Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED

// Audited by ZachXBT

pragma solidity ^0.8.18;

import "./Ownable.sol";
import "./Math.sol";

contract NetworkController is Ownable {
	struct BulkWithdraw {
		address destination;
		uint256 amount;
	}

	// Current sending mode
	bool public forwarding;

	// Receives donations when mode == Forwarding
	address public beneficiary;

	// Mapping of people who are approved to withdraw
	mapping(address => bool) withdrawApprovals;

	constructor(address _beneficiary, bool _forwarding) {
		forwarding = _forwarding;
		beneficiary = _beneficiary;
	}

	/*
	 * @dev Checks if a user is allowed to withdraw
	 */
	modifier allowedToWithdraw() {
		require(
			msg.sender == owner() || withdrawApprovals[msg.sender],
			"WITHDRAW APPROVED ONLY!"
		);
		_;
	}

	/*
	 * @dev Changes between Holding and Forwarding mode
	 */
	function setForwarding(bool _forwarding) external onlyOwner {
		require(_forwarding != forwarding, "SAME MODE!");

		forwarding = _forwarding;
	}

	/*
	 * @dev Sets the beneficiary for Forward mode
	 */
	function setBeneficiary(address newBeneficiary) external onlyOwner {
		beneficiary = newBeneficiary;
	}

	/*
	 * @dev Approves or revokes permissions to call withdraw functions
	 */
	function approveWithdraw(address member, bool allowed) external onlyOwner {
		withdrawApprovals[member] = allowed;
	}

	/*
	 * @dev Takes in multiple withdraw calls
	 */
	function withdrawToBulk(
		BulkWithdraw[] calldata withdraws
	) external allowedToWithdraw {
		for (uint8 i = 0; i < withdraws.length; ++i) {
			(bool sent, ) = withdraws[i].destination.call{
				value: withdraws[i].amount
			}("");

			require(sent, "FAILURE");
		}
	}

	/*
	 * @dev Withdraws to a specific destination
	 */
	function withdrawTo(
		address destination,
		uint256 amount
	) external allowedToWithdraw {
		uint256 amountToWithdraw = Math.min(amount, address(this).balance);

		(bool sent, ) = destination.call{value: amountToWithdraw}("");
		require(sent, "FAILURE");
	}

	/*
	 * @dev Withdraws total balance to approved caller
	 */
	function withdraw() external allowedToWithdraw {
		(bool sent, ) = msg.sender.call{value: address(this).balance}("");
		require(sent, "FAILURE");
	}

	/*
	 * @dev Called upon recieving ETH
	 */
	function _mergeAction() internal {
		if (forwarding) {
			(bool sent, ) = beneficiary.call{value: msg.value}("");
			require(sent, "FAILURE");
		}
	}

	/*
	 * @dev Called on ETH sends with data
	 */
	fallback() external payable {
		_mergeAction();
	}

	/*
	 * @dev Called on ETH sends with no data
	 */
	receive() external payable {
		_mergeAction();
	}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_beneficiary","type":"address"},{"internalType":"bool","name":"_forwarding","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"member","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"name":"approveWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"beneficiary","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forwarding","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newBeneficiary","type":"address"}],"name":"setBeneficiary","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_forwarding","type":"bool"}],"name":"setForwarding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct NetworkController.BulkWithdraw[]","name":"withdraws","type":"tuple[]"}],"name":"withdrawToBulk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000009fa7bb759641fcd37fe4ae41f725e0f653f2c7260000000000000000000000000000000000000000000000000000000000000001

-----Decoded View---------------
Arg [0] : _beneficiary (address): 0x9fA7bB759641FCd37fe4aE41f725e0f653f2C726
Arg [1] : _forwarding (bool): True

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000009fa7bb759641fcd37fe4ae41f725e0f653f2c726
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000001

