Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library LibParam
•    - function isStatic(bytes32 conf)
•    - function isReferenced(bytes32 conf)
•    - function getReturnNum(bytes32 conf)
•    - function getParams(bytes32 conf)
• 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 ...
• library LibCache
•    - function set(
•    - function setAddress(
•    - function setUint256(
•    - function getAddress(
•    - function getUint256(
•    - function get(mapping(bytes32 =&gt ...
•  contract Storage
•    - function _setSender()
•    - function _resetSender()
•    - function _getSender()
•    - function _addCubeCounter()
•    - function _resetCubeCounter()
•    - function _getCubeCounter()
•  contract Config
• interface IRegistry
•    - function infos(address)
•    - function isValid(address handler)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function _verifyCallResult(bool succe ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•  contract Proxy is Storage, Config *
•    - 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 _getRegistry()
•    - function _isValid(address handler)

More Options

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

/**
 *Submitted for verification at Etherscan.io on 2021-01-09
*/

// File: localhost/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 = 0;
        while (conf & REFS_MASK == REFS_MASK && n < REFS_LIMIT) {
            n++;
            conf = conf >> 8;
        }
        n = REFS_LIMIT - n;
        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: localhost/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, uint256 _input) internal {
        require(_input < uint96(-1), "Invalid Handler Type");
        _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: localhost/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: localhost/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");
        _;
    }

    function _setSender() internal {
        if (_getSender() == address(0))
            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: localhost/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: localhost/contracts/interface/IRegistry.sol

pragma solidity ^0.6.0;


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

    function isValid(address handler) external view returns (bool result);
}

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

// SPDX-License-Identifier: MIT

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/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/token/ERC20/IERC20.sol


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/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: localhost/contracts/Proxy.sol

pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;







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

    // keccak256 hash of "furucombo.handler.registry"
    // prettier-ignore
    bytes32 private constant HANDLER_REGISTRY = 0x6874162fd62902201ea0f4bf541086067b3b88bd802fac9e150fd2d1db584e19;

    constructor(address registry) public {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            sstore(slot, registry)
        }
    }

    /**
     * @notice Direct transfer from EOA should be reverted.
     * @dev Callback function will be handled here.
     */
    fallback() external payable {
        require(Address.isContract(msg.sender), "Not allowed from EOA");

        // 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.
        if (msg.data.length != 0) {
            require(_isValid(msg.sender), "Invalid caller");

            address target =
                address(bytes20(IRegistry(_getRegistry()).infos(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 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[] memory tos,
        bytes32[] memory configs,
        bytes[] memory datas
    ) public payable {
        _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[] memory tos,
        bytes32[] memory configs,
        bytes[] memory datas
    ) public payable {
        require(msg.sender == address(this), "Does not allow external calls");
        require(_getSender() != address(0), "Sender should be initialized");
        _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++) {
            // Check if the data contains dynamic parameter
            if (!configs[i].isStatic()) {
                // If so, trim the exectution data base on the configuration and stack content
                _trim(datas[i], configs[i], localStack, index);
            }
            // Check if the output will be referenced afterwards
            if (configs[i].isReferenced()) {
                // If so, parse the output and place it into local stack
                uint256 num = configs[i].getReturnNum();
                uint256 newIndex =
                    _parse(localStack, _exec(tos[i], datas[i]), index);
                require(
                    newIndex == index + num,
                    "Return num and parsed return num not matched"
                );
                index = newIndex;
            } else {
                _exec(tos[i], datas[i]);
            }
            // 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;
        // 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(_isValid(_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(uint256(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 Get the registry contract address.
    function _getRegistry() internal view returns (address registry) {
        bytes32 slot = HANDLER_REGISTRY;
        assembly {
            registry := sload(slot)
        }
    }

    /// @notice Check if the handler is valid in registry.
    function _isValid(address handler) internal view returns (bool result) {
        return IRegistry(_getRegistry()).isValid(handler);
    }
}

• 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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stack","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"}]

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

0x60806040526004361061007b5760003560e01c806387c139431161004e57806387c139431461021657806399eb59b91461022b578063dc9031c41461024b578063fa2901a51461026b5761007b565b80630f532d18146101b05780631413dc7d146101db57806338c5c08e146101f05780637193850914610203575b6100843361028d565b6100a95760405162461bcd60e51b81526004016100a090611400565b60405180910390fd5b36156101ae576100b833610297565b6100d45760405162461bcd60e51b81526004016100a0906112ec565b60006100de610322565b6001600160a01b031663c6ddb642336040518263ffffffff1660e01b81526004016101099190611244565b60206040518083038186803b15801561012157600080fd5b505afa158015610135573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101599190611210565b60601c905060606101a1826000368080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061034792505050565b8051909150602082018181f35b005b3480156101bc57600080fd5b506101c56103c6565b6040516101d29190611271565b60405180910390f35b3480156101e757600080fd5b506101c56103d8565b6101ae6101fe3660046110f3565b6103ea565b6101ae6102113660046110f3565b61040a565b34801561022257600080fd5b506101c5610465565b34801561023757600080fd5b506101c56102463660046111f8565b610471565b34801561025757600080fd5b506101c56102663660046111f8565b610483565b34801561027757600080fd5b506102806104a1565b6040516101d2919061127a565b803b15155b919050565b60006102a1610322565b6001600160a01b0316638b1b925f836040518263ffffffff1660e01b81526004016102cc9190611244565b60206040518083038186803b1580156102e457600080fd5b505afa1580156102f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061031c91906111d8565b92915050565b7f6874162fd62902201ea0f4bf541086067b3b88bd802fac9e150fd2d1db584e195490565b606061035283610297565b61036e5760405162461bcd60e51b81526004016100a090611483565b6103766104ac565b600080835160208501866113885a03f43d6040519250601f19601f6020830101168301604052808352806000602085013e8115600181146103b6576103bd565b8160208501fd5b50505092915050565b60008051602061179083398151915281565b6000805160206117b083398151915281565b6103f26104d3565b6103fd838383610520565b6104056106c4565b505050565b3330146104295760405162461bcd60e51b81526004016100a0906114ac565b600061043361081b565b6001600160a01b0316141561045a5760405162461bcd60e51b81526004016100a0906116e1565b610405838383610520565b670de0b6b3a764000081565b60016020526000908152604090205481565b6000818154811061049057fe5b600091825260209091200154905081565b636139148b60e11b81565b6104d16000805160206117b08339815191526104c661083b565b600191908201610856565b565b600054156104f35760405162461bcd60e51b81526004016100a0906115bd565b6104fb61083b565b156105185760405162461bcd60e51b81526004016100a090611314565b6104d1610868565b610528610f90565b6000825185511461054b5760405162461bcd60e51b81526004016100a09061157c565b835185511461056c5760405162461bcd60e51b81526004016100a0906115e6565b60005b85518110156106bc5761059485828151811061058757fe5b602002602001015161089b565b6105ca576105ca8482815181106105a757fe5b60200260200101518683815181106105bb57fe5b602002602001015185856108b8565b6105e68582815181106105d957fe5b6020026020010151610991565b156106735760006106098683815181106105fc57fe5b60200260200101516109b0565b90506000610647856106418a868151811061062057fe5b602002602001015189878151811061063457fe5b6020026020010151610347565b866109b9565b9050818401811461066a5760405162461bcd60e51b81526004016100a0906114e3565b92506106989050565b61069686828151811061068257fe5b602002602001015185838151811061063457fe5b505b6106b48682815181106106a757fe5b6020026020010151610a11565b60010161056f565b505050505050565b600054156107d25760006106d86000610a83565b90506001600160a01b03811661072f576106f26000610a83565b6040805160048152602481019091526020810180516001600160e01b0316636139148b60e11b179052909150610729908290610347565b506107cc565b6040516370a0823160e01b81526000906001600160a01b038316906370a082319061075e903090600401611244565b60206040518083038186803b15801561077657600080fd5b505afa15801561078a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906107ae9190611210565b905080156107ca576107ca6001600160a01b0383163383610ab8565b505b506106c4565b47801561080857604051339082156108fc029083906000818181858888f19350505050158015610806573d6000803e3d6000fd5b505b610810610b0e565b610818610b29565b50565b60006108366001600080516020611790833981519152610b44565b905090565b600061083660016000805160206117b0833981519152610b44565b60009182526020929092526040902055565b600061087261081b565b6001600160a01b031614156104d1576104d1600160008051602061179083398151915233610b57565b6000600160f81b82166108b057506001610292565b506000610292565b6060806108c485610b75565b9150915060005b825181101561098857838382815181106108e157fe5b6020026020010151106109065760405162461bcd60e51b81526004016100a090611660565b60008584838151811061091557fe5b6020026020010151610100811061092857fe5b60200201519050600083838151811061093d57fe5b602002602001015190506000670de0b6b3a764000090508160208b01018051801561097957848102858282041461097357600080fd5b83900494505b509290925250506001016108cb565b50505050505050565b600061099c826109b0565b6109a857506000610292565b506001610292565b60f01c60ff1690565b8151602081048201906101008211156109e45760405162461bcd60e51b81526004016100a090611554565b8260051b60005b82811015610a07576020818701810151838301890152016109eb565b5050509392505050565b600054610a1d57610818565b600160a01b610a2c6000610d35565b1415610818576000805480610a3d57fe5b60019003818190600052602060002001600090559055610a5d6000610d35565b6001600160e01b03191615610a7757610a77600082610d7a565b61081860006001610d9c565b6000610a8e82610d35565b60001c905081805480610a9d57fe5b60019003818190600052602060002001600090559055919050565b6104058363a9059cbb60e01b8484604051602401610ad7929190611258565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b031990931692909217909152610dee565b6104d160016000805160206117908339815191526000610b57565b6104d160016000805160206117b08339815191526000610856565b6000908152602091909152604090205490565b6000918252602092909252604090206001600160a01b039091169055565b606080610b818361089b565b15610b9e5760405162461bcd60e51b81526004016100a09061145c565b60005b60ff848116148015610bb35750601681105b15610bc75760089390931c92600101610ba1565b60160380610be75760405162461bcd60e51b81526004016100a0906112c2565b8067ffffffffffffffff81118015610bfe57600080fd5b50604051908082528060200260200182016040528015610c28578160200160208202803683370190505b5092508067ffffffffffffffff81118015610c4257600080fd5b50604051908082528060200260200182016040528015610c6c578160200160208202803683370190505b50915060005b81811015610ca757835160ff861690859083908110610c8d57fe5b602090810291909101015260089490941c93600101610c72565b506000805b6040811015610d0e576001861615610d0257828210610cdd5760405162461bcd60e51b81526004016100a090611385565b80602002600401848381518110610cf057fe5b60209081029190910101526001909101905b600195861c9501610cac565b50818114610d2e5760405162461bcd60e51b81526004016100a090611343565b5050915091565b8054600090610d565760405162461bcd60e51b81526004016100a09061152f565b815482906000198101908110610d6857fe5b90600052602060002001549050919050565b8154600181018355600092835260209092206001600160a01b03909116910155565b6bffffffffffffffffffffffff8110610dc75760405162461bcd60e51b81526004016100a09061142e565b81546001810183556000928352602090922060a09190911b6001600160a01b031916910155565b6060610e43826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316610e7d9092919063ffffffff16565b8051909150156104055780806020019051810190610e6191906111d8565b6104055760405162461bcd60e51b81526004016100a090611697565b6060610e8c8484600085610e96565b90505b9392505050565b606082471015610eb85760405162461bcd60e51b81526004016100a0906113ba565b610ec18561028d565b610edd5760405162461bcd60e51b81526004016100a090611629565b60006060866001600160a01b03168587604051610efa9190611228565b60006040518083038185875af1925050503d8060008114610f37576040519150601f19603f3d011682016040523d82523d6000602084013e610f3c565b606091505b5091509150610f4c828286610f57565b979650505050505050565b60608315610f66575081610e8f565b825115610f765782518084602001fd5b8160405162461bcd60e51b81526004016100a0919061128f565b604051806120000160405280610100906020820280368337509192915050565b80356001600160a01b038116811461031c57600080fd5b600082601f830112610fd7578081fd5b8135610fea610fe58261173f565b611718565b81815291506020808301908481018184028601820187101561100b57600080fd5b60005b8481101561102a5781358452928201929082019060010161100e565b505050505092915050565b6000601f8381840112611046578182fd5b8235611054610fe58261173f565b818152925060208084019085810160005b848110156110e7578135880189603f82011261108057600080fd5b8381013567ffffffffffffffff81111561109957600080fd5b6110aa818901601f19168601611718565b81815260408c818486010111156110c057600080fd5b82818501888401375060009181018601919091528552509282019290820190600101611065565b50505050505092915050565b600080600060608486031215611107578283fd5b833567ffffffffffffffff8082111561111e578485fd5b818601915086601f830112611131578485fd5b813561113f610fe58261173f565b80828252602080830192508086018b82838702890101111561115f57898afd5b8996505b84871015611189576111758c82610fb0565b845260019690960195928101928101611163565b5090975088013593505050808211156111a0578384fd5b6111ac87838801610fc7565b935060408601359150808211156111c1578283fd5b506111ce86828701611035565b9150509250925092565b6000602082840312156111e9578081fd5b81518015158114610e8f578182fd5b600060208284031215611209578081fd5b5035919050565b600060208284031215611221578081fd5b5051919050565b6000825161123a81846020870161175f565b9190910192915050565b6001600160a01b0391909116815260200190565b6001600160a01b03929092168252602082015260400190565b90815260200190565b6001600160e01b031991909116815260200190565b60006020825282518060208401526112ae81604085016020870161175f565b601f01601f19169190910160400192915050565b60208082526010908201526f4e6f2064796e616d696320706172616d60801b604082015260600190565b6020808252600e908201526d24b73b30b634b21031b0b63632b960911b604082015260600190565b6020808252601590820152744375626520636f756e746572206e6f74207a65726f60581b604082015260600190565b60208082526022908201527f4c6f636174696f6e20636f756e74206c657373207468616e2072656620636f756040820152611b9d60f21b606082015260800190565b6020808252818101527f4c6f636174696f6e20636f756e7420657863656564732072656620636f756e74604082015260600190565b60208082526026908201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6040820152651c8818d85b1b60d21b606082015260800190565b6020808252601490820152734e6f7420616c6c6f7765642066726f6d20454f4160601b604082015260600190565b602080825260149082015273496e76616c69642048616e646c6572205479706560601b604082015260600190565b6020808252600d908201526c53746174696320706172616d7360981b604082015260600190565b6020808252600f908201526e24b73b30b634b2103430b7323632b960891b604082015260600190565b6020808252601d908201527f446f6573206e6f7420616c6c6f772065787465726e616c2063616c6c73000000604082015260600190565b6020808252602c908201527f52657475726e206e756d20616e64207061727365642072657475726e206e756d60408201526b081b9bdd081b585d18da195960a21b606082015260800190565b6020808252600b908201526a737461636b20656d70747960a81b604082015260600190565b6020808252600e908201526d737461636b206f766572666c6f7760901b604082015260600190565b60208082526021908201527f546f7320616e64206461746173206c656e67746820696e636f6e73697374656e6040820152601d60fa1b606082015260800190565b6020808252600f908201526e537461636b206e6f7420656d70747960881b604082015260600190565b60208082526023908201527f546f7320616e6420636f6e66696773206c656e67746820696e636f6e73697374604082015262195b9d60ea1b606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252601e908201527f5265666572656e636520746f206f7574206f66206c6f63616c537461636b0000604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b6020808252601c908201527f53656e6465722073686f756c6420626520696e697469616c697a656400000000604082015260600190565b60405181810167ffffffffffffffff8111828210171561173757600080fd5b604052919050565b600067ffffffffffffffff821115611755578081fd5b5060209081020190565b60005b8381101561177a578181015183820152602001611762565b83811115611789576000848401525b5050505056feb2f2618cecbbb6e7468cc0f2aa43858ad8d153e0280b22285e28e853bb9d453af9543f11459ccccd21306c8881aaab675ff49d988c1162fd1dd9bbcdbe4446bea264697066735822122005daa6c0f08ef29d3ed91c7a405e01599c80776675051ed6192403c9feb744c564736f6c634300060c0033

000000000000000000000000d4258b13c9fadb7623ca4b15dda34b7b85b842c7

-----Decoded View---------------
Arg [0] : registry (address): 0xd4258B13C9FADb7623Ca4b15DdA34b7b85b842C7

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000d4258b13c9fadb7623ca4b15dda34b7b85b842c7

26278:10210:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26958:30;26977:10;26958:18;:30::i;:::-;26950:63;;;;-1:-1:-1;;;26950:63:0;;;;;;;:::i;:::-;;;;;;;;;27221:8;:20;27217:491;;27266:20;27275:10;27266:8;:20::i;:::-;27258:47;;;;-1:-1:-1;;;27258:47:0;;;;;;;:::i;:::-;27322:14;27382;:12;:14::i;:::-;-1:-1:-1;;;;;27372:31:0;;27404:10;27372:43;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27356:61;;27322:95;;27432:19;27454:23;27460:6;27468:8;;27454:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27454:5:0;;-1:-1:-1;;;27454:23:0:i;:::-;27563:13;;27432:45;;-1:-1:-1;27642:4:0;27630:17;;27563:13;27630:17;27665;27600:97;26278:10210;5177:107;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5358:109;;;;;;;;;;;;;:::i;27997:233::-;;;;;;:::i;:::-;;:::i;28453:338::-;;;;;;:::i;:::-;;:::i;6673:49::-;;;;;;;;;;;;;:::i;5065:40::-;;;;;;;;;;-1:-1:-1;5065:40:0;;;;;:::i;:::-;;:::i;5036:22::-;;;;;;;;;;-1:-1:-1;5036:22:0;;;;;:::i;:::-;;:::i;6566:51::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;7901:422::-;8268:20;;8307:8;;7901:422;;;;:::o;36346:139::-;36404:11;36445:14;:12;:14::i;:::-;-1:-1:-1;;;;;36435:33:0;;36469:7;36435:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;36428:49;36346:139;-1:-1:-1;;36346:139:0:o;36095:183::-;26542:66;36249:11;;36222:49::o;33149:889::-;33233:19;33278:13;33287:3;33278:8;:13::i;:::-;33270:41;;;;-1:-1:-1;;;33270:41:0;;;;;;;:::i;:::-;33322:17;:15;:17::i;:::-;33565:1;33545;33520:5;33514:12;33490:4;33483:5;33479:16;33457:3;33433:4;33426:5;33422:16;33391:190;33607:16;33655:4;33649:11;33639:21;;33770:4;33766:9;33759:4;33752;33746;33742:15;33738:26;33734:42;33726:6;33722:55;33699:4;33674:118;33821:4;33813:6;33806:20;33877:4;33874:1;33867:4;33859:6;33855:17;33840:42;33912:9;33905:17;33945:1;33940:80;;;;33898:122;;33940:80;33996:4;33989;33981:6;33977:17;33970:31;33898:122;;;;33359:672;;;;:::o;5177:107::-;-1:-1:-1;;;;;;;;;;;5177:107:0;:::o;5358:109::-;-1:-1:-1;;;;;;;;;;;5358:109:0;:::o;27997:233::-;28146:13;:11;:13::i;:::-;28170:27;28177:3;28182:7;28191:5;28170:6;:27::i;:::-;28208:14;:12;:14::i;:::-;27997:233;;;:::o;28453:338::-;28606:10;28628:4;28606:27;28598:69;;;;-1:-1:-1;;;28598:69:0;;;;;;;:::i;:::-;28710:1;28686:12;:10;:12::i;:::-;-1:-1:-1;;;;;28686:26:0;;;28678:67;;;;-1:-1:-1;;;28678:67:0;;;;;;;:::i;:::-;28756:27;28763:3;28768:7;28777:5;28756:6;:27::i;6673:49::-;6715:7;6673:49;:::o;5065:40::-;;;;;;;;;;;;;:::o;5036:22::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5036:22:0;:::o;6566:51::-;-1:-1:-1;;;6566:51:0;:::o;6079:112::-;6126:57;-1:-1:-1;;;;;;;;;;;6161:17:0;:15;:17::i;:::-;6181:1;;6126:57;6161:21;;6126:16;:57::i;:::-;6079:112::o;34798:130::-;5519:5;:12;:17;5511:45;;;;-1:-1:-1;;;5511:45:0;;;;;;;:::i;:::-;5632:17:::1;:15;:17::i;:::-;:22:::0;5624:56:::1;;;;-1:-1:-1::0;;;5624:56:0::1;;;;;;;:::i;:::-;34908:12:::2;:10;:12::i;28996:1536::-:0;29136:30;;:::i;:::-;29177:13;29243:5;:12;29229:3;:10;:26;29207:109;;;;-1:-1:-1;;;29207:109:0;;;;;;;:::i;:::-;29363:7;:14;29349:3;:10;:28;29327:113;;;;-1:-1:-1;;;29327:113:0;;;;;;;:::i;:::-;29456:9;29451:1074;29475:3;:10;29471:1;:14;29451:1074;;;29573:21;:7;29581:1;29573:10;;;;;;;;;;;;;;:19;:21::i;:::-;29568:205;;29711:46;29717:5;29723:1;29717:8;;;;;;;;;;;;;;29727:7;29735:1;29727:10;;;;;;;;;;;;;;29739;29751:5;29711;:46::i;:::-;29857:25;:7;29865:1;29857:10;;;;;;;;;;;;;;:23;:25::i;:::-;29853:547;;;29977:11;29991:25;:7;29999:1;29991:10;;;;;;;;;;;;;;:23;:25::i;:::-;29977:39;;30035:16;30075:50;30082:10;30094:23;30100:3;30104:1;30100:6;;;;;;;;;;;;;;30108:5;30114:1;30108:8;;;;;;;;;;;;;;30094:5;:23::i;:::-;30119:5;30075:6;:50::i;:::-;30035:90;;30194:3;30186:5;:11;30174:8;:23;30144:141;;;;-1:-1:-1;;;30144:141:0;;;;;;;:::i;:::-;30312:8;-1:-1:-1;29853:547:0;;-1:-1:-1;29853:547:0;;30361:23;30367:3;30371:1;30367:6;;;;;;;;;;;;;;30375:5;30381:1;30375:8;;;;;;;30361:23;;29853:547;30490:23;30506:3;30510:1;30506:6;;;;;;;;;;;;;;30490:15;:23::i;:::-;29487:3;;29451:1074;;;;28996:1536;;;;;:::o;34977:1058::-;35357:1;35342:12;:16;35335:429;;35375:12;35390:18;:5;:16;:18::i;:::-;35375:33;-1:-1:-1;;;;;;35427:18:0;;35423:330;;35473:18;:5;:16;:18::i;:::-;35522:39;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35522:39:0;-1:-1:-1;;;35522:39:0;;;35466:25;;-1:-1:-1;35510:52:0;;35466:25;;35510:5;:52::i;:::-;;35423:330;;;35620:37;;-1:-1:-1;;;35620:37:0;;35603:14;;-1:-1:-1;;;;;35620:22:0;;;;;:37;;35651:4;;35620:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;35603:54;-1:-1:-1;35680:10:0;;35676:61;;35692:45;-1:-1:-1;;;;;35692:25:0;;35718:10;35730:6;35692:25;:45::i;:::-;35423:330;;35335:429;;;;35845:21;35881:10;;35877:43;;35893:27;;:10;;:27;;;;;35913:6;;35893:27;;;;35913:6;35893:10;:27;;;;;;;;;;;;;;;;;;;;;35877:43;35983:14;:12;:14::i;:::-;36008:19;:17;:19::i;:::-;34977:1058;:::o;5959:112::-;6004:7;6031:32;:5;-1:-1:-1;;;;;;;;;;;6031:16:0;:32::i;:::-;6024:39;;5959:112;:::o;6301:119::-;6351:7;6378:34;:5;-1:-1:-1;;;;;;;;;;;6378:16:0;:34::i;4007:186::-;4170:15;4155:12;;;;;;;;;;;:30;4007:186::o;5708:139::-;5778:1;5754:12;:10;:12::i;:::-;-1:-1:-1;;;;;5754:26:0;;5750:89;;;5795:44;:5;-1:-1:-1;;;;;;;;;;;5828:10:0;5795:16;:44::i;746:148::-;801:4;-1:-1:-1;;;822:18:0;;818:68;;-1:-1:-1;854:4:0;847:11;;818:68;-1:-1:-1;881:5:0;874:12;;30797:1214;31021:21;31044:23;31071:18;:6;:16;:18::i;:::-;31020:69;;;;31165:9;31160:844;31184:4;:11;31180:1;:15;31160:844;;;31235:5;31225:4;31230:1;31225:7;;;;;;;;;;;;;;:15;31217:58;;;;-1:-1:-1;;;31217:58:0;;;;;;;:::i;:::-;31290:11;31304:10;31315:4;31320:1;31315:7;;;;;;;;;;;;;;31304:19;;;;;;;;;;;31290:33;;31338:14;31355:6;31362:1;31355:9;;;;;;;;;;;;;;31338:26;;31379:12;6715:7;31379:30;;31484:6;31477:4;31471;31467:15;31463:28;31524:3;31518:10;31649:1;31642:9;31632:2;;31741:3;31738:1;31734:11;31791:3;31787:1;31784;31780:9;31777:18;31767:2;;31834:1;31831;31824:12;31767:2;31913:12;;;;-1:-1:-1;31632:2:0;-1:-1:-1;31962:16:0;;;;-1:-1:-1;;31197:3:0;;31160:844;;;;30797:1214;;;;;;:::o;902:152::-;961:4;982:18;995:4;982:12;:18::i;:::-;978:68;;-1:-1:-1;1014:5:0;1007:12;;978:68;-1:-1:-1;1042:4:0;1035:11;;1062:181;734:3;1160:45;;;;1062:181::o;32240:749::-;32421:10;;32516:2;32510:8;;32502:16;;;32549:3;32537:15;;;32529:42;;;;-1:-1:-1;;;32529:42:0;;;;;;;:::i;:::-;32627:5;32624:1;32620:13;32726:1;32694:277;32749:3;32746:1;32743:10;32694:277;;;32931:4;32918:11;;;32914:22;;32908:29;32870:14;;;32854:31;;32825:131;32778:12;32694:277;;;32698:44;;32591:391;;;;;;:::o;34152:598::-;34364:5;:12;34360:383;;34398:7;;34360:383;-1:-1:-1;;;34440:12:0;:5;:10;:12::i;:::-;:60;34422:321;;;34527:5;:11;;;;;;;;;;;;;;;;;;;;;;;;34617:12;:5;:10;:12::i;:::-;-1:-1:-1;;;;;;34610:34:0;;34606:61;;34646:21;:5;34663:3;34646:16;:21::i;:::-;34682:49;:5;34711:18;34682:20;:49::i;2819:187::-;2901:11;2960:12;2965:6;2960:4;:12::i;:::-;2952:21;;2930:45;;2986:6;:12;;;;;;;;;;;;;;;;;;;;;;;;2819:187;;;:::o;23020:177::-;23103:86;23123:5;23153:23;;;23178:2;23182:5;23130:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23130:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;23130:58:0;-1:-1:-1;;;;;;23130:58:0;;;;;;;;;;23103:19;:86::i;5855:96::-;5899:44;:5;-1:-1:-1;;;;;;;;;;;5916:14:0;5899:16;:44::i;6199:94::-;6248:37;:5;-1:-1:-1;;;;;;;;;;;6265:16:0;6248;:37::i;4201:203::-;4327:11;4381:12;;;;;;;;;;;;;4201:203::o;3795:204::-;3958:33;3943:12;;;;;;;;;;;-1:-1:-1;;;;;3966:24:0;;;3943:48;;3795:204::o;1251:1006::-;1334:21;1357:23;1407:14;1416:4;1407:8;:14::i;:::-;1406:15;1398:41;;;;-1:-1:-1;;;1398:41:0;;;;;;;:::i;:::-;1450:9;1474:117;388:66;1481:16;;;:29;:47;;;;;626:2;1514:1;:14;1481:47;1474:117;;;1578:1;1570:9;;;;;1545:3;;1474:117;;;626:2;1605:14;1638:5;1630:34;;;;-1:-1:-1;;;1630:34:0;;;;;;;:::i;:::-;1696:1;1682:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1682:16:0;;1675:23;;1732:1;1718:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1718:16:0;;1709:25;;1750:9;1745:125;1769:1;1765;:5;1745:125;;;1792:7;;388:66;1810:16;;;1792:4;;1797:1;;1792:7;;;;;;;;;;;;;;;:35;1857:1;1849:9;;;;;1772:3;;1745:125;;;;1880:9;1909;1904:282;680:2;1924:1;:21;1904:282;;;269:66;1971:18;;:23;1967:177;;2027:1;2023;:5;2015:50;;;;-1:-1:-1;;;2015:50:0;;;;;;;:::i;:::-;2096:1;2100:2;2096:6;2105:1;2096:10;2084:6;2091:1;2084:9;;;;;;;;;;;;;;;;;:22;2125:3;;;;;1967:177;2173:1;2165:9;;;;1947:3;1904:282;;;;2209:1;2204;:6;2196:53;;;;-1:-1:-1;;;2196:53:0;;;;;;;:::i;:::-;1251:1006;;;;;:::o;3300:210::-;3427:13;;3390:11;;3419:41;;;;-1:-1:-1;;;3419:41:0;;;;;;;:::i;:::-;3484:13;;3477:6;;-1:-1:-1;;3484:17:0;;;3477:25;;;;;;;;;;;;;;3471:31;;3300:210;;;:::o;2364:136::-;2446:46;;;;;;;2458:33;2446:46;;;;;;;-1:-1:-1;;;;;2466:24:0;;;2446:46;;;2364:136::o;2618:193::-;2712:19;;;2704:52;;;;-1:-1:-1;;;2704:52:0;;;;;;;:::i;:::-;2767:36;;;;;;;-1:-1:-1;2767:36:0;;;;;;;2779:23;;;;;-1:-1:-1;;;;;;2767:36:0;;;;2618:193::o;25325:761::-;25749:23;25775:69;25803:4;25775:69;;;;;;;;;;;;;;;;;25783:5;-1:-1:-1;;;;;25775:27:0;;;:69;;;;;:::i;:::-;25859:17;;25749:95;;-1:-1:-1;25859:21:0;25855:224;;26001:10;25990:30;;;;;;;;;;;;:::i;:::-;25982:85;;;;-1:-1:-1;;;25982:85:0;;;;;;;:::i;10819:195::-;10922:12;10954:52;10976:6;10984:4;10990:1;10993:12;10954:21;:52::i;:::-;10947:59;;10819:195;;;;;;:::o;11871:530::-;11998:12;12056:5;12031:21;:30;;12023:81;;;;-1:-1:-1;;;12023:81:0;;;;;;;:::i;:::-;12123:18;12134:6;12123:10;:18::i;:::-;12115:60;;;;-1:-1:-1;;;12115:60:0;;;;;;;:::i;:::-;12249:12;12263:23;12290:6;-1:-1:-1;;;;;12290:11:0;12310:5;12318:4;12290:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12248:75;;;;12341:52;12359:7;12368:10;12380:12;12341:17;:52::i;:::-;12334:59;11871:530;-1:-1:-1;;;;;;;11871:530:0:o;13407:742::-;13522:12;13551:7;13547:595;;;-1:-1:-1;13582:10:0;13575:17;;13547:595;13696:17;;:21;13692:439;;13959:10;13953:17;14020:15;14007:10;14003:2;13999:19;13992:44;13907:148;14102:12;14095:20;;-1:-1:-1;;;14095:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;-1:-1;;;;;27860:54;;28979:35;;28969:2;;29028:1;;29018:12;893:707;;1010:3;1003:4;995:6;991:17;987:27;977:2;;-1:-1;;1018:12;977:2;1065:6;1052:20;1087:80;1102:64;1159:6;1102:64;:::i;:::-;1087:80;:::i;:::-;1195:21;;;1078:89;-1:-1;1239:4;1252:14;;;;1227:17;;;1341;;;1332:27;;;;1329:36;-1:-1;1326:2;;;1378:1;;1368:12;1326:2;1403:1;1388:206;1413:6;1410:1;1407:13;1388:206;;;2539:20;;1481:50;;1545:14;;;;1573;;;;1435:1;1428:9;1388:206;;;1392:14;;;;;970:630;;;;:::o;1624:705::-;;1743:4;1750:3;1743:4;1735:6;1731:17;1727:27;1717:2;;-1:-1;;1758:12;1717:2;1805:6;1792:20;1827:89;1842:73;1908:6;1842:73;:::i;1827:89::-;1944:21;;;1818:98;-1:-1;1988:4;2001:14;;;;1976:17;;;2096:1;2081:242;2106:6;2103:1;2100:13;2081:242;;;2189:3;2176:17;1980:6;2164:30;2852:3;2833:17;2164:30;2833:17;2829:27;2819:2;;2096:1;;2860:12;2819:2;1988:4;2164:30;;2894:20;26611:18;26603:6;26600:30;26597:2;;;2096:1;;26633:12;26597:2;2929:64;26687:17;;;-1:-1;;26683:33;26764:15;;2929:64;:::i;:::-;3013:6;3006:5;2999:21;3037:17;3117:3;3037:17;3108:6;2164:30;3099:16;;3096:25;3093:2;;;2096:1;;3124:12;3093:2;28466:6;3037:17;2164:30;3037:17;1988:4;3075:5;3071:16;28443:30;-1:-1;2096:1;28504:16;;;;;28497:27;;;;2201:59;;-1:-1;2274:14;;;;2302;;;;2128:1;2121:9;2081:242;;;2085:14;;;;;;1710:619;;;;:::o;3477:917::-;;;;3699:2;3687:9;3678:7;3674:23;3670:32;3667:2;;;-1:-1;;3705:12;3667:2;3763:17;3750:31;3801:18;;3793:6;3790:30;3787:2;;;-1:-1;;3823:12;3787:2;3914:6;3903:9;3899:22;;;277:3;270:4;262:6;258:17;254:27;244:2;;-1:-1;;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;:::i;354:80::-;440:16;476:6;469:5;462:21;506:4;;523:3;519:14;512:21;;506:4;498:6;494:17;628:3;506:4;;612:6;608:17;498:6;599:27;;596:36;593:2;;;-1:-1;;635:12;593:2;-1:-1;661:10;;655:206;680:6;677:1;674:13;655:206;;;760:37;793:3;781:10;760:37;:::i;:::-;748:50;;702:1;695:9;;;;;812:14;;;;840;;655:206;;;-1:-1;3843:88;;-1:-1;3981:18;;3968:32;;-1:-1;;;4009:30;;;4006:2;;;-1:-1;;4042:12;4006:2;4072:78;4142:7;4133:6;4122:9;4118:22;4072:78;:::i;:::-;4062:88;;4215:2;4204:9;4200:18;4187:32;4173:46;;3801:18;4231:6;4228:30;4225:2;;;-1:-1;;4261:12;4225:2;;4291:87;4370:7;4361:6;4350:9;4346:22;4291:87;:::i;:::-;4281:97;;;3661:733;;;;;:::o;4401:257::-;;4513:2;4501:9;4492:7;4488:23;4484:32;4481:2;;;-1:-1;;4519:12;4481:2;2418:6;2412:13;29125:5;27542:13;27535:21;29103:5;29100:32;29090:2;;-1:-1;;29136:12;4665:241;;4769:2;4757:9;4748:7;4744:23;4740:32;4737:2;;;-1:-1;;4775:12;4737:2;-1:-1;2539:20;;4731:175;-1:-1;4731:175::o;4913:263::-;;5028:2;5016:9;5007:7;5003:23;4999:32;4996:2;;;-1:-1;;5034:12;4996:2;-1:-1;2687:13;;4990:186;-1:-1;4990:186::o;14288:271::-;;6367:5;26883:12;6478:52;6523:6;6518:3;6511:4;6504:5;6500:16;6478:52;:::i;:::-;6542:16;;;;;14422:137;-1:-1;;14422:137::o;14566:222::-;-1:-1;;;;;27860:54;;;;5921:37;;14693:2;14678:18;;14664:124::o;15040:333::-;-1:-1;;;;;27860:54;;;;5921:37;;15359:2;15344:18;;6041:37;15195:2;15180:18;;15166:207::o;15380:222::-;6041:37;;;15507:2;15492:18;;15478:124::o;15609:218::-;-1:-1;;;;;;27708:78;;;;6159:36;;15734:2;15719:18;;15705:122::o;15834:310::-;;15981:2;16002:17;15995:47;6715:5;26883:12;27322:6;15981:2;15970:9;15966:18;27310:19;6809:52;6854:6;27350:14;15970:9;27350:14;15981:2;6835:5;6831:16;6809:52;:::i;:::-;26706:9;28883:14;-1:-1;;28879:28;6873:39;;;;27350:14;6873:39;;15952:192;-1:-1;;15952:192::o;16151:416::-;16351:2;16365:47;;;7149:2;16336:18;;;27310:19;-1:-1;;;27350:14;;;7165:39;7223:12;;;16322:245::o;16574:416::-;16774:2;16788:47;;;7474:2;16759:18;;;27310:19;-1:-1;;;27350:14;;;7490:37;7546:12;;;16745:245::o;16997:416::-;17197:2;17211:47;;;7797:2;17182:18;;;27310:19;-1:-1;;;27350:14;;;7813:44;7876:12;;;17168:245::o;17420:416::-;17620:2;17634:47;;;8127:2;17605:18;;;27310:19;8163:34;27350:14;;;8143:55;-1:-1;;;8218:12;;;8211:26;8256:12;;;17591:245::o;17843:416::-;18043:2;18057:47;;;18028:18;;;27310:19;8543:34;27350:14;;;8523:55;8597:12;;;18014:245::o;18266:416::-;18466:2;18480:47;;;8848:2;18451:18;;;27310:19;8884:34;27350:14;;;8864:55;-1:-1;;;8939:12;;;8932:30;8981:12;;;18437:245::o;18689:416::-;18889:2;18903:47;;;9232:2;18874:18;;;27310:19;-1:-1;;;27350:14;;;9248:43;9310:12;;;18860:245::o;19112:416::-;19312:2;19326:47;;;9561:2;19297:18;;;27310:19;-1:-1;;;27350:14;;;9577:43;9639:12;;;19283:245::o;19535:416::-;19735:2;19749:47;;;9890:2;19720:18;;;27310:19;-1:-1;;;27350:14;;;9906:36;9961:12;;;19706:245::o;19958:416::-;20158:2;20172:47;;;10212:2;20143:18;;;27310:19;-1:-1;;;27350:14;;;10228:38;10285:12;;;20129:245::o;20381:416::-;20581:2;20595:47;;;10536:2;20566:18;;;27310:19;10572:31;27350:14;;;10552:52;10623:12;;;20552:245::o;20804:416::-;21004:2;21018:47;;;10874:2;20989:18;;;27310:19;10910:34;27350:14;;;10890:55;-1:-1;;;10965:12;;;10958:36;11013:12;;;20975:245::o;21227:416::-;21427:2;21441:47;;;11264:2;21412:18;;;27310:19;-1:-1;;;27350:14;;;11280:34;11333:12;;;21398:245::o;21650:416::-;21850:2;21864:47;;;11584:2;21835:18;;;27310:19;-1:-1;;;27350:14;;;11600:37;11656:12;;;21821:245::o;22073:416::-;22273:2;22287:47;;;11907:2;22258:18;;;27310:19;11943:34;27350:14;;;11923:55;-1:-1;;;11998:12;;;11991:25;12035:12;;;22244:245::o;22496:416::-;22696:2;22710:47;;;12286:2;22681:18;;;27310:19;-1:-1;;;27350:14;;;12302:38;12359:12;;;22667:245::o;22919:416::-;23119:2;23133:47;;;12610:2;23104:18;;;27310:19;12646:34;27350:14;;;12626:55;-1:-1;;;12701:12;;;12694:27;12740:12;;;23090:245::o;23342:416::-;23542:2;23556:47;;;12991:2;23527:18;;;27310:19;13027:31;27350:14;;;13007:52;13078:12;;;23513:245::o;23765:416::-;23965:2;23979:47;;;13329:2;23950:18;;;27310:19;13365:32;27350:14;;;13345:53;13417:12;;;23936:245::o;24188:416::-;24388:2;24402:47;;;13668:2;24373:18;;;27310:19;13704:34;27350:14;;;13684:55;-1:-1;;;13759:12;;;13752:34;13805:12;;;24359:245::o;24611:416::-;24811:2;24825:47;;;14056:2;24796:18;;;27310:19;14092:30;27350:14;;;14072:51;14142:12;;;24782:245::o;25263:256::-;25325:2;25319:9;25351:17;;;25426:18;25411:34;;25447:22;;;25408:62;25405:2;;;25483:1;;25473:12;25405:2;25325;25492:22;25303:216;;-1:-1;25303:216::o;25526:304::-;;25685:18;25677:6;25674:30;25671:2;;;-1:-1;;25707:12;25671:2;-1:-1;25752:4;25740:17;;;25805:15;;25608:222::o;28539:268::-;28604:1;28611:101;28625:6;28622:1;28619:13;28611:101;;;28692:11;;;28686:18;28673:11;;;28666:39;28647:2;28640:10;28611:101;;;28727:6;28724:1;28721:13;28718:2;;;28604:1;28783:6;28778:3;28774:16;28767:27;28718:2;;28588:219;;;:::o

ipfs://05daa6c0f08ef29d3ed91c7a405e01599c80776675051ed6192403c9feb744c5