Contract 0x69FB8Dca8067A5D38703b9e8b39cf2D51473E4b4

/**
 *Submitted for verification at FtmScan.com on 2022-01-20
*/

// Sources flattened with hardhat v2.8.2 https://hardhat.org

// File @openzeppelin/contracts/math/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity 0.7.6;
pragma experimental ABIEncoderV2;

/**
 * @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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * 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);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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/cryptography/[email protected]



/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        return recover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
        require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}


// File contracts/6/forwarder/ERC20ForwardRequestTypes.sol




/* deadline can be removed : GSN reference https://github.com/opengsn/gsn/blob/master/contracts/forwarder/IForwarder.sol (Saves 250 more gas)*/
/**
* This contract defines a struct which both ERC20FeeProxy and BiconomyForwarder inherit. ERC20ForwardRequest specifies all the fields present in the GSN V2 ForwardRequest struct, 
* but adds the following :
* address token
* uint256 tokenGasPrice
* uint256 txGas
* uint256 batchNonce (can be removed)
* uint256 deadline 
* Fields are placed in type order, to minimise storage used when executing transactions.
*/
contract ERC20ForwardRequestTypes{

/*allow the EVM to optimize for this, 
ensure that you try to order your storage variables and struct members such that they can be packed tightly*/

    struct ERC20ForwardRequest {
        address from; 
        address to; 
        address token; 
        uint256 txGas;
        uint256 tokenGasPrice;
        uint256 batchId; 
        uint256 batchNonce; 
        uint256 deadline; 
        bytes data;
    }

     struct PermitRequest {
        address holder; 
        address spender;  
        uint256 value;
        uint256 nonce;
        uint256 expiry;
        bool allowed; 
        uint8 v;
        bytes32 r; 
        bytes32 s; 
    }

    
}


// File contracts/6/libs/Ownable.sol


/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor(address owner) public {
        _owner = owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(
            isOwner(),
            "Only contract owner is allowed to perform this operation"
        );
        _;
    }

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

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * @notice Renouncing to ownership will leave the contract without an owner.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


// File contracts/6/forwarder/BiconomyForwarder.sol







/**
 *
 * @title BiconomyForwarder
 *
 * @notice A trusted forwarder for Biconomy relayed meta transactions
 *
 * @dev - Inherits the ERC20ForwarderRequest struct
 * @dev - Verifies EIP712 signatures
 * @dev - Verifies personalSign signatures
 * @dev - Implements 2D nonces... each Tx has a BatchId and a BatchNonce
 * @dev - Keeps track of highest BatchId used by a given address, to assist in encoding of transactions client-side
 * @dev - maintains a list of verified domain seperators
 *
 */