144:2586:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2708:14;:12;:14::i;:::-;144:2586;;2598:14;:12;:14::i;:::-;144:2586;1475:279;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1107:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1816:267;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;361:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2152:151;;;;;;;;;;;;;:::i;:::-;;285:22;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;894:149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1824:101:3;;;;;;;;;;;;;:::i;:::-;;1194:85;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1297:119:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2074:198:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2355:154:2;2397:10;;;;;;;;;;;2393:112;;;2416:9;2431:11;;;;;;;;;;;:16;;2455:9;2431:38;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2415:54;;;2483:4;2475:24;;;;;;;;;;;;:::i;:::-;;;;;;;;;2409:96;2393:112;2355:154::o;1475:279::-;737:7;:5;:7::i;:::-;723:21;;:10;:21;;;:54;;;;748:17;:29;766:10;748:29;;;;;;;;;;;;;;;;;;;;;;;;;723:54;710:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;1578:7:::1;1573:177;1595:9;;:16;;1591:1;:20;;;1573:177;;;1625:9;1640;;1650:1;1640:12;;;;;;;;;:::i;:::-;;;;;;;:24;;;;;;;;;;:::i;:::-;:29;;1683:9;;1693:1;1683:12;;;;;;;;;:::i;:::-;;;;;;;:19;;;1640:72;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1624:88;;;1728:4;1720:24;;;;;;;;;;;;:::i;:::-;;;;;;;;;1618:132;1613:3;;;;:::i;:::-;;;1573:177;;;;1475:279:::0;;:::o;1107:105::-;1087:13:3;:11;:13::i;:::-;1193:14:2::1;1179:11;;:28;;;;;;;;;;;;;;;;;;1107:105:::0;:::o;1816:267::-;737:7;:5;:7::i;:::-;723:21;;:10;:21;;;:54;;;;748:17;:29;766:10;748:29;;;;;;;;;;;;;;;;;;;;;;;;;723:54;710:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;1915:24:::1;1942:39;1951:6;1959:21;1942:8;:39::i;:::-;1915:66;;1989:9;2004:11;:16;;2028;2004:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1988:61;;;2062:4;2054:24;;;;;;;;;;;;:::i;:::-;;;;;;;;;1910:173;;1816:267:::0;;:::o;361:26::-;;;;;;;;;;;;;:::o;2152:151::-;737:7;:5;:7::i;:::-;723:21;;:10;:21;;;:54;;;;748:17;:29;766:10;748:29;;;;;;;;;;;;;;;;;;;;;;;;;723:54;710:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;2205:9:::1;2220:10;:15;;2243:21;2220:49;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2204:65;;;2282:4;2274:24;;;;;;;;;;;;:::i;:::-;;;;;;;;;2199:104;2152:151::o:0;285:22::-;;;;;;;;;;;;;:::o;894:149::-;1087:13:3;:11;:13::i;:::-;982:10:2::1;;;;;;;;;;;967:25;;:11;:25;;::::0;959:48:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;1027:11;1014:10;;:24;;;;;;;;;;;;;;;;;;894:149:::0;:::o;1824:101:3:-;1087:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;:::-;1824:101::o:0;1194:85::-;1240:7;1266:6;;;;;;;;;;;1259:13;;1194:85;:::o;1297:119:2:-;1087:13:3;:11;:13::i;:::-;1404:7:2::1;1376:17;:25;1394:6;1376:25;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;1297:119:::0;;:::o;2074:198:3:-;1087:13;:11;:13::i;:::-;2182:1:::1;2162:22;;:8;:22;;::::0;2154:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;2237:28;2256:8;2237:18;:28::i;:::-;2074:198:::0;:::o;1352:130::-;1426:12;:10;:12::i;:::-;1415:23;;:7;:5;:7::i;:::-;:23;;;1407:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1352:130::o;588:104:1:-;646:7;676:1;672;:5;:13;;684:1;672:13;;;680:1;672:13;665:20;;588:104;;;;:::o;2426:187:3:-;2499:16;2518:6;;;;;;;;;;;2499:25;;2543:8;2534:6;;:17;;;;;;;;;;;;;;;;;;2597:8;2566:40;;2587:8;2566:40;;;;;;;;;;;;2489:124;2426:187;:::o;640:96:0:-;693:7;719:10;712:17;;640:96;:::o;88:117:4:-;197:1;194;187:12;211:117;320:1;317;310:12;334:117;443:1;440;433:12;457:117;566:1;563;556:12;580:117;689:1;686;679:12;750:599;854:8;864:6;914:3;907:4;899:6;895:17;891:27;881:122;;922:79;;:::i;:::-;881:122;1035:6;1022:20;1012:30;;1065:18;1057:6;1054:30;1051:117;;;1087:79;;:::i;:::-;1051:117;1201:4;1193:6;1189:17;1177:29;;1255:3;1247:4;1239:6;1235:17;1225:8;1221:32;1218:41;1215:128;;;1262:79;;:::i;:::-;1215:128;750:599;;;;;:::o;1355:621::-;1472:6;1480;1529:2;1517:9;1508:7;1504:23;1500:32;1497:119;;;1535:79;;:::i;:::-;1497:119;1683:1;1672:9;1668:17;1655:31;1713:18;1705:6;1702:30;1699:117;;;1735:79;;:::i;:::-;1699:117;1848:111;1951:7;1942:6;1931:9;1927:22;1848:111;:::i;:::-;1830:129;;;;1626:343;1355:621;;;;;:::o;1982:126::-;2019:7;2059:42;2052:5;2048:54;2037:65;;1982:126;;;:::o;2114:96::-;2151:7;2180:24;2198:5;2180:24;:::i;:::-;2169:35;;2114:96;;;:::o;2216:122::-;2289:24;2307:5;2289:24;:::i;:::-;2282:5;2279:35;2269:63;;2328:1;2325;2318:12;2269:63;2216:122;:::o;2344:139::-;2390:5;2428:6;2415:20;2406:29;;2444:33;2471:5;2444:33;:::i;:::-;2344:139;;;;:::o;2489:329::-;2548:6;2597:2;2585:9;2576:7;2572:23;2568:32;2565:119;;;2603:79;;:::i;:::-;2565:119;2723:1;2748:53;2793:7;2784:6;2773:9;2769:22;2748:53;:::i;:::-;2738:63;;2694:117;2489:329;;;;:::o;2824:77::-;2861:7;2890:5;2879:16;;2824:77;;;:::o;2907:122::-;2980:24;2998:5;2980:24;:::i;:::-;2973:5;2970:35;2960:63;;3019:1;3016;3009:12;2960:63;2907:122;:::o;3035:139::-;3081:5;3119:6;3106:20;3097:29;;3135:33;3162:5;3135:33;:::i;:::-;3035:139;;;;:::o;3180:474::-;3248:6;3256;3305:2;3293:9;3284:7;3280:23;3276:32;3273:119;;;3311:79;;:::i;:::-;3273:119;3431:1;3456:53;3501:7;3492:6;3481:9;3477:22;3456:53;:::i;:::-;3446:63;;3402:117;3558:2;3584:53;3629:7;3620:6;3609:9;3605:22;3584:53;:::i;:::-;3574:63;;3529:118;3180:474;;;;;:::o;3660:118::-;3747:24;3765:5;3747:24;:::i;:::-;3742:3;3735:37;3660:118;;:::o;3784:222::-;3877:4;3915:2;3904:9;3900:18;3892:26;;3928:71;3996:1;3985:9;3981:17;3972:6;3928:71;:::i;:::-;3784:222;;;;:::o;4012:90::-;4046:7;4089:5;4082:13;4075:21;4064:32;;4012:90;;;:::o;4108:109::-;4189:21;4204:5;4189:21;:::i;:::-;4184:3;4177:34;4108:109;;:::o;4223:210::-;4310:4;4348:2;4337:9;4333:18;4325:26;;4361:65;4423:1;4412:9;4408:17;4399:6;4361:65;:::i;:::-;4223:210;;;;:::o;4439:116::-;4509:21;4524:5;4509:21;:::i;:::-;4502:5;4499:32;4489:60;;4545:1;4542;4535:12;4489:60;4439:116;:::o;4561:133::-;4604:5;4642:6;4629:20;4620:29;;4658:30;4682:5;4658:30;:::i;:::-;4561:133;;;;:::o;4700:323::-;4756:6;4805:2;4793:9;4784:7;4780:23;4776:32;4773:119;;;4811:79;;:::i;:::-;4773:119;4931:1;4956:50;4998:7;4989:6;4978:9;4974:22;4956:50;:::i;:::-;4946:60;;4902:114;4700:323;;;;:::o;5029:468::-;5094:6;5102;5151:2;5139:9;5130:7;5126:23;5122:32;5119:119;;;5157:79;;:::i;:::-;5119:119;5277:1;5302:53;5347:7;5338:6;5327:9;5323:22;5302:53;:::i;:::-;5292:63;;5248:117;5404:2;5430:50;5472:7;5463:6;5452:9;5448:22;5430:50;:::i;:::-;5420:60;;5375:115;5029:468;;;;;:::o;5503:147::-;5604:11;5641:3;5626:18;;5503:147;;;;:::o;5656:114::-;;:::o;5776:398::-;5935:3;5956:83;6037:1;6032:3;5956:83;:::i;:::-;5949:90;;6048:93;6137:3;6048:93;:::i;:::-;6166:1;6161:3;6157:11;6150:18;;5776:398;;;:::o;6180:379::-;6364:3;6386:147;6529:3;6386:147;:::i;:::-;6379:154;;6550:3;6543:10;;6180:379;;;:::o;6565:169::-;6649:11;6683:6;6678:3;6671:19;6723:4;6718:3;6714:14;6699:29;;6565:169;;;;:::o;6740:157::-;6880:9;6876:1;6868:6;6864:14;6857:33;6740:157;:::o;6903:365::-;7045:3;7066:66;7130:1;7125:3;7066:66;:::i;:::-;7059:73;;7141:93;7230:3;7141:93;:::i;:::-;7259:2;7254:3;7250:12;7243:19;;6903:365;;;:::o;7274:419::-;7440:4;7478:2;7467:9;7463:18;7455:26;;7527:9;7521:4;7517:20;7513:1;7502:9;7498:17;7491:47;7555:131;7681:4;7555:131;:::i;:::-;7547:139;;7274:419;;;:::o;7699:173::-;7839:25;7835:1;7827:6;7823:14;7816:49;7699:173;:::o;7878:366::-;8020:3;8041:67;8105:2;8100:3;8041:67;:::i;:::-;8034:74;;8117:93;8206:3;8117:93;:::i;:::-;8235:2;8230:3;8226:12;8219:19;;7878:366;;;:::o;8250:419::-;8416:4;8454:2;8443:9;8439:18;8431:26;;8503:9;8497:4;8493:20;8489:1;8478:9;8474:17;8467:47;8531:131;8657:4;8531:131;:::i;:::-;8523:139;;8250:419;;;:::o;8675:180::-;8723:77;8720:1;8713:88;8820:4;8817:1;8810:15;8844:4;8841:1;8834:15;8861:180;8909:77;8906:1;8899:88;9006:4;9003:1;8996:15;9030:4;9027:1;9020:15;9047:86;9082:7;9122:4;9115:5;9111:16;9100:27;;9047:86;;;:::o;9139:167::-;9176:3;9199:22;9215:5;9199:22;:::i;:::-;9190:31;;9243:4;9236:5;9233:15;9230:41;;9251:18;;:::i;:::-;9230:41;9298:1;9291:5;9287:13;9280:20;;9139:167;;;:::o;9312:160::-;9452:12;9448:1;9440:6;9436:14;9429:36;9312:160;:::o;9478:366::-;9620:3;9641:67;9705:2;9700:3;9641:67;:::i;:::-;9634:74;;9717:93;9806:3;9717:93;:::i;:::-;9835:2;9830:3;9826:12;9819:19;;9478:366;;;:::o;9850:419::-;10016:4;10054:2;10043:9;10039:18;10031:26;;10103:9;10097:4;10093:20;10089:1;10078:9;10074:17;10067:47;10131:131;10257:4;10131:131;:::i;:::-;10123:139;;9850:419;;;:::o;10275:225::-;10415:34;10411:1;10403:6;10399:14;10392:58;10484:8;10479:2;10471:6;10467:15;10460:33;10275:225;:::o;10506:366::-;10648:3;10669:67;10733:2;10728:3;10669:67;:::i;:::-;10662:74;;10745:93;10834:3;10745:93;:::i;:::-;10863:2;10858:3;10854:12;10847:19;;10506:366;;;:::o;10878:419::-;11044:4;11082:2;11071:9;11067:18;11059:26;;11131:9;11125:4;11121:20;11117:1;11106:9;11102:17;11095:47;11159:131;11285:4;11159:131;:::i;:::-;11151:139;;10878:419;;;:::o;11303:182::-;11443:34;11439:1;11431:6;11427:14;11420:58;11303:182;:::o;11491:366::-;11633:3;11654:67;11718:2;11713:3;11654:67;:::i;:::-;11647:74;;11730:93;11819:3;11730:93;:::i;:::-;11848:2;11843:3;11839:12;11832:19;;11491:366;;;:::o;11863:419::-;12029:4;12067:2;12056:9;12052:18;12044:26;;12116:9;12110:4;12106:20;12102:1;12091:9;12087:17;12080:47;12144:131;12270:4;12144:131;:::i;:::-;12136:139;;11863:419;;;:::o

ipfs://cfb69e2827a4e932080edb083b1c0155b827be0fdad73664bf43ae78f7152e20