Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(
•    - function mod(uint256 a, uint256 b)
•    - function mod(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
• functionStaticCall(
•    - function functionStaticCall(
•    - function _verifyCallResult(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• interface IProxy
•    - function batchExec(
•    - function execs(
• interface IRegistry
•    - function handlers(address)
•    - function callers(address)
•    - function bannedAgents(address)
•    - function fHalt()
•    - function isValidHandler(address handl ...
•    - function isValidCaller(address handle ...
•  contract Config
• library LibCache
•    - function set(
•    - function setAddress(
•    - function setUint256(
•    - function getAddress(
•    - function getUint256(
•    - function get(mapping(bytes32 =&gt ...
• library LibStack
•    - function setAddress(bytes32[] storage ...
•    - function set(bytes32[] storage _stack ...
•    - function setHandlerType(bytes32[] sto ...
•    - function getAddress(bytes32[] storage ...
•    - function getSig(bytes32[] storage _st ...
•    - function get(bytes32[] storage _stack ...
•    - function peek(bytes32[] storage _stac ...
•  contract Storage
•    - function _setSender()
•    - function _resetSender()
•    - function _getSender()
•    - function _addCubeCounter()
•    - function _resetCubeCounter()
•    - function _getCubeCounter()
• library LibParam
•    - function isStatic(bytes32 conf)
•    - function isReferenced(bytes32 conf)
•    - function getReturnNum(bytes32 conf)
•    - function getParams(bytes32 conf)
•  contract Proxy is IProxy, Storage, ... *
•    - function batchExec(
•    - function execs(
•    - function _execs(
•    - function _trim(
•    - function _parse(
•    - function _exec(address _to, bytes mem ...
•    - function _setPostProcess(address _to)
•    - function _preProcess()
•    - function _postProcess()
•    - function _isValidHandler(address hand ...
•    - function _isValidCaller(address calle ...

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-05-11
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) =
            target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).add(value);
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance =
            token.allowance(address(this), spender).sub(
                value,
                "SafeERC20: decreased allowance below zero"
            );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata =
            address(token).functionCall(
                data,
                "SafeERC20: low-level call failed"
            );
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// File: contracts/interface/IProxy.sol

pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

interface IProxy {
    function batchExec(
        address[] calldata tos,
        bytes32[] calldata configs,
        bytes[] memory datas
    ) external payable;

    function execs(
        address[] calldata tos,
        bytes32[] calldata configs,
        bytes[] memory datas
    ) external payable;
}

// File: contracts/interface/IRegistry.sol

pragma solidity ^0.6.0;

interface IRegistry {
    function handlers(address) external view returns (bytes32);

    function callers(address) external view returns (bytes32);

    function bannedAgents(address) external view returns (uint256);

    function fHalt() external view returns (bool);

    function isValidHandler(address handler) external view returns (bool);

    function isValidCaller(address handler) external view returns (bool);
}

// File: contracts/Config.sol

pragma solidity ^0.6.0;

contract Config {
    // function signature of "postProcess()"
    bytes4 public constant POSTPROCESS_SIG = 0xc2722916;

    // The base amount of percentage function
    uint256 public constant PERCENTAGE_BASE = 1 ether;

    // Handler post-process type. Others should not happen now.
    enum HandlerType {Token, Custom, Others}
}

// File: contracts/lib/LibCache.sol

pragma solidity ^0.6.0;

library LibCache {
    function set(
        mapping(bytes32 => bytes32) storage _cache,
        bytes32 _key,
        bytes32 _value
    ) internal {
        _cache[_key] = _value;
    }

    function setAddress(
        mapping(bytes32 => bytes32) storage _cache,
        bytes32 _key,
        address _value
    ) internal {
        _cache[_key] = bytes32(uint256(uint160(_value)));
    }

    function setUint256(
        mapping(bytes32 => bytes32) storage _cache,
        bytes32 _key,
        uint256 _value
    ) internal {
        _cache[_key] = bytes32(_value);
    }

    function getAddress(
        mapping(bytes32 => bytes32) storage _cache,
        bytes32 _key
    ) internal view returns (address ret) {
        ret = address(uint160(uint256(_cache[_key])));
    }

    function getUint256(
        mapping(bytes32 => bytes32) storage _cache,
        bytes32 _key
    ) internal view returns (uint256 ret) {
        ret = uint256(_cache[_key]);
    }

    function get(mapping(bytes32 => bytes32) storage _cache, bytes32 _key)
        internal
        view
        returns (bytes32 ret)
    {
        ret = _cache[_key];
    }
}

// File: contracts/lib/LibStack.sol

pragma solidity ^0.6.0;

library LibStack {
    function setAddress(bytes32[] storage _stack, address _input) internal {
        _stack.push(bytes32(uint256(uint160(_input))));
    }

    function set(bytes32[] storage _stack, bytes32 _input) internal {
        _stack.push(_input);
    }

    function setHandlerType(bytes32[] storage _stack, Config.HandlerType _input)
        internal
    {
        _stack.push(bytes12(uint96(_input)));
    }

    function getAddress(bytes32[] storage _stack)
        internal
        returns (address ret)
    {
        ret = address(uint160(uint256(peek(_stack))));
        _stack.pop();
    }

    function getSig(bytes32[] storage _stack) internal returns (bytes4 ret) {
        ret = bytes4(peek(_stack));
        _stack.pop();
    }

    function get(bytes32[] storage _stack) internal returns (bytes32 ret) {
        ret = peek(_stack);
        _stack.pop();
    }

    function peek(bytes32[] storage _stack)
        internal
        view
        returns (bytes32 ret)
    {
        require(_stack.length > 0, "stack empty");
        ret = _stack[_stack.length - 1];
    }
}

// File: contracts/Storage.sol

pragma solidity ^0.6.0;

/// @notice A cache structure composed by a bytes32 array
contract Storage {
    using LibCache for mapping(bytes32 => bytes32);
    using LibStack for bytes32[];

    bytes32[] public stack;
    mapping(bytes32 => bytes32) public cache;

    // keccak256 hash of "msg.sender"
    // prettier-ignore
    bytes32 public constant MSG_SENDER_KEY = 0xb2f2618cecbbb6e7468cc0f2aa43858ad8d153e0280b22285e28e853bb9d453a;

    // keccak256 hash of "cube.counter"
    // prettier-ignore
    bytes32 public constant CUBE_COUNTER_KEY = 0xf9543f11459ccccd21306c8881aaab675ff49d988c1162fd1dd9bbcdbe4446be;

    modifier isStackEmpty() {
        require(stack.length == 0, "Stack not empty");
        _;
    }

    modifier isCubeCounterZero() {
        require(_getCubeCounter() == 0, "Cube counter not zero");
        _;
    }

    modifier isInitialized() {
        require(_getSender() != address(0), "Sender is not initialized");
        _;
    }

    modifier isNotInitialized() {
        require(_getSender() == address(0), "Sender is initialized");
        _;
    }

    function _setSender() internal isNotInitialized {
        cache.setAddress(MSG_SENDER_KEY, msg.sender);
    }

    function _resetSender() internal {
        cache.setAddress(MSG_SENDER_KEY, address(0));
    }

    function _getSender() internal view returns (address) {
        return cache.getAddress(MSG_SENDER_KEY);
    }

    function _addCubeCounter() internal {
        cache.setUint256(CUBE_COUNTER_KEY, _getCubeCounter() + 1);
    }

    function _resetCubeCounter() internal {
        cache.setUint256(CUBE_COUNTER_KEY, 0);
    }

    function _getCubeCounter() internal view returns (uint256) {
        return cache.getUint256(CUBE_COUNTER_KEY);
    }
}

// File: contracts/lib/LibParam.sol

pragma solidity ^0.6.0;

library LibParam {
    bytes32 private constant STATIC_MASK =
        0x0100000000000000000000000000000000000000000000000000000000000000;
    bytes32 private constant PARAMS_MASK =
        0x0000000000000000000000000000000000000000000000000000000000000001;
    bytes32 private constant REFS_MASK =
        0x00000000000000000000000000000000000000000000000000000000000000FF;
    bytes32 private constant RETURN_NUM_MASK =
        0x00FF000000000000000000000000000000000000000000000000000000000000;

    uint256 private constant REFS_LIMIT = 22;
    uint256 private constant PARAMS_SIZE_LIMIT = 64;
    uint256 private constant RETURN_NUM_OFFSET = 240;

    function isStatic(bytes32 conf) internal pure returns (bool) {
        if (conf & STATIC_MASK == 0) return true;
        else return false;
    }

    function isReferenced(bytes32 conf) internal pure returns (bool) {
        if (getReturnNum(conf) == 0) return false;
        else return true;
    }

    function getReturnNum(bytes32 conf) internal pure returns (uint256 num) {
        bytes32 temp = (conf & RETURN_NUM_MASK) >> RETURN_NUM_OFFSET;
        num = uint256(temp);
    }

    function getParams(bytes32 conf)
        internal
        pure
        returns (uint256[] memory refs, uint256[] memory params)
    {
        require(!isStatic(conf), "Static params");
        uint256 n = REFS_LIMIT;
        while (conf & REFS_MASK == REFS_MASK && n > 0) {
            n--;
            conf = conf >> 8;
        }
        require(n > 0, "No dynamic param");
        refs = new uint256[](n);
        params = new uint256[](n);
        for (uint256 i = 0; i < n; i++) {
            refs[i] = uint256(conf & REFS_MASK);
            conf = conf >> 8;
        }
        uint256 i = 0;
        for (uint256 k = 0; k < PARAMS_SIZE_LIMIT; k++) {
            if (conf & PARAMS_MASK != 0) {
                require(i < n, "Location count exceeds ref count");
                params[i] = k * 32 + 4;
                i++;
            }
            conf = conf >> 1;
        }
        require(i == n, "Location count less than ref count");
    }
}

// File: contracts/Proxy.sol

pragma solidity ^0.6.0;

/**
 * @title The entrance of Furucombo
 * @author Ben Huang
 */
contract Proxy is IProxy, Storage, Config {
    using Address for address;
    using SafeERC20 for IERC20;
    using LibParam for bytes32;

    modifier isNotBanned(address agent) {
        require(registry.bannedAgents(agent) == 0, "Banned");
        _;
    }

    modifier isNotHalted() {
        require(registry.fHalt() == false, "Halted");
        _;
    }

    IRegistry public immutable registry;

    constructor(address _registry) public {
        registry = IRegistry(_registry);
    }

    /**
     * @notice Direct transfer from EOA should be reverted.
     * @dev Callback function will be handled here.
     */
    fallback()
        external
        payable
        isNotHalted
        isNotBanned(msg.sender)
        isInitialized
    {
        // If triggered by a function call, caller should be registered in
        // registry.
        // The function call will then be forwarded to the location registered
        // in registry.
        require(_isValidCaller(msg.sender), "Invalid caller");

        address target = address(bytes20(registry.callers(msg.sender)));
        bytes memory result = _exec(target, msg.data);

        // return result for aave v2 flashloan()
        uint256 size = result.length;
        assembly {
            let loc := add(result, 0x20)
            return(loc, size)
        }
    }

    /**
     * @notice Direct transfer from EOA should be reverted.
     */
    receive() external payable {
        require(Address.isContract(msg.sender), "Not allowed from EOA");
    }

    /**
     * @notice Combo execution function. Including three phases: pre-process,
     * exection and post-process.
     * @param tos The handlers of combo.
     * @param configs The configurations of executing cubes.
     * @param datas The combo datas.
     */
    function batchExec(
        address[] calldata tos,
        bytes32[] calldata configs,
        bytes[] memory datas
    ) external payable override isNotHalted isNotBanned(msg.sender) {
        _preProcess();
        _execs(tos, configs, datas);
        _postProcess();
    }

    /**
     * @notice The execution interface for callback function to be executed.
     * @dev This function can only be called through the handler, which makes
     * the caller become proxy itself.
     */
    function execs(
        address[] calldata tos,
        bytes32[] calldata configs,
        bytes[] memory datas
    )
        external
        payable
        override
        isNotHalted
        isNotBanned(msg.sender)
        isInitialized
    {
        require(msg.sender == address(this), "Does not allow external calls");
        _execs(tos, configs, datas);
    }

    /**
     * @notice The execution phase.
     * @param tos The handlers of combo.
     * @param configs The configurations of executing cubes.
     * @param datas The combo datas.
     */
    function _execs(
        address[] memory tos,
        bytes32[] memory configs,
        bytes[] memory datas
    ) internal {
        bytes32[256] memory localStack;
        uint256 index = 0;

        require(
            tos.length == datas.length,
            "Tos and datas length inconsistent"
        );
        require(
            tos.length == configs.length,
            "Tos and configs length inconsistent"
        );
        for (uint256 i = 0; i < tos.length; i++) {
            bytes32 config = configs[i];
            // Check if the data contains dynamic parameter
            if (!config.isStatic()) {
                // If so, trim the exectution data base on the configuration and stack content
                _trim(datas[i], config, localStack, index);
            }
            // Check if the output will be referenced afterwards
            bytes memory result = _exec(tos[i], datas[i]);
            if (config.isReferenced()) {
                // If so, parse the output and place it into local stack
                uint256 num = config.getReturnNum();
                uint256 newIndex = _parse(localStack, result, index);
                require(
                    newIndex == index + num,
                    "Return num and parsed return num not matched"
                );
                index = newIndex;
            }

            // Setup the process to be triggered in the post-process phase
            _setPostProcess(tos[i]);
        }
    }

    /**
     * @notice Trimming the execution data.
     * @param data The execution data.
     * @param config The configuration.
     * @param localStack The stack the be referenced.
     * @param index Current element count of localStack.
     */
    function _trim(
        bytes memory data,
        bytes32 config,
        bytes32[256] memory localStack,
        uint256 index
    ) internal pure {
        // Fetch the parameter configuration from config
        (uint256[] memory refs, uint256[] memory params) = config.getParams();
        // Trim the data with the reference and parameters
        for (uint256 i = 0; i < refs.length; i++) {
            require(refs[i] < index, "Reference to out of localStack");
            bytes32 ref = localStack[refs[i]];
            uint256 offset = params[i];
            uint256 base = PERCENTAGE_BASE;
            assembly {
                let loc := add(add(data, 0x20), offset)
                let m := mload(loc)
                // Adjust the value by multiplier if a dynamic parameter is not zero
                if iszero(iszero(m)) {
                    // Assert no overflow first
                    let p := mul(m, ref)
                    if iszero(eq(div(p, m), ref)) {
                        revert(0, 0)
                    } // require(p / m == ref)
                    ref := div(p, base)
                }
                mstore(loc, ref)
            }
        }
    }

    /**
     * @notice Parse the return data to the local stack.
     * @param localStack The local stack to place the return values.
     * @param ret The return data.
     * @param index The current tail.
     */
    function _parse(
        bytes32[256] memory localStack,
        bytes memory ret,
        uint256 index
    ) internal pure returns (uint256 newIndex) {
        uint256 len = ret.length;
        // The return value should be multiple of 32-bytes to be parsed.
        require(len % 32 == 0, "illegal length for _parse");
        // Estimate the tail after the process.
        newIndex = index + len / 32;
        require(newIndex <= 256, "stack overflow");
        assembly {
            let offset := shl(5, index)
            // Store the data into localStack
            for {
                let i := 0
            } lt(i, len) {
                i := add(i, 0x20)
            } {
                mstore(
                    add(localStack, add(i, offset)),
                    mload(add(add(ret, i), 0x20))
                )
            }
        }
    }

    /**
     * @notice The execution of a single cube.
     * @param _to The handler of cube.
     * @param _data The cube execution data.
     */
    function _exec(address _to, bytes memory _data)
        internal
        returns (bytes memory result)
    {
        require(_isValidHandler(_to), "Invalid handler");
        _addCubeCounter();
        assembly {
            let succeeded := delegatecall(
                sub(gas(), 5000),
                _to,
                add(_data, 0x20),
                mload(_data),
                0,
                0
            )
            let size := returndatasize()

            result := mload(0x40)
            mstore(
                0x40,
                add(result, and(add(add(size, 0x20), 0x1f), not(0x1f)))
            )
            mstore(result, size)
            returndatacopy(add(result, 0x20), 0, size)

            switch iszero(succeeded)
                case 1 {
                    revert(add(result, 0x20), size)
                }
        }
    }

    /**
     * @notice Setup the post-process.
     * @param _to The handler of post-process.
     */
    function _setPostProcess(address _to) internal {
        // If the stack length equals 0, just skip
        // If the top is a custom post-process, replace it with the handler
        // address.
        if (stack.length == 0) {
            return;
        } else if (
            stack.peek() == bytes32(bytes12(uint96(HandlerType.Custom)))
        ) {
            stack.pop();
            // Check if the handler is already set.
            if (bytes4(stack.peek()) != 0x00000000) stack.setAddress(_to);
            stack.setHandlerType(HandlerType.Custom);
        }
    }

    /// @notice The pre-process phase.
    function _preProcess() internal virtual isStackEmpty isCubeCounterZero {
        // Set the sender.
        _setSender();
    }

    /// @notice The post-process phase.
    function _postProcess() internal {
        // If the top of stack is HandlerType.Custom (which makes it being zero
        // address when `stack.getAddress()`), get the handler address and execute
        // the handler with it and the post-process function selector.
        // If not, use it as token address and send the token back to user.
        while (stack.length > 0) {
            address addr = stack.getAddress();
            if (addr == address(0)) {
                addr = stack.getAddress();
                _exec(addr, abi.encodeWithSelector(POSTPROCESS_SIG));
            } else {
                uint256 amount = IERC20(addr).balanceOf(address(this));
                if (amount > 0) IERC20(addr).safeTransfer(msg.sender, amount);
            }
        }

        // Balance should also be returned to user
        uint256 amount = address(this).balance;
        if (amount > 0) msg.sender.transfer(amount);

        // Reset the msg.sender and cube counter
        _resetSender();
        _resetCubeCounter();
    }

    /// @notice Check if the handler is valid in registry.
    function _isValidHandler(address handler) internal view returns (bool) {
        return registry.isValidHandler(handler);
    }

    /// @notice Check if the caller is valid in registry.
    function _isValidCaller(address caller) internal view returns (bool) {
        return registry.isValidCaller(caller);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_registry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"CUBE_COUNTER_KEY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MSG_SENDER_KEY","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTAGE_BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POSTPROCESS_SIG","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes32[]","name":"configs","type":"bytes32[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"batchExec","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"cache","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"bytes32[]","name":"configs","type":"bytes32[]"},{"internalType":"bytes[]","name":"datas","type":"bytes[]"}],"name":"execs","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"registry","outputs":[{"internalType":"contract IRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stack","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

60a060405234801561001057600080fd5b50604051611e56380380611e5683398101604081905261002f91610044565b60601b6001600160601b031916608052610072565b600060208284031215610055578081fd5b81516001600160a01b038116811461006b578182fd5b9392505050565b60805160601c611d9b6100bb6000398060c15280610186528061029852806104b552806105e552806106aa52806107d5528061089a52806109fd5280610a935250611d9b6000f3fe60806040526004361061008a5760003560e01c80637b103999116100595780637b103999146103d857806387c13943146103fa57806399eb59b91461040f578063dc9031c41461042f578063fa2901a51461044f576100bf565b80630f532d18146103725780631413dc7d1461039d57806338c5c08e146103b257806371938509146103c5576100bf565b366100bf5761009833610471565b6100bd5760405162461bcd60e51b81526004016100b490611984565b60405180910390fd5b005b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663ea750af66040518163ffffffff1660e01b815260040160206040518083038186803b15801561011857600080fd5b505afa15801561012c573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061015091906116f6565b1561016d5760405162461bcd60e51b81526004016100b490611aa5565b604051630c81ee5560e11b815233906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690631903dcaa906101bb908490600401611762565b60206040518083038186803b1580156101d357600080fd5b505afa1580156101e7573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061020b919061172e565b156102285760405162461bcd60e51b81526004016100b4906119b2565b600061023261047b565b6001600160a01b031614156102595760405162461bcd60e51b81526004016100b4906117e0565b6102623361049b565b61027e5760405162461bcd60e51b81526004016100b490611841565b604051637bbf4a3f60e01b81526000906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690637bbf4a3f906102cd903390600401611762565b60206040518083038186803b1580156102e557600080fd5b505afa1580156102f9573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061031d919061172e565b60601c90506060610365826000368080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061054092505050565b8051909150602082018181f35b34801561037e57600080fd5b506103876105bf565b604051610394919061178f565b60405180910390f35b3480156103a957600080fd5b506103876105d1565b6100bd6103c0366004611612565b6105e3565b6100bd6103d3366004611612565b6107d3565b3480156103e457600080fd5b506103ed6109fb565b6040516103949190611762565b34801561040657600080fd5b50610387610a1f565b34801561041b57600080fd5b5061038761042a366004611716565b610a2b565b34801561043b57600080fd5b5061038761044a366004611716565b610a3d565b34801561045b57600080fd5b50610464610a5b565b6040516103949190611798565b803b15155b919050565b60006104966001600080516020611d26833981519152610a66565b905090565b60405163bb1010e960e01b81526000906001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063bb1010e9906104ea908590600401611762565b60206040518083038186803b15801561050257600080fd5b505afa158015610516573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061053a91906116f6565b92915050565b606061054b83610a79565b6105675760405162461bcd60e51b81526004016100b4906119f9565b61056f610ac8565b600080835160208501866113885a03f43d6040519250601f19601f6020830101168301604052808352806000602085013e8115600181146105af576105b6565b8160208501fd5b50505092915050565b600080516020611d2683398151915281565b600080516020611d4683398151915281565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663ea750af66040518163ffffffff1660e01b815260040160206040518083038186803b15801561063c57600080fd5b505afa158015610650573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061067491906116f6565b156106915760405162461bcd60e51b81526004016100b490611aa5565b604051630c81ee5560e11b815233906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690631903dcaa906106df908490600401611762565b60206040518083038186803b1580156106f757600080fd5b505afa15801561070b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061072f919061172e565b1561074c5760405162461bcd60e51b81526004016100b4906119b2565b610754610aef565b6107c386868080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050604080516020808a02828101820190935289825290935089925088918291850190849080828437600092019190915250879250610b3c915050565b6107cb610c81565b505050505050565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663ea750af66040518163ffffffff1660e01b815260040160206040518083038186803b15801561082c57600080fd5b505afa158015610840573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061086491906116f6565b156108815760405162461bcd60e51b81526004016100b490611aa5565b604051630c81ee5560e11b815233906001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690631903dcaa906108cf908490600401611762565b60206040518083038186803b1580156108e757600080fd5b505afa1580156108fb573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061091f919061172e565b1561093c5760405162461bcd60e51b81526004016100b4906119b2565b600061094661047b565b6001600160a01b0316141561096d5760405162461bcd60e51b81526004016100b4906117e0565b33301461098c5760405162461bcd60e51b81526004016100b490611a22565b6107cb86868080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050604080516020808a02828101820190935289825290935089925088918291850190849080828437600092019190915250879250610b3c915050565b7f000000000000000000000000000000000000000000000000000000000000000081565b670de0b6b3a764000081565b60016020526000908152604090205481565b60008181548110610a4a57fe5b600091825260209091200154905081565b636139148b60e11b81565b6000908152602091909152604090205490565b604051631a98d06960e31b81526000906001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063d4c68348906104ea908590600401611762565b610aed600080516020611d46833981519152610ae2610dd8565b600191908201610df3565b565b60005415610b0f5760405162461bcd60e51b81526004016100b490611b53565b610b17610dd8565b15610b345760405162461bcd60e51b81526004016100b490611898565b610aed610e05565b610b44611540565b60008251855114610b675760405162461bcd60e51b81526004016100b490611b12565b8351855114610b885760405162461bcd60e51b81526004016100b490611bb3565b60005b85518110156107cb576000858281518110610ba257fe5b60200260200101519050610bb581610e4f565b610bd857610bd8858381518110610bc857fe5b6020026020010151828686610e6c565b6060610c0a888481518110610be957fe5b6020026020010151878581518110610bfd57fe5b6020026020010151610540565b9050610c1582610f45565b15610c5b576000610c2583610f64565b90506000610c34878488610f6d565b90508186018114610c575760405162461bcd60e51b81526004016100b490611a59565b9450505b610c77888481518110610c6a57fe5b6020026020010151610fea565b5050600101610b8b565b60005415610d8f576000610c95600061105c565b90506001600160a01b038116610cec57610caf600061105c565b6040805160048152602481019091526020810180516001600160e01b0316636139148b60e11b179052909150610ce6908290610540565b50610d89565b6040516370a0823160e01b81526000906001600160a01b038316906370a0823190610d1b903090600401611762565b60206040518083038186803b158015610d3357600080fd5b505afa158015610d47573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d6b919061172e565b90508015610d8757610d876001600160a01b0383163383611091565b505b50610c81565b478015610dc557604051339082156108fc029083906000818181858888f19350505050158015610dc3573d6000803e3d6000fd5b505b610dcd6110ec565b610dd5611107565b50565b60006104966001600080516020611d46833981519152610a66565b60009182526020929092526040902055565b6000610e0f61047b565b6001600160a01b031614610e355760405162461bcd60e51b81526004016100b490611869565b610aed6001600080516020611d2683398151915233611122565b6000600160f81b8216610e6457506001610476565b506000610476565b606080610e7885611140565b9150915060005b8251811015610f3c5783838281518110610e9557fe5b602002602001015110610eba5760405162461bcd60e51b81526004016100b490611c2d565b600085848381518110610ec957fe5b60200260200101516101008110610edc57fe5b602002015190506000838381518110610ef157fe5b602002602001015190506000670de0b6b3a764000090508160208b010180518015610f2d578481028582820414610f2757600080fd5b83900494505b50929092525050600101610e7f565b50505050505050565b6000610f5082610f64565b610f5c57506000610476565b506001610476565b60f01c60ff1690565b81516000906020810615610f935760405162461bcd60e51b81526004016100b490611b7c565b6020810483019150610100821115610fbd5760405162461bcd60e51b81526004016100b490611aea565b8260051b60005b82811015610fe057602081870181015183830189015201610fc4565b5050509392505050565b600054610ff657610dd5565b600160a01b6110056000611301565b1415610dd557600080548061101657fe5b600190038181906000526020600020016000905590556110366000611301565b6001600160e01b0319161561105057611050600082611346565b610dd560006001611368565b600061106782611301565b60001c90508180548061107657fe5b60019003818190600052602060002001600090559055919050565b6110e78363a9059cbb60e01b84846040516024016110b0929190611776565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915261139e565b505050565b610aed6001600080516020611d268339815191526000611122565b610aed6001600080516020611d468339815191526000610df3565b6000918252602092909252604090206001600160a01b039091169055565b60608061114c83610e4f565b156111695760405162461bcd60e51b81526004016100b4906119d2565b60165b60ff84811614801561117e5750600081115b156111935760089390931c926000190161116c565b600081116111b35760405162461bcd60e51b81526004016100b490611817565b8067ffffffffffffffff811180156111ca57600080fd5b506040519080825280602002602001820160405280156111f4578160200160208202803683370190505b5092508067ffffffffffffffff8111801561120e57600080fd5b50604051908082528060200260200182016040528015611238578160200160208202803683370190505b50915060005b8181101561127357835160ff86169085908390811061125957fe5b602090810291909101015260089490941c9360010161123e565b506000805b60408110156112da5760018616156112ce578282106112a95760405162461bcd60e51b81526004016100b490611909565b806020026004018483815181106112bc57fe5b60209081029190910101526001909101905b600195861c9501611278565b508181146112fa5760405162461bcd60e51b81526004016100b4906118c7565b5050915091565b80546000906113225760405162461bcd60e51b81526004016100b490611ac5565b81548290600019810190811061133457fe5b90600052602060002001549050919050565b8154600181018355600092835260209092206001600160a01b03909116910155565b8181600281111561137557fe5b81546001810183556000928352602090922060a09190911b6001600160a01b0319169101555050565b60606113f3826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661142d9092919063ffffffff16565b8051909150156110e7578080602001905181019061141191906116f6565b6110e75760405162461bcd60e51b81526004016100b490611c64565b606061143c8484600085611446565b90505b9392505050565b6060824710156114685760405162461bcd60e51b81526004016100b49061193e565b61147185610471565b61148d5760405162461bcd60e51b81526004016100b490611bf6565b60006060866001600160a01b031685876040516114aa9190611746565b60006040518083038185875af1925050503d80600081146114e7576040519150601f19603f3d011682016040523d82523d6000602084013e6114ec565b606091505b50915091506114fc828286611507565b979650505050505050565b6060831561151657508161143f565b8251156115265782518084602001fd5b8160405162461bcd60e51b81526004016100b491906117ad565b604051806120000160405280610100906020820280368337509192915050565b60008083601f840112611571578182fd5b50813567ffffffffffffffff811115611588578182fd5b60208301915083602080830285010111156115a257600080fd5b9250929050565b600082601f8301126115b9578081fd5b813567ffffffffffffffff8111156115cf578182fd5b6115e2601f8201601f1916602001611cae565b91508082528360208285010111156115f957600080fd5b8060208401602084013760009082016020015292915050565b600080600080600060608688031215611629578081fd5b853567ffffffffffffffff80821115611640578283fd5b61164c89838a01611560565b9097509550602091508782013581811115611665578384fd5b6116718a828b01611560565b909650945050604088013581811115611688578384fd5b88019050601f8101891361169a578283fd5b80356116ad6116a882611cd5565b611cae565b81815283810190838501865b848110156116e2576116d08e8884358901016115a9565b845292860192908601906001016116b9565b505080955050505050509295509295909350565b600060208284031215611707578081fd5b8151801515811461143f578182fd5b600060208284031215611727578081fd5b5035919050565b60006020828403121561173f578081fd5b5051919050565b60008251611758818460208701611cf5565b9190910192915050565b6001600160a01b0391909116815260200190565b6001600160a01b03929092168252602082015260400190565b90815260200190565b6001600160e01b031991909116815260200190565b60006020825282518060208401526117cc816040850160208701611cf5565b601f01601f19169190910160400192915050565b60208082526019908201527f53656e646572206973206e6f7420696e697469616c697a656400000000000000604082015260600190565b60208082526010908201526f4e6f2064796e616d696320706172616d60801b604082015260600190565b6020808252600e908201526d24b73b30b634b21031b0b63632b960911b604082015260600190565b60208082526015908201527414d95b99195c881a5cc81a5b9a5d1a585b1a5e9959605a1b604082015260600190565b6020808252601590820152744375626520636f756e746572206e6f74207a65726f60581b604082015260600190565b60208082526022908201527f4c6f636174696f6e20636f756e74206c657373207468616e2072656620636f756040820152611b9d60f21b606082015260800190565b6020808252818101527f4c6f636174696f6e20636f756e7420657863656564732072656620636f756e74604082015260600190565b60208082526026908201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6040820152651c8818d85b1b60d21b606082015260800190565b6020808252601490820152734e6f7420616c6c6f7765642066726f6d20454f4160601b604082015260600190565b60208082526006908201526510985b9b995960d21b604082015260600190565b6020808252600d908201526c53746174696320706172616d7360981b604082015260600190565b6020808252600f908201526e24b73b30b634b2103430b7323632b960891b604082015260600190565b6020808252601d908201527f446f6573206e6f7420616c6c6f772065787465726e616c2063616c6c73000000604082015260600190565b6020808252602c908201527f52657475726e206e756d20616e64207061727365642072657475726e206e756d60408201526b081b9bdd081b585d18da195960a21b606082015260800190565b60208082526006908201526512185b1d195960d21b604082015260600190565b6020808252600b908201526a737461636b20656d70747960a81b604082015260600190565b6020808252600e908201526d737461636b206f766572666c6f7760901b604082015260600190565b60208082526021908201527f546f7320616e64206461746173206c656e67746820696e636f6e73697374656e6040820152601d60fa1b606082015260800190565b6020808252600f908201526e537461636b206e6f7420656d70747960881b604082015260600190565b60208082526019908201527f696c6c6567616c206c656e67746820666f72205f706172736500000000000000604082015260600190565b60208082526023908201527f546f7320616e6420636f6e66696773206c656e67746820696e636f6e73697374604082015262195b9d60ea1b606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252601e908201527f5265666572656e636520746f206f7574206f66206c6f63616c537461636b0000604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b60405181810167ffffffffffffffff81118282101715611ccd57600080fd5b604052919050565b600067ffffffffffffffff821115611ceb578081fd5b5060209081020190565b60005b83811015611d10578181015183820152602001611cf8565b83811115611d1f576000848401525b5050505056feb2f2618cecbbb6e7468cc0f2aa43858ad8d153e0280b22285e28e853bb9d453af9543f11459ccccd21306c8881aaab675ff49d988c1162fd1dd9bbcdbe4446bea26469706673582212207aec21621e0dc7dc2c41c974fa87b8d8505dbad6b547e64c522ff3fdc55a9ba864736f6c634300060c003300000000000000000000000037c2fcc93a681c98cd065d7f103ec7bd640b2a6c

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

00000000000000000000000037c2fcc93a681c98cd065d7f103ec7bd640b2a6c

-----Decoded View---------------
Arg [0] : _registry (address): 0x37C2Fcc93a681C98Cd065d7f103EC7bD640B2A6C

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000037c2fcc93a681c98cd065d7f103ec7bd640b2a6c

28480:10509:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29997:30;30016:10;29997:18;:30::i;:::-;29989:63;;;;-1:-1:-1;;;29989:63:0;;;;;;;:::i;:::-;;;;;;;;;28480:10509;;28798:8;-1:-1:-1;;;;;28798:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:25;28790:44;;;;-1:-1:-1;;;28790:44:0;;;;;;;:::i;:::-;28684:28:::1;::::0;-1:-1:-1;;;28684:28:0;;29222:10:::1;::::0;-1:-1:-1;;;;;28684:8:0::1;:21;::::0;::::1;::::0;:28:::1;::::0;29222:10;;28684:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33:::0;28676:52:::1;;;;-1:-1:-1::0;;;28676:52:0::1;;;;;;;:::i;:::-;25249:1:::2;25225:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;25225:26:0::2;;;25217:64;;;;-1:-1:-1::0;;;25217:64:0::2;;;;;;;:::i;:::-;29484:26:::3;29499:10;29484:14;:26::i;:::-;29476:53;;;;-1:-1:-1::0;;;29476:53:0::3;;;;;;;:::i;:::-;29575:28;::::0;-1:-1:-1;;;29575:28:0;;29542:14:::3;::::0;-1:-1:-1;;;;;29575:8:0::3;:16;::::0;::::3;::::0;:28:::3;::::0;29592:10:::3;::::0;29575:28:::3;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;29559:46;;29542:63;;29616:19;29638:23;29644:6;29652:8;;29638:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;::::0;;;;-1:-1:-1;29638:5:0::3;::::0;-1:-1:-1;;;29638:23:0:i:3;:::-;29739:13:::0;;29616:45;;-1:-1:-1;29810:4:0::3;29798:17:::0;::::3;29739:13:::0;29798:17;29829::::3;24650:107:::0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24831:109;;;;;;;;;;;;;:::i;30342:284::-;;;;;;:::i;:::-;;:::i;30849:384::-;;;;;;:::i;:::-;;:::i;28862:35::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;21639:49::-;;;;;;;;;;;;;:::i;24538:40::-;;;;;;;;;;-1:-1:-1;24538:40:0;;;;;:::i;:::-;;:::i;24509:22::-;;;;;;;;;;-1:-1:-1;24509:22:0;;;;;:::i;:::-;;:::i;21532:51::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9216:444::-;9596:20;;9644:8;;9216:444;;;;:::o;25659:112::-;25704:7;25731:32;:5;-1:-1:-1;;;;;;;;;;;25731:16:0;:32::i;:::-;25724:39;;25659:112;:::o;38861:125::-;38948:30;;-1:-1:-1;;;38948:30:0;;38924:4;;-1:-1:-1;;;;;38948:8:0;:22;;;;:30;;38971:6;;38948:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38941:37;38861:125;-1:-1:-1;;38861:125:0:o;35713:896::-;35797:19;35842:20;35858:3;35842:15;:20::i;:::-;35834:48;;;;-1:-1:-1;;;35834:48:0;;;;;;;:::i;:::-;35893:17;:15;:17::i;:::-;36136:1;36116;36091:5;36085:12;36061:4;36054:5;36050:16;36028:3;36004:4;35997:5;35993:16;35962:190;36178:16;36226:4;36220:11;36210:21;;36341:4;36337:9;36330:4;36323;36317;36313:15;36309:26;36305:42;36297:6;36293:55;36270:4;36245:118;36392:4;36384:6;36377:20;36448:4;36445:1;36438:4;36430:6;36426:17;36411:42;36483:9;36476:17;36516:1;36511:80;;;;36469:122;;36511:80;36567:4;36560;36552:6;36548:17;36541:31;36469:122;;;;35930:672;;;;:::o;24650:107::-;-1:-1:-1;;;;;;;;;;;24650:107:0;:::o;24831:109::-;-1:-1:-1;;;;;;;;;;;24831:109:0;:::o;30342:284::-;28798:8;-1:-1:-1;;;;;28798:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:25;28790:44;;;;-1:-1:-1;;;28790:44:0;;;;;;;:::i;:::-;28684:28:::1;::::0;-1:-1:-1;;;28684:28:0;;30519:10:::1;::::0;-1:-1:-1;;;;;28684:8:0::1;:21;::::0;::::1;::::0;:28:::1;::::0;30519:10;;28684:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33:::0;28676:52:::1;;;;-1:-1:-1::0;;;28676:52:0::1;;;;;;;:::i;:::-;30542:13:::2;:11;:13::i;:::-;30566:27;30573:3;;30566:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;30566:27:0::2;::::0;;::::2;::::0;;::::2;::::0;;;;;;;;;;;;;-1:-1:-1;30578:7:0;;-1:-1:-1;30578:7:0;;;;30566:27;::::2;::::0;30578:7;;30566:27;30578:7;30566:27;::::2;;::::0;::::2;::::0;;;;-1:-1:-1;30587:5:0;;-1:-1:-1;30566:6:0::2;::::0;-1:-1:-1;;30566:27:0:i:2;:::-;30604:14;:12;:14::i;:::-;28845:1:::1;30342:284:::0;;;;;:::o;30849:384::-;28798:8;-1:-1:-1;;;;;28798:14:0;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:25;28790:44;;;;-1:-1:-1;;;28790:44:0;;;;;;;:::i;:::-;28684:28:::1;::::0;-1:-1:-1;;;28684:28:0;;31067:10:::1;::::0;-1:-1:-1;;;;;28684:8:0::1;:21;::::0;::::1;::::0;:28:::1;::::0;31067:10;;28684:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33:::0;28676:52:::1;;;;-1:-1:-1::0;;;28676:52:0::1;;;;;;;:::i;:::-;25249:1:::2;25225:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;25225:26:0::2;;;25217:64;;;;-1:-1:-1::0;;;25217:64:0::2;;;;;;;:::i;:::-;31126:10:::3;31148:4;31126:27;31118:69;;;;-1:-1:-1::0;;;31118:69:0::3;;;;;;;:::i;:::-;31198:27;31205:3;;31198:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;::::0;;;;-1:-1:-1;;31198:27:0::3;::::0;;::::3;::::0;;::::3;::::0;;;;;;;;;;;;;-1:-1:-1;31210:7:0;;-1:-1:-1;31210:7:0;;;;31198:27;::::3;::::0;31210:7;;31198:27;31210:7;31198:27;::::3;;::::0;::::3;::::0;;;;-1:-1:-1;31219:5:0;;-1:-1:-1;31198:6:0::3;::::0;-1:-1:-1;;31198:27:0:i:3;28862:35::-:0;;;:::o;21639:49::-;21681:7;21639:49;:::o;24538:40::-;;;;;;;;;;;;;:::o;24509:22::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24509:22:0;:::o;21532:51::-;-1:-1:-1;;;21532:51:0;:::o;22483:203::-;22609:11;22663:12;;;;;;;;;;;;;22483:203::o;38665:129::-;38754:32;;-1:-1:-1;;;38754:32:0;;38730:4;;-1:-1:-1;;;;;38754:8:0;:23;;;;:32;;38778:7;;38754:32;;;:::i;25779:112::-;25826:57;-1:-1:-1;;;;;;;;;;;25861:17:0;:15;:17::i;:::-;25881:1;;25826:57;25861:21;;25826:16;:57::i;:::-;25779:112::o;37360:130::-;24992:5;:12;:17;24984:45;;;;-1:-1:-1;;;24984:45:0;;;;;;;:::i;:::-;25105:17:::1;:15;:17::i;:::-;:22:::0;25097:56:::1;;;;-1:-1:-1::0;;;25097:56:0::1;;;;;;;:::i;:::-;37470:12:::2;:10;:12::i;31438:1522::-:0;31578:30;;:::i;:::-;31619:13;31685:5;:12;31671:3;:10;:26;31649:109;;;;-1:-1:-1;;;31649:109:0;;;;;;;:::i;:::-;31805:7;:14;31791:3;:10;:28;31769:113;;;;-1:-1:-1;;;31769:113:0;;;;;;;:::i;:::-;31898:9;31893:1060;31917:3;:10;31913:1;:14;31893:1060;;;31949:14;31966:7;31974:1;31966:10;;;;;;;;;;;;;;31949:27;;32057:17;:6;:15;:17::i;:::-;32052:197;;32191:42;32197:5;32203:1;32197:8;;;;;;;;;;;;;;32207:6;32215:10;32227:5;32191;:42::i;:::-;32329:19;32351:23;32357:3;32361:1;32357:6;;;;;;;;;;;;;;32365:5;32371:1;32365:8;;;;;;;;;;;;;;32351:5;:23::i;:::-;32329:45;;32393:21;:6;:19;:21::i;:::-;32389:437;;;32509:11;32523:21;:6;:19;:21::i;:::-;32509:35;;32563:16;32582:33;32589:10;32601:6;32609:5;32582:6;:33::i;:::-;32563:52;;32684:3;32676:5;:11;32664:8;:23;32634:141;;;;-1:-1:-1;;;32634:141:0;;;;;;;:::i;:::-;32802:8;-1:-1:-1;;32389:437:0;32918:23;32934:3;32938:1;32934:6;;;;;;;;;;;;;;32918:15;:23::i;:::-;-1:-1:-1;;31929:3:0;;31893:1060;;37539:1058;37919:1;37904:12;:16;37897:429;;37937:12;37952:18;:5;:16;:18::i;:::-;37937:33;-1:-1:-1;;;;;;37989:18:0;;37985:330;;38035:18;:5;:16;:18::i;:::-;38084:39;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;38084:39:0;-1:-1:-1;;;38084:39:0;;;38028:25;;-1:-1:-1;38072:52:0;;38028:25;;38072:5;:52::i;:::-;;37985:330;;;38182:37;;-1:-1:-1;;;38182:37:0;;38165:14;;-1:-1:-1;;;;;38182:22:0;;;;;:37;;38213:4;;38182:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38165:54;-1:-1:-1;38242:10:0;;38238:61;;38254:45;-1:-1:-1;;;;;38254:25:0;;38280:10;38292:6;38254:25;:45::i;:::-;37985:330;;37897:429;;;;38407:21;38443:10;;38439:43;;38455:27;;:10;;:27;;;;;38475:6;;38455:27;;;;38475:6;38455:10;:27;;;;;;;;;;;;;;;;;;;;;38439:43;38545:14;:12;:14::i;:::-;38570:19;:17;:19::i;:::-;37539:1058;:::o;26001:119::-;26051:7;26078:34;:5;-1:-1:-1;;;;;;;;;;;26078:16:0;:34::i;22289:186::-;22452:15;22437:12;;;;;;;;;;;:30;22289:186::o;25436:111::-;25380:1;25356:12;:10;:12::i;:::-;-1:-1:-1;;;;;25356:26:0;;25348:60;;;;-1:-1:-1;;;25348:60:0;;;;;;;:::i;:::-;25495:44:::1;:5;-1:-1:-1::0;;;;;;;;;;;25528:10:0::1;25495:16;:44::i;26863:148::-:0;26918:4;-1:-1:-1;;;26939:18:0;;26935:68;;-1:-1:-1;26971:4:0;26964:11;;26935:68;-1:-1:-1;26998:5:0;26991:12;;33225:1214;33449:21;33472:23;33499:18;:6;:16;:18::i;:::-;33448:69;;;;33593:9;33588:844;33612:4;:11;33608:1;:15;33588:844;;;33663:5;33653:4;33658:1;33653:7;;;;;;;;;;;;;;:15;33645:58;;;;-1:-1:-1;;;33645:58:0;;;;;;;:::i;:::-;33718:11;33732:10;33743:4;33748:1;33743:7;;;;;;;;;;;;;;33732:19;;;;;;;;;;;33718:33;;33766:14;33783:6;33790:1;33783:9;;;;;;;;;;;;;;33766:26;;33807:12;21681:7;33807:30;;33912:6;33905:4;33899;33895:15;33891:28;33952:3;33946:10;34077:1;34070:9;34060:2;;34169:3;34166:1;34162:11;34219:3;34215:1;34212;34208:9;34205:18;34195:2;;34262:1;34259;34252:12;34195:2;34341:12;;;;-1:-1:-1;34060:2:0;-1:-1:-1;34390:16:0;;;;-1:-1:-1;;33625:3:0;;33588:844;;;;33225:1214;;;;;;:::o;27019:152::-;27078:4;27099:18;27112:4;27099:12;:18::i;:::-;27095:68;;-1:-1:-1;27131:5:0;27124:12;;27095:68;-1:-1:-1;27159:4:0;27152:11;;27179:181;26851:3;27277:45;;;;27179:181::o;34668:885::-;34849:10;;34806:16;;34958:2;34849:10;34952:8;:13;34944:51;;;;-1:-1:-1;;;34944:51:0;;;;;;;:::i;:::-;35080:2;35074:3;:8;35066:5;:16;35055:27;;35113:3;35101:8;:15;;35093:42;;;;-1:-1:-1;;;35093:42:0;;;;;;;:::i;:::-;35191:5;35188:1;35184:13;35290:1;35258:277;35313:3;35310:1;35307:10;35258:277;;;35495:4;35482:11;;;35478:22;;35472:29;35434:14;;;35418:31;;35389:131;35342:12;35258:277;;;35262:44;;35155:391;;;;;;:::o;36723:589::-;36935:5;:12;36931:374;;36969:7;;36931:374;-1:-1:-1;;;37011:12:0;:5;:10;:12::i;:::-;:60;36993:312;;;37098:5;:11;;;;;;;;;;;;;;;;;;;;;;;;37188:12;:5;:10;:12::i;:::-;-1:-1:-1;;;;;;37181:34:0;;37177:61;;37217:21;:5;37234:3;37217:16;:21::i;:::-;37253:40;:5;37274:18;37253:20;:40::i;23577:187::-;23659:11;23718:12;23723:6;23718:4;:12::i;:::-;23710:21;;23688:45;;23744:6;:12;;;;;;;;;;;;;;;;;;;;;;;;23577:187;;;:::o;16681:248::-;16798:123;16832:5;16875:23;;;16900:2;16904:5;16852:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16852:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;16852:58:0;-1:-1:-1;;;;;;16852:58:0;;;;;;;;;;16798:19;:123::i;:::-;16681:248;;;:::o;25555:96::-;25599:44;:5;-1:-1:-1;;;;;;;;;;;25616:14:0;25599:16;:44::i;25899:94::-;25948:37;:5;-1:-1:-1;;;;;;;;;;;25965:16:0;25948;:37::i;22077:204::-;22240:33;22225:12;;;;;;;;;;;-1:-1:-1;;;;;22248:24:0;;;22225:48;;22077:204::o;27368:977::-;27451:21;27474:23;27524:14;27533:4;27524:8;:14::i;:::-;27523:15;27515:41;;;;-1:-1:-1;;;27515:41:0;;;;;;;:::i;:::-;26743:2;27600:108;26505:66;27607:16;;;:29;:38;;;;;27644:1;27640;:5;27607:38;27600:108;;;27695:1;27687:9;;;;;-1:-1:-1;;27662:3:0;27600:108;;;27730:1;27726;:5;27718:34;;;;-1:-1:-1;;;27718:34:0;;;;;;;:::i;:::-;27784:1;27770:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27770:16:0;;27763:23;;27820:1;27806:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27806:16:0;;27797:25;;27838:9;27833:125;27857:1;27853;:5;27833:125;;;27880:7;;26505:66;27898:16;;;27880:4;;27885:1;;27880:7;;;;;;;;;;;;;;;:35;27945:1;27937:9;;;;;27860:3;;27833:125;;;;27968:9;27997;27992:282;26797:2;28012:1;:21;27992:282;;;26386:66;28059:18;;:23;28055:177;;28115:1;28111;:5;28103:50;;;;-1:-1:-1;;;28103:50:0;;;;;;;:::i;:::-;28184:1;28188:2;28184:6;28193:1;28184:10;28172:6;28179:1;28172:9;;;;;;;;;;;;;;;;;:22;28213:3;;;;;28055:177;28261:1;28253:9;;;;28035:3;27992:282;;;;28297:1;28292;:6;28284:53;;;;-1:-1:-1;;;28284:53:0;;;;;;;:::i;:::-;27368:977;;;;;:::o;24058:210::-;24185:13;;24148:11;;24177:41;;;;-1:-1:-1;;;24177:41:0;;;;;;;:::i;:::-;24242:13;;24235:6;;-1:-1:-1;;24242:17:0;;;24235:25;;;;;;;;;;;;;;24229:31;;24058:210;;;:::o;23160:136::-;23242:46;;;;;;;23254:33;23242:46;;;;;;;-1:-1:-1;;;;;23262:24:0;;;23242:46;;;23160:136::o;23414:155::-;23525:6;23552;23545:14;;;;;;;;23525:36;;;;;;;-1:-1:-1;23525:36:0;;;;;;;23537:23;;;;;-1:-1:-1;;;;;;23525:36:0;;;;-1:-1:-1;;23414:155:0:o;19571:885::-;19995:23;20034:118;20080:4;20034:118;;;;;;;;;;;;;;;;;20042:5;-1:-1:-1;;;;;20034:27:0;;;:118;;;;;:::i;:::-;20167:17;;19995:157;;-1:-1:-1;20167:21:0;20163:286;;20340:10;20329:30;;;;;;;;;;;;:::i;:::-;20303:134;;;;-1:-1:-1;;;20303:134:0;;;;;;;:::i;12253:229::-;12390:12;12422:52;12444:6;12452:4;12458:1;12461:12;12422:21;:52::i;:::-;12415:59;;12253:229;;;;;;:::o;13469:621::-;13639:12;13711:5;13686:21;:30;;13664:118;;;;-1:-1:-1;;;13664:118:0;;;;;;;:::i;:::-;13801:18;13812:6;13801:10;:18::i;:::-;13793:60;;;;-1:-1:-1;;;13793:60:0;;;;;;;:::i;:::-;13927:12;13941:23;13981:6;-1:-1:-1;;;;;13981:11:0;14000:5;14007:4;13981:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13926:86;;;;14030:52;14048:7;14057:10;14069:12;14030:17;:52::i;:::-;14023:59;13469:621;-1:-1:-1;;;;;;;13469:621:0:o;15241:777::-;15391:12;15420:7;15416:595;;;-1:-1:-1;15451:10:0;15444:17;;15416:595;15565:17;;:21;15561:439;;15828:10;15822:17;15889:15;15876:10;15872:2;15868:19;15861:44;15776:148;15971:12;15964:20;;-1:-1:-1;;;15964:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;23:352::-;;;153:3;146:4;138:6;134:17;130:27;120:2;;-1:-1;;161:12;120:2;-1:-1;191:20;;231:18;220:30;;217:2;;;-1:-1;;253:12;217:2;297:4;289:6;285:17;273:29;;348:3;297:4;;332:6;328:17;289:6;314:32;;311:41;308:2;;;365:1;;355:12;308:2;113:262;;;;;:::o;1904:440::-;;2005:3;1998:4;1990:6;1986:17;1982:27;1972:2;;-1:-1;;2013:12;1972:2;2060:6;2047:20;27841:18;27833:6;27830:30;27827:2;;;-1:-1;;27863:12;27827:2;2082:64;27936:9;27917:17;;-1:-1;;27913:33;28004:4;27994:15;2082:64;:::i;:::-;2073:73;;2166:6;2159:5;2152:21;2270:3;28004:4;2261:6;2194;2252:16;;2249:25;2246:2;;;2287:1;;2277:12;2246:2;29990:6;28004:4;2194:6;2190:17;28004:4;2228:5;2224:16;29967:30;30046:1;30028:16;;;28004:4;30028:16;30021:27;2228:5;1965:379;-1:-1;;1965:379::o;2630:957::-;;;;;;2872:2;2860:9;2851:7;2847:23;2843:32;2840:2;;;-1:-1;;2878:12;2840:2;2936:17;2923:31;2974:18;;2966:6;2963:30;2960:2;;;-1:-1;;2996:12;2960:2;3034:80;3106:7;3097:6;3086:9;3082:22;3034:80;:::i;:::-;3016:98;;-1:-1;3016:98;-1:-1;3179:2;;-1:-1;3164:18;;;3151:32;3192:30;;;3189:2;;;-1:-1;;3225:12;3189:2;3263:80;3335:7;3326:6;3315:9;3311:22;3263:80;:::i;:::-;3245:98;;-1:-1;3245:98;-1:-1;;3408:2;3393:18;;3380:32;3421:30;;;3418:2;;;-1:-1;;3454:12;3418:2;3539:22;;;-1:-1;896:4;884:17;;880:27;-1:-1;870:2;;-1:-1;;911:12;870:2;958:6;945:20;980:89;995:73;1061:6;995:73;:::i;:::-;980:89;:::i;:::-;1097:21;;;1154:14;;;;1129:17;;;-1:-1;1234:242;1259:6;1256:1;1253:13;1234:242;;;1366:46;1408:3;3179:2;1342:3;1329:17;1133:6;1317:30;;1366:46;:::i;:::-;1354:59;;1427:14;;;;1455;;;;1281:1;1274:9;1234:242;;;1238:14;;3474:97;;;;;;;;2834:753;;;;;;;;:::o;3594:257::-;;3706:2;3694:9;3685:7;3681:23;3677:32;3674:2;;;-1:-1;;3712:12;3674:2;1571:6;1565:13;30525:5;28772:13;28765:21;30503:5;30500:32;30490:2;;-1:-1;;30536:12;3858:241;;3962:2;3950:9;3941:7;3937:23;3933:32;3930:2;;;-1:-1;;3968:12;3930:2;-1:-1;1692:20;;3924:175;-1:-1;3924:175::o;4106:263::-;;4221:2;4209:9;4200:7;4196:23;4192:32;4189:2;;;-1:-1;;4227:12;4189:2;-1:-1;1840:13;;4183:186;-1:-1;4183:186::o;14608:271::-;;5560:5;28113:12;5671:52;5716:6;5711:3;5704:4;5697:5;5693:16;5671:52;:::i;:::-;5735:16;;;;;14742:137;-1:-1;;14742:137::o;14886:222::-;-1:-1;;;;;29090:54;;;;5114:37;;15013:2;14998:18;;14984:124::o;15360:333::-;-1:-1;;;;;29090:54;;;;5114:37;;15679:2;15664:18;;5234:37;15515:2;15500:18;;15486:207::o;15700:222::-;5234:37;;;15827:2;15812:18;;15798:124::o;15929:218::-;-1:-1;;;;;;28938:78;;;;5352:36;;16054:2;16039:18;;16025:122::o;16417:310::-;;16564:2;16585:17;16578:47;6075:5;28113:12;28552:6;16564:2;16553:9;16549:18;28540:19;6169:52;6214:6;28580:14;16553:9;28580:14;16564:2;6195:5;6191:16;6169:52;:::i;:::-;27936:9;30407:14;-1:-1;;30403:28;6233:39;;;;28580:14;6233:39;;16535:192;-1:-1;;16535:192::o;16734:416::-;16934:2;16948:47;;;6509:2;16919:18;;;28540:19;6545:27;28580:14;;;6525:48;6592:12;;;16905:245::o;17157:416::-;17357:2;17371:47;;;6843:2;17342:18;;;28540:19;-1:-1;;;28580:14;;;6859:39;6917:12;;;17328:245::o;17580:416::-;17780:2;17794:47;;;7168:2;17765:18;;;28540:19;-1:-1;;;28580:14;;;7184:37;7240:12;;;17751:245::o;18003:416::-;18203:2;18217:47;;;7491:2;18188:18;;;28540:19;-1:-1;;;28580:14;;;7507:44;7570:12;;;18174:245::o;18426:416::-;18626:2;18640:47;;;7821:2;18611:18;;;28540:19;-1:-1;;;28580:14;;;7837:44;7900:12;;;18597:245::o;18849:416::-;19049:2;19063:47;;;8151:2;19034:18;;;28540:19;8187:34;28580:14;;;8167:55;-1:-1;;;8242:12;;;8235:26;8280:12;;;19020:245::o;19272:416::-;19472:2;19486:47;;;19457:18;;;28540:19;8567:34;28580:14;;;8547:55;8621:12;;;19443:245::o;19695:416::-;19895:2;19909:47;;;8872:2;19880:18;;;28540:19;8908:34;28580:14;;;8888:55;-1:-1;;;8963:12;;;8956:30;9005:12;;;19866:245::o;20118:416::-;20318:2;20332:47;;;9256:2;20303:18;;;28540:19;-1:-1;;;28580:14;;;9272:43;9334:12;;;20289:245::o;20541:416::-;20741:2;20755:47;;;9585:1;20726:18;;;28540:19;-1:-1;;;28580:14;;;9600:29;9648:12;;;20712:245::o;20964:416::-;21164:2;21178:47;;;9899:2;21149:18;;;28540:19;-1:-1;;;28580:14;;;9915:36;9970:12;;;21135:245::o;21387:416::-;21587:2;21601:47;;;10221:2;21572:18;;;28540:19;-1:-1;;;28580:14;;;10237:38;10294:12;;;21558:245::o;21810:416::-;22010:2;22024:47;;;10545:2;21995:18;;;28540:19;10581:31;28580:14;;;10561:52;10632:12;;;21981:245::o;22233:416::-;22433:2;22447:47;;;10883:2;22418:18;;;28540:19;10919:34;28580:14;;;10899:55;-1:-1;;;10974:12;;;10967:36;11022:12;;;22404:245::o;22656:416::-;22856:2;22870:47;;;11273:1;22841:18;;;28540:19;-1:-1;;;28580:14;;;11288:29;11336:12;;;22827:245::o;23079:416::-;23279:2;23293:47;;;11587:2;23264:18;;;28540:19;-1:-1;;;28580:14;;;11603:34;11656:12;;;23250:245::o;23502:416::-;23702:2;23716:47;;;11907:2;23687:18;;;28540:19;-1:-1;;;28580:14;;;11923:37;11979:12;;;23673:245::o;23925:416::-;24125:2;24139:47;;;12230:2;24110:18;;;28540:19;12266:34;28580:14;;;12246:55;-1:-1;;;12321:12;;;12314:25;12358:12;;;24096:245::o;24348:416::-;24548:2;24562:47;;;12609:2;24533:18;;;28540:19;-1:-1;;;28580:14;;;12625:38;12682:12;;;24519:245::o;24771:416::-;24971:2;24985:47;;;12933:2;24956:18;;;28540:19;12969:27;28580:14;;;12949:48;13016:12;;;24942:245::o;25194:416::-;25394:2;25408:47;;;13267:2;25379:18;;;28540:19;13303:34;28580:14;;;13283:55;-1:-1;;;13358:12;;;13351:27;13397:12;;;25365:245::o;25617:416::-;25817:2;25831:47;;;13648:2;25802:18;;;28540:19;13684:31;28580:14;;;13664:52;13735:12;;;25788:245::o;26040:416::-;26240:2;26254:47;;;13986:2;26225:18;;;28540:19;14022:32;28580:14;;;14002:53;14074:12;;;26211:245::o;26463:416::-;26663:2;26677:47;;;14325:2;26648:18;;;28540:19;14361:34;28580:14;;;14341:55;-1:-1;;;14416:12;;;14409:34;14462:12;;;26634:245::o;27115:256::-;27177:2;27171:9;27203:17;;;27278:18;27263:34;;27299:22;;;27260:62;27257:2;;;27335:1;;27325:12;27257:2;27177;27344:22;27155:216;;-1:-1;27155:216::o;27378:313::-;;27546:18;27538:6;27535:30;27532:2;;;-1:-1;;27568:12;27532:2;-1:-1;27613:4;27601:17;;;27666:15;;27469:222::o;30063:268::-;30128:1;30135:101;30149:6;30146:1;30143:13;30135:101;;;30216:11;;;30210:18;30197:11;;;30190:39;30171:2;30164:10;30135:101;;;30251:6;30248:1;30245:13;30242:2;;;30128:1;30307:6;30302:3;30298:16;30291:27;30242:2;;30112:219;;;:::o

ipfs://7aec21621e0dc7dc2c41c974fa87b8d8505dbad6b547e64c522ff3fdc55a9ba8