contract BiconomyForwarder is ERC20ForwardRequestTypes,Ownable{
    using ECDSA for bytes32;

    mapping(bytes32 => bool) public domains;

    uint256 chainId;

    string public constant EIP712_DOMAIN_TYPE = "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)";

    bytes32 public constant REQUEST_TYPEHASH = keccak256(bytes("ERC20ForwardRequest(address from,address to,address token,uint256 txGas,uint256 tokenGasPrice,uint256 batchId,uint256 batchNonce,uint256 deadline,bytes data)"));

    mapping(address => mapping(uint256 => uint256)) nonces;

    constructor(
        address _owner
    ) public Ownable(_owner){
        uint256 id;
        assembly {
            id := chainid()
        }
        chainId = id;
        require(_owner != address(0), "Owner Address cannot be 0");
    }
    /**
     * @dev registers domain seperators, maintaining that all domain seperators used for EIP712 forward requests use...
     * ... the address of this contract and the chainId of the chain this contract is deployed to
     * @param name : name of dApp/dApp fee proxy
     * @param version : version of dApp/dApp fee proxy
     */
    function registerDomainSeparator(string calldata name, string calldata version) external onlyOwner{
        uint256 id;
        /* solhint-disable-next-line no-inline-assembly */
        assembly {
            id := chainid()
        }

        bytes memory domainValue = abi.encode(
            keccak256(bytes(EIP712_DOMAIN_TYPE)),
            keccak256(bytes(name)),
            keccak256(bytes(version)),
            address(this),
            bytes32(id));

        bytes32 domainHash = keccak256(domainValue);

        domains[domainHash] = true;
        emit DomainRegistered(domainHash, domainValue);
    }

    event DomainRegistered(bytes32 indexed domainSeparator, bytes domainValue);

    event MetaTransactionExecuted(address indexed userAddress, address payable indexed relayerAddress, bytes indexed functionSignature);

    /**
     * @dev returns a value from the nonces 2d mapping
     * @param from : the user address
     * @param batchId : the key of the user's batch being queried
     * @return nonce : the number of transaction made within said batch
     */
    function getNonce(address from, uint256 batchId)
    public view
    returns (uint256) {
        return nonces[from][batchId];
    }

    /**
     * @dev an external function which exposes the internal _verifySigEIP712 method
     * @param req : request being verified
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     */
    function verifyEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes calldata sig)
    external view {
        _verifySigEIP712(req, domainSeparator, sig);
    }

    /**
     * @dev verifies the call is valid by calling _verifySigEIP712
     * @dev executes the forwarded call if valid
     * @dev updates the nonce after
     * @param req : request being executed
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     * @return success : false if call fails. true otherwise
     * @return ret : any return data from the call
     */
    function executeEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes calldata sig
    )
    external 
    returns (bool success, bytes memory ret) {
        _verifySigEIP712(req,domainSeparator,sig);
        _updateNonce(req);
        /* solhint-disable-next-line avoid-low-level-calls */
         (success,ret) = req.to.call{gas : req.txGas}(abi.encodePacked(req.data, req.from));
         // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        assert(gasleft() > req.txGas / 63);
        _verifyCallResult(success,ret,"Forwarded call to destination did not succeed");
        emit MetaTransactionExecuted(req.from, msg.sender, req.data);
    }

    /**
     * @dev an external function which exposes the internal _verifySigPersonSign method
     * @param req : request being verified
     * @param sig : the signature generated by the user's wallet
     */
    function verifyPersonalSign(
        ERC20ForwardRequest calldata req,
        bytes calldata sig)
    external view {
        _verifySigPersonalSign(req, sig);
    }

    /**
     * @dev verifies the call is valid by calling _verifySigPersonalSign
     * @dev executes the forwarded call if valid
     * @dev updates the nonce after
     * @param req : request being executed
     * @param sig : the signature generated by the user's wallet
     * @return success : false if call fails. true otherwise
     * @return ret : any return data from the call
     */
    function executePersonalSign(ERC20ForwardRequest calldata req,bytes calldata sig)
    external 
    returns(bool success, bytes memory ret){
        _verifySigPersonalSign(req, sig);
        _updateNonce(req);
        (success,ret) = req.to.call{gas : req.txGas}(abi.encodePacked(req.data, req.from));
        // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        assert(gasleft() > req.txGas / 63);
        _verifyCallResult(success,ret,"Forwarded call to destination did not succeed");
        emit MetaTransactionExecuted(req.from, msg.sender, req.data);
    }

    /**
     * @dev Increments the nonce of given user/batch pair
     * @dev Updates the highestBatchId of the given user if the request's batchId > current highest
     * @dev only intended to be called post call execution
     * @param req : request that was executed
     */
    function _updateNonce(ERC20ForwardRequest calldata req) internal {
        nonces[req.from][req.batchId]++;
    }

    /**
     * @dev verifies the domain separator used has been registered via registerDomainSeparator()
     * @dev recreates the 32 byte hash signed by the user's wallet (as per EIP712 specifications)
     * @dev verifies the signature using Open Zeppelin's ECDSA library
     * @dev signature valid if call doesn't throw
     *
     * @param req : request being executed
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     *
     */
    function _verifySigEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes memory sig)
    internal
    view
    {   
        uint256 id;
        /* solhint-disable-next-line no-inline-assembly */
        assembly {
            id := chainid()
        }
        require(req.deadline == 0 || block.timestamp + 20 <= req.deadline, "request expired");
        require(domains[domainSeparator], "unregistered domain separator");
        require(chainId == id, "potential replay attack on the fork");
        bytes32 digest =
            keccak256(abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                keccak256(abi.encode(REQUEST_TYPEHASH,
                            req.from,
                            req.to,
                            req.token,
                            req.txGas,
                            req.tokenGasPrice,
                            req.batchId,
                            nonces[req.from][req.batchId],
                            req.deadline,
                            keccak256(req.data)
                        ))));
        require(digest.recover(sig) == req.from, "signature mismatch");
    }

    /**
     * @dev encodes a 32 byte data string (presumably a hash of encoded data) as per eth_sign
     *
     * @param hash : hash of encoded data that signed by user's wallet using eth_sign
     * @return input hash encoded to matched what is signed by the user's key when using eth_sign*/
    function prefixed(bytes32 hash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev recreates the 32 byte hash signed by the user's wallet
     * @dev verifies the signature using Open Zeppelin's ECDSA library
     * @dev signature valid if call doesn't throw
     *
     * @param req : request being executed
     * @param sig : the signature generated by the user's wallet
     *
     */
    function _verifySigPersonalSign(
        ERC20ForwardRequest calldata req,
        bytes memory sig)
    internal
    view
    {
        require(req.deadline == 0 || block.timestamp + 20 <= req.deadline, "request expired");
        bytes32 digest = prefixed(keccak256(abi.encodePacked(
            req.from,
            req.to,
            req.token,
            req.txGas,
            req.tokenGasPrice,
            req.batchId,
            nonces[req.from][req.batchId],
            req.deadline,
            keccak256(req.data)
        )));
        require(digest.recover(sig) == req.from, "signature mismatch");
    }

    /**
     * @dev verifies the call result and bubbles up revert reason for failed calls
     *
     * @param success : outcome of forwarded call
     * @param returndata : returned data from the frowarded call
     * @param errorMessage : fallback error message to show 
     */
     function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure {
        if (!success) {
            // 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);
            }
        }
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"indexed":false,"internalType":"bytes","name":"domainValue","type":"bytes"}],"name":"DomainRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":true,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":true,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"EIP712_DOMAIN_TYPE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REQUEST_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"domains","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ERC20ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"executeEIP712","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"ret","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ERC20ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"executePersonalSign","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"ret","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"batchId","type":"uint256"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"}],"name":"registerDomainSeparator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ERC20ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"verifyEIP712","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ERC20ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"verifyPersonalSign","outputs":[],"stateMutability":"view","type":"function"}]

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

000000000000000000000000949019bf1fae7004ec3009e72b4f15c27f4147d1

-----Decoded View---------------
Arg [0] : _owner (address): 0x949019bf1fae7004ec3009e72b4f15c27f4147d1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000949019bf1fae7004ec3009e72b4f15c27f4147d1

15788:10349:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19250:786;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;20261:171;;;;;;:::i;:::-;;:::i;:::-;;14439:140;;;:::i;20843:656::-;;;;;;:::i;:::-;;:::i;18100:136::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;13889:79::-;;;:::i;:::-;;;;;;;:::i;14061:92::-;;;:::i;:::-;;;;;;;:::i;16984:632::-;;;;;;:::i;:::-;;:::i;16095:220::-;;;:::i;18546:210::-;;;;;;:::i;:::-;;:::i;15961:125::-;;;:::i;:::-;;;;;;;:::i;15889:39::-;;;;;;:::i;:::-;;:::i;14756:109::-;;;;;;:::i;:::-;;:::i;19250:786::-;19415:12;19429:16;19458:41;19475:3;19479:15;19495:3;;19458:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19458:16:0;;-1:-1:-1;;;19458:41:0:i;:::-;19510:17;19523:3;19510:12;:17::i;:::-;19618:6;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19618:11:0;19636:9;;;;19664:8;;;;19636:3;19664:8;:::i;:::-;19674;;;;:3;:8;:::i;:::-;19647:36;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;19647:36:0;;;;;;;;;;19618:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19602:82:0;;-1:-1:-1;19602:82:0;-1:-1:-1;19865:2:0;19853:9;;;;:14;19841:9;:26;19834:34;;;;19879:78;19897:7;19905:3;19879:78;;;;;;;;;;;;;;;;;:17;:78::i;:::-;20019:8;;;;:3;:8;:::i;:::-;19973:55;;;;;;;:::i;:::-;;;;;;;;;20007:10;19997:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;19973:55:0;;;;;;;;;;;19250:786;;;;;;;:::o;20261:171::-;20392:32;20415:3;20420;;20392:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20392:22:0;;-1:-1:-1;;;20392:32:0:i;:::-;20261:171;;;:::o;14439:140::-;13708:9;:7;:9::i;:::-;13686:115;;;;-1:-1:-1;;;13686:115:0;;;;;;;:::i;:::-;;;;;;;;;14538:1:::1;14522:6:::0;;14501:40:::1;::::0;-1:-1:-1;;;;;14522:6:0;;::::1;::::0;14501:40:::1;::::0;14538:1;;14501:40:::1;14569:1;14552:19:::0;;-1:-1:-1;;;;;;14552:19:0::1;::::0;;14439:140::o;20843:656::-;20953:12;20967:16;20995:32;21018:3;21023;;20995:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20995:22:0;;-1:-1:-1;;;20995:32:0:i;:::-;21038:17;21051:3;21038:12;:17::i;:::-;21082:6;;;;;;;;:::i;:::-;-1:-1:-1;;;;;21082:11:0;21100:9;;;;21128:8;;;;21100:3;21128:8;:::i;:::-;21138;;;;:3;:8;:::i;:::-;21111:36;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;21111:36:0;;;;;;;;;;21082:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21066:82:0;;-1:-1:-1;21066:82:0;-1:-1:-1;21328:2:0;21316:9;;;;:14;21304:9;:26;21297:34;;;;21342:78;21360:7;21368:3;21342:78;;;;;;;;;;;;;;;;;:17;:78::i;:::-;21482:8;;;;:3;:8;:::i;:::-;21436:55;;;;;;;:::i;:::-;;;;;;;;;21470:10;21460:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;21436:55:0;;;;;;;;;;;20843:656;;;;;;:::o;18100:136::-;-1:-1:-1;;;;;18207:12:0;;;;18180:7;18207:12;;;:6;:12;;;;;;;;:21;;;;;;;;;18100:136::o;13889:79::-;13927:7;13954:6;-1:-1:-1;;;;;13954:6:0;13889:79;:::o;14061:92::-;14101:4;14139:6;-1:-1:-1;;;;;14139:6:0;14125:10;:20;;14061:92::o;16984:632::-;13708:9;:7;:9::i;:::-;13686:115;;;;-1:-1:-1;;;13686:115:0;;;;;;;:::i;:::-;17093:10:::1;17204:9;17198:15;;17236:24;17304:18;;;;;;;;;;;;;;;;;17288:36;;;;;;17355:4;;17339:22;;;;;;;:::i;:::-;;;;;;;;17392:7;;17376:25;;;;;;;:::i;:::-;;::::0;;;;::::1;::::0;;17263:193:::1;::::0;;;17424:4:::1;::::0;17452:2;;17263:193:::1;;;:::i;:::-;;::::0;;-1:-1:-1;;17263:193:0;;::::1;::::0;;;;;;17490:22;;17263:193:::1;17490:22:::0;;::::1;::::0;;;;17469:18:::1;17525:19:::0;;;17547:4:::1;17525:19:::0;;;;;;;;:26;;-1:-1:-1;;17525:26:0::1;::::0;;::::1;::::0;;17263:193;-1:-1:-1;17490:22:0;;;17567:41:::1;::::0;::::1;::::0;17263:193;;17567:41:::1;:::i;:::-;;;;;;;;13812:1;;;16984:632:::0;;;;:::o;16095:220::-;16148:166;;;;;;;;;;;;;;;;;16138:177;;;;;;16095:220;:::o;18546:210::-;18705:43;18722:3;18727:15;18744:3;;18705:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18705:16:0;;-1:-1:-1;;;18705:43:0:i;:::-;18546:210;;;;:::o;15961:125::-;;;;;;;;;;;;;;;;;;;:::o;15889:39::-;;;;;;;;;;;;;;;:::o;14756:109::-;13708:9;:7;:9::i;:::-;13686:115;;;;-1:-1:-1;;;13686:115:0;;;;;;;:::i;:::-;14829:28:::1;14848:8;14829:18;:28::i;:::-;14756:109:::0;:::o;22468:1245::-;22753:9;22791:12;;;;:17;;:57;;;22836:3;:12;;;22812:15;22830:2;22812:20;:36;;22791:57;22783:85;;;;-1:-1:-1;;;22783:85:0;;;;;;;:::i;:::-;22887:24;;;;:7;:24;;;;;;;;22879:66;;;;-1:-1:-1;;;22879:66:0;;;;;;;:::i;:::-;22975:2;22964:7;;:13;22956:61;;;;-1:-1:-1;;;22956:61:0;;;;;;;:::i;:::-;23028:14;23132:15;16148:166;;;;;;;;;;;;;;;;;16138:177;;;;;;;;23234:8;;;;:3;:8;:::i;:::-;23273:6;;;;;;;;:::i;:::-;23310:9;;;;;;;;:::i;:::-;23350:3;:9;;;23390:3;:17;;;23438:3;:11;;;23480:6;:16;23487:3;:8;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;23480:16:0;-1:-1:-1;;;;;23480:16:0;;;;;;;;;;;;:29;23497:3;:11;;;23480:29;;;;;;;;;;;;23540:3;:12;;;23593:3;:8;;;;;;;;:::i;:::-;23583:19;;;;;;;:::i;:::-;;;;;;;;;23176:453;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23166:464;;;;;;23068:563;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23068:563:0;;;;;;;;;23058:574;;23068:563;23058:574;;;;;-1:-1:-1;23674:8:0;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;23651:31:0;:19;:6;23666:3;23651:14;:19::i;:::-;-1:-1:-1;;;;;23651:31:0;;23643:62;;;;-1:-1:-1;;;23643:62:0;;;;;;;:::i;:::-;22468:1245;;;;;:::o;21792:115::-;21868:6;:16;21875:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;21868:16:0;;;;;;;;;;;;;;;-1:-1:-1;21868:16:0;;;21885:11;;;;;21868:29;;;;;;;;:31;;;;;;21792:115::o;25461:671::-;25584:7;25579:546;;25679:17;;:21;25675:439;;25942:10;25936:17;26003:15;25990:10;25986:2;25982:19;25975:44;25890:148;26085:12;26078:20;;-1:-1:-1;;;26078:20:0;;;;;;;;:::i;24523:640::-;24674:12;;;;:17;;:57;;;24719:3;:12;;;24695:15;24713:2;24695:20;:36;;24674:57;24666:85;;;;-1:-1:-1;;;24666:85:0;;;;;;;:::i;:::-;24762:14;24779:303;24829:8;;;;:3;:8;:::i;:::-;24852:6;;;;;;;;:::i;:::-;24873:9;;;;;;;;:::i;:::-;24897;;;;24921:17;;;;24953:11;;;;24979:6;:16;24986:8;;;;24897:3;24986:8;:::i;:::-;-1:-1:-1;;;;;24979:16:0;;;;;;;;;;;;;;;-1:-1:-1;24979:16:0;;;24996:11;;;;24979:29;;;;;;;;25023:12;;;;25060:8;;;;24996:3;25060:8;:::i;:::-;25050:19;;;;;;;:::i;:::-;;;;;;;;;24798:282;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24788:293;;;;;;24779:8;:303::i;:::-;24762:320;-1:-1:-1;25124:8:0;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;25101:31:0;:19;:6;25116:3;25101:14;:19::i;:::-;-1:-1:-1;;;;;25101:31:0;;25093:62;;;;-1:-1:-1;;;25093:62:0;;;;;;;:::i;15015:187::-;-1:-1:-1;;;;;15089:22:0;;15081:31;;;;;;15149:6;;;15128:38;;-1:-1:-1;;;;;15128:38:0;;;;15149:6;;;15128:38;;;15177:6;:17;;-1:-1:-1;;;;;;15177:17:0;-1:-1:-1;;;;;15177:17:0;;;;;;;;;;15015:187::o;8689:761::-;8767:7;8830:9;:16;8850:2;8830:22;8826:96;;8869:41;;-1:-1:-1;;;8869:41:0;;;;;;;:::i;8826:96::-;9283:4;9268:20;;9262:27;9329:4;9314:20;;9308:27;9383:4;9368:20;;9362:27;8991:9;9354:36;9420:22;9428:4;9354:36;9262:27;9308;9420:7;:22::i;:::-;9413:29;8689:761;-1:-1:-1;;;;;;8689:761:0:o;24021:159::-;24076:7;24166:4;24113:58;;;;;;;;:::i;:::-;;;;;;;;;;;;;24103:69;;;;;;24096:76;;24021:159;;;;:::o;9604:1432::-;9689:7;10614:66;10600:80;;;10592:127;;;;-1:-1:-1;;;10592:127:0;;;;;;;:::i;:::-;10738:1;:7;;10743:2;10738:7;:18;;;;10749:1;:7;;10754:2;10749:7;10738:18;10730:65;;;;-1:-1:-1;;;10730:65:0;;;;;;;:::i;:::-;10893:14;10910:24;10920:4;10926:1;10929;10932;10910:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;10910:24:0;;-1:-1:-1;;10910:24:0;;;-1:-1:-1;;;;;;;10953:20:0;;10945:57;;;;-1:-1:-1;;;10945:57:0;;;;;;;:::i;:::-;11022:6;9604:1432;-1:-1:-1;;;;;9604:1432:0:o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:377;;;311:3;304:4;296:6;292:17;288:27;278:2;;336:8;326;319:26;278:2;-1:-1:-1;366:20:1;;409:18;398:30;;395:2;;;448:8;438;431:26;395:2;492:4;484:6;480:17;468:29;;544:3;537:4;528:6;520;516:19;512:30;509:39;506:2;;;561:1;558;551:12;506:2;268:303;;;;;:::o;576:179::-;;696:3;687:6;682:3;678:16;674:26;671:2;;;717:5;710;703:20;671:2;-1:-1:-1;743:6:1;661:94;-1:-1:-1;661:94:1:o;760:198::-;;872:2;860:9;851:7;847:23;843:32;840:2;;;893:6;885;878:22;840:2;921:31;942:9;921:31;:::i;:::-;911:41;830:128;-1:-1:-1;;;830:128:1:o;963:266::-;;;1092:2;1080:9;1071:7;1067:23;1063:32;1060:2;;;1113:6;1105;1098:22;1060:2;1141:31;1162:9;1141:31;:::i;:::-;1131:41;1219:2;1204:18;;;;1191:32;;-1:-1:-1;;;1050:179:1:o;1234:190::-;;1346:2;1334:9;1325:7;1321:23;1317:32;1314:2;;;1367:6;1359;1352:22;1314:2;-1:-1:-1;1395:23:1;;1304:120;-1:-1:-1;1304:120:1:o;1429:753::-;;;;;1598:2;1586:9;1577:7;1573:23;1569:32;1566:2;;;1619:6;1611;1604:22;1566:2;1664:9;1651:23;1693:18;1734:2;1726:6;1723:14;1720:2;;;1755:6;1747;1740:22;1720:2;1799:60;1851:7;1842:6;1831:9;1827:22;1799:60;:::i;:::-;1878:8;;-1:-1:-1;1773:86:1;-1:-1:-1;1966:2:1;1951:18;;1938:32;;-1:-1:-1;1982:16:1;;;1979:2;;;2016:6;2008;2001:22;1979:2;;2060:62;2114:7;2103:8;2092:9;2088:24;2060:62;:::i;:::-;1556:626;;;;-1:-1:-1;2141:8:1;-1:-1:-1;;;;1556:626:1:o;2187:790::-;;;;;2390:2;2378:9;2369:7;2365:23;2361:32;2358:2;;;2411:6;2403;2396:22;2358:2;2456:9;2443:23;2485:18;2526:2;2518:6;2515:14;2512:2;;;2547:6;2539;2532:22;2512:2;2575:82;2649:7;2640:6;2629:9;2625:22;2575:82;:::i;:::-;2565:92;;2704:2;2693:9;2689:18;2676:32;2666:42;;2761:2;2750:9;2746:18;2733:32;2717:48;;2790:2;2780:8;2777:16;2774:2;;;2811:6;2803;2796:22;2982:722;;;;3168:2;3156:9;3147:7;3143:23;3139:32;3136:2;;;3189:6;3181;3174:22;3136:2;3234:9;3221:23;3263:18;3304:2;3296:6;3293:14;3290:2;;;3325:6;3317;3310:22;3290:2;3353:82;3427:7;3418:6;3407:9;3403:22;3353:82;:::i;:::-;3343:92;;3488:2;3477:9;3473:18;3460:32;3444:48;;3517:2;3507:8;3504:16;3501:2;;;3538:6;3530;3523:22;3501:2;;3582:62;3636:7;3625:8;3614:9;3610:24;3582:62;:::i;:::-;3126:578;;3663:8;;-1:-1:-1;3556:88:1;;-1:-1:-1;;;;3126:578:1:o;3709:259::-;;3790:5;3784:12;3817:6;3812:3;3805:19;3833:63;3889:6;3882:4;3877:3;3873:14;3866:4;3859:5;3855:16;3833:63;:::i;:::-;3950:2;3929:15;-1:-1:-1;;3925:29:1;3916:39;;;;3957:4;3912:50;;3760:208;-1:-1:-1;;3760:208:1:o;3973:811::-;-1:-1:-1;;4396:2:1;4392:15;;;4388:24;;4376:37;;4447:15;;;4443:24;;4438:2;4429:12;;4422:46;4502:15;;;;4498:24;;;4493:2;4484:12;;4477:46;4548:2;4539:12;;4532:28;;;;4585:2;4576:12;;4569:28;;;;4622:3;4613:13;;4606:29;4660:3;4651:13;;4644:29;4698:3;4689:13;;4682:29;;;;4736:3;4727:13;;4720:29;;;;4774:3;4765:13;;4316:468::o;4789:273::-;;4972:6;4964;4959:3;4946:33;4998:16;;5023:15;;;4998:16;4936:126;-1:-1:-1;4936:126:1:o;5067:384::-;;5278:6;5270;5265:3;5252:33;-1:-1:-1;5372:2:1;5368:15;;;;-1:-1:-1;;5364:53:1;5304:16;;5353:65;;;5442:2;5434:11;;5242:209;-1:-1:-1;5242:209:1:o;5456:274::-;;5623:6;5617:13;5639:53;5685:6;5680:3;5673:4;5665:6;5661:17;5639:53;:::i;:::-;5708:16;;;;;5593:137;-1:-1:-1;;5593:137:1:o;5735:380::-;5977:66;5965:79;;6069:2;6060:12;;6053:28;;;;6106:2;6097:12;;5955:160::o;6120:392::-;-1:-1:-1;;;6378:27:1;;6430:1;6421:11;;6414:27;;;;6466:2;6457:12;;6450:28;6503:2;6494:12;;6368:144::o;6517:203::-;-1:-1:-1;;;;;6681:32:1;;;;6663:51;;6651:2;6636:18;;6618:102::o;6725:187::-;6890:14;;6883:22;6865:41;;6853:2;6838:18;;6820:92::o;6917:300::-;;7100:6;7093:14;7086:22;7075:9;7068:41;7145:2;7140;7129:9;7125:18;7118:30;7165:46;7207:2;7196:9;7192:18;7184:6;7165:46;:::i;:::-;7157:54;7058:159;-1:-1:-1;;;;7058:159:1:o;7222:177::-;7368:25;;;7356:2;7341:18;;7323:76::o;7404:888::-;7803:25;;;-1:-1:-1;;;;;7902:15:1;;;7897:2;7882:18;;7875:43;7954:15;;;7949:2;7934:18;;7927:43;8006:15;;;;8001:2;7986:18;;7979:43;8053:3;8038:19;;8031:35;;;;7855:3;8082:19;;8075:35;8141:3;8126:19;;8119:35;8185:3;8170:19;;8163:35;;;;8229:3;8214:19;;8207:35;;;;8273:3;8258:19;;8251:35;7790:3;7775:19;;7757:535::o;8297:489::-;8556:25;;;8612:2;8597:18;;8590:34;;;;8655:2;8640:18;;8633:34;;;;-1:-1:-1;;;;;8703:32:1;8698:2;8683:18;;8676:60;8767:3;8752:19;;8745:35;8543:3;8528:19;;8510:276::o;8791:398::-;9018:25;;;9091:4;9079:17;;;;9074:2;9059:18;;9052:45;9128:2;9113:18;;9106:34;9171:2;9156:18;;9149:34;9005:3;8990:19;;8972:217::o;9194:219::-;;9341:2;9330:9;9323:21;9361:46;9403:2;9392:9;9388:18;9380:6;9361:46;:::i;9644:348::-;9846:2;9828:21;;;9885:2;9865:18;;;9858:30;9924:26;9919:2;9904:18;;9897:54;9983:2;9968:18;;9818:174::o;9997:339::-;10199:2;10181:21;;;10238:2;10218:18;;;10211:30;-1:-1:-1;;;10272:2:1;10257:18;;10250:45;10327:2;10312:18;;10171:165::o;10341:355::-;10543:2;10525:21;;;10582:2;10562:18;;;10555:30;10621:33;10616:2;10601:18;;10594:61;10687:2;10672:18;;10515:181::o;10701:398::-;10903:2;10885:21;;;10942:2;10922:18;;;10915:30;10981:34;10976:2;10961:18;;10954:62;-1:-1:-1;;;11047:2:1;11032:18;;11025:32;11089:3;11074:19;;10875:224::o;11104:353::-;11306:2;11288:21;;;11345:2;11325:18;;;11318:30;11384:31;11379:2;11364:18;;11357:59;11448:2;11433:18;;11278:179::o;11462:398::-;11664:2;11646:21;;;11703:2;11683:18;;;11676:30;11742:34;11737:2;11722:18;;11715:62;-1:-1:-1;;;11808:2:1;11793:18;;11786:32;11850:3;11835:19;;11636:224::o;11865:420::-;12067:2;12049:21;;;12106:2;12086:18;;;12079:30;12145:34;12140:2;12125:18;;12118:62;12216:26;12211:2;12196:18;;12189:54;12275:3;12260:19;;12039:246::o;12290:399::-;12492:2;12474:21;;;12531:2;12511:18;;;12504:30;12570:34;12565:2;12550:18;;12543:62;-1:-1:-1;;;12636:2:1;12621:18;;12614:33;12679:3;12664:19;;12464:225::o;12694:342::-;12896:2;12878:21;;;12935:2;12915:18;;;12908:30;-1:-1:-1;;;12969:2:1;12954:18;;12947:48;13027:2;13012:18;;12868:168::o;13223:533::-;;;13366:11;13353:25;13460:2;13456:7;13445:8;13429:14;13425:29;13421:43;13401:18;13397:68;13387:2;;13482:4;13476;13469:18;13387:2;13512:33;;13564:20;;;-1:-1:-1;13607:18:1;13596:30;;13593:2;;;13642:4;13636;13629:18;13593:2;13678:4;13666:17;;-1:-1:-1;13709:14:1;13705:27;;;13695:38;;13692:2;;;13746:1;13743;13736:12;13761:258;13833:1;13843:113;13857:6;13854:1;13851:13;13843:113;;;13933:11;;;13927:18;13914:11;;;13907:39;13879:2;13872:10;13843:113;;;13974:6;13971:1;13968:13;13965:2;;;-1:-1:-1;;14009:1:1;13991:16;;13984:27;13814:205::o

ipfs://4cea60cf0c7f297eee06b0d6d83a2e1372a49d6a314eddc8dfb4112b7c0b9264