Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ... 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 IReduxToken    - function freeUpTo(uint256 value)    - function freeFromUpTo(address from, u ...    - function mint(uint256 value)  contract ReduxToken is IERC20, IRe ... *    - function totalSupply()    - function mint(uint256 value)    - function free(uint256 value)    - function freeUpTo(uint256 value)    - function freeFromUpTo(address from, u ...    - function freeFrom(address from, uint2 ...    - function allowance(address owner, add ...    - function transfer(address recipient, ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function permit(    - function balanceOf(address account)    - function _transfer(address sender, ad ...    - function _approve(address owner, addr ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _burnFrom(address account, u ...    - function computeAddress2(uint256 salt ...    - function _destroyChildren(uint256 val ...    - function getChainId()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-04-02
*/

// File: openzeppelin-solidity/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-solidity/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: original_contracts/IReduxToken.sol

pragma solidity 0.7.5;

interface IReduxToken {

    function freeUpTo(uint256 value) external returns (uint256 freed);

    function freeFromUpTo(address from, uint256 value) external returns (uint256 freed);

    function mint(uint256 value) external;
}

// File: original_contracts/lib/ReduxToken.sol

pragma solidity 0.7.5;





contract ReduxToken is IERC20, IReduxToken {
    using SafeMath for uint256;

    string constant public name = "REDUX";
    string constant public symbol = "REDUX";
    uint8 constant public decimals = 0;

    mapping(address => uint256) private s_balances;
    mapping(address => mapping(address => uint256)) private s_allowances;

    uint256 public totalReduxMinted;
    uint256 public totalReduxBurned;

    //The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    //The EIP-712 typehash for the permit struct used by the contract
    bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    //A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    function totalSupply() external view override returns(uint256) {
        return totalReduxMinted.sub(totalReduxBurned);
    }

    function mint(uint256 value) external override {
        uint256 offset = totalReduxMinted;

        assembly {

            // EVM assembler of runtime portion of child contract:
            //     ;; Pseudocode: if (msg.sender != 0x000000000000cb2d80a37898be43579c7b616844) { throw; }
            //     ;;             suicide(msg.sender)
            //     PUSH14 0xcb2d80a37898be43579c7b616856 ;; hardcoded address of this contract
            //     CALLER
            //     XOR
            //     JUMP
            //     JUMPDEST
            //     CALLER
            //     SELFDESTRUCT
            // Or in binary: 6dcb2d80a37898be43579c7b6168563318565b33ff
            // Since the binary is so short (21 bytes), we can get away
            // with a very simple initcode:
            //     PUSH21 0x6dcb2d80a37898be43579c7b6168573318565b33ff
            //     PUSH1 0
            //     MSTORE ;; at this point, memory locations mem[10] through
            //            ;; mem[30] contain the runtime portion of the child
            //            ;; contract. all that's left to do is to RETURN this
            //            ;; chunk of memory.
            //     PUSH1 21 ;; length
            //     PUSH1 11 ;; offset
            //     RETURN
            // Or in binary: 746dcb2d80a37898be43579c7b6168563318565b33ff6000526015600bf30000
            // Almost done! All we have to do is put this short (30 bytes) blob into
            // memory and call CREATE with the appropriate offsets.

            let end := add(offset, value)
            mstore(callvalue(), 0x746dcb2d80a37898be43579c7b6168563318565b33ff6000526015600bf30000)

            for {let i := div(value, 32)} i {i := sub(i, 1)} {
                pop(create2(callvalue(), callvalue(), 30, add(offset, 0))) pop(create2(callvalue(), callvalue(), 30, add(offset, 1)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 2))) pop(create2(callvalue(), callvalue(), 30, add(offset, 3)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 4))) pop(create2(callvalue(), callvalue(), 30, add(offset, 5)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 6))) pop(create2(callvalue(), callvalue(), 30, add(offset, 7)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 8))) pop(create2(callvalue(), callvalue(), 30, add(offset, 9)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 10))) pop(create2(callvalue(), callvalue(), 30, add(offset, 11)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 12))) pop(create2(callvalue(), callvalue(), 30, add(offset, 13)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 14))) pop(create2(callvalue(), callvalue(), 30, add(offset, 15)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 16))) pop(create2(callvalue(), callvalue(), 30, add(offset, 17)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 18))) pop(create2(callvalue(), callvalue(), 30, add(offset, 19)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 20))) pop(create2(callvalue(), callvalue(), 30, add(offset, 21)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 22))) pop(create2(callvalue(), callvalue(), 30, add(offset, 23)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 24))) pop(create2(callvalue(), callvalue(), 30, add(offset, 25)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 26))) pop(create2(callvalue(), callvalue(), 30, add(offset, 27)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 28))) pop(create2(callvalue(), callvalue(), 30, add(offset, 29)))
                pop(create2(callvalue(), callvalue(), 30, add(offset, 30))) pop(create2(callvalue(), callvalue(), 30, add(offset, 31)))
                offset := add(offset, 32)
            }

            for { } lt(offset, end) { offset := add(offset, 1) } {
                pop(create2(callvalue(), callvalue(), 30, offset))
            }
        }

        _mint(msg.sender, value);
        totalReduxMinted = offset;
    }

    function free(uint256 value) external {
        _burn(msg.sender, value);
        _destroyChildren(value);
    }

    function freeUpTo(uint256 value) external override returns (uint256) {
        uint256 fromBalance = s_balances[msg.sender];
        if (value > fromBalance) {
            value = fromBalance;
        }
        _burn(msg.sender, value);
        _destroyChildren(value);

        return value;
    }

    function freeFromUpTo(address from, uint256 value) external override returns (uint256) {
        uint256 fromBalance = s_balances[from];
        if (value > fromBalance) {
            value = fromBalance;
        }

        uint256 userAllowance = s_allowances[from][msg.sender];
        if (value > userAllowance) {
            value = userAllowance;
        }
        _burnFrom(from, value);
        _destroyChildren(value);

        return value;
    }

    function freeFrom(address from, uint256 value) external {
        _burnFrom(from, value);
        _destroyChildren(value);
    }

    function allowance(address owner, address spender) external view override returns (uint256) {
        return s_allowances[owner][spender];
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, s_allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @notice Triggers an approval from owner to spends
     * @param owner The address to approve from
     * @param spender The address to be approved
     * @param amount The number of tokens that are approved
     * @param deadline The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {

        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, nonces[owner]++, deadline));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "permit: invalid signature");
        require(signatory == owner, "permit: unauthorized");
        require(block.timestamp <= deadline, "permit: signature expired");

        _approve(owner, spender, amount);
    }

    function balanceOf(address account) public view override returns (uint256) {
        return s_balances[account];
    }

    function _transfer(address sender, address recipient, uint256 amount) private {
        s_balances[sender] = s_balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        s_balances[recipient] = s_balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _approve(address owner, address spender, uint256 amount) private {
        s_allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _mint(address account, uint256 amount) private {
        s_balances[account] = s_balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) private {
        s_balances[account] = s_balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        emit Transfer(account, address(0), amount);
    }

    function _burnFrom(address account, uint256 amount) private {
        _burn(account, amount);
        _approve(account, msg.sender, s_allowances[account][msg.sender].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    function computeAddress2(uint256 salt) public pure returns (address child) {
        assembly {
            let data := mload(0x40)
            mstore(data, 0xff000000000000cb2d80a37898be43579c7b6168440000000000000000000000)
            mstore(add(data, 21), salt)
            mstore(add(data, 53), 0xe4135d085e66541f164ddfd4dd9d622a50176c98e7bcdbbc6634d80cd31e9421)
            child := and(keccak256(data, 85), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        }
    }

    function _destroyChildren(uint256 value) internal {
        assembly {
            let i := sload(totalReduxBurned.slot)
            let end := add(i, value)
            sstore(totalReduxBurned.slot, end)

            let data := mload(0x40)
            mstore(data, 0xff000000000000cb2d80a37898be43579c7b6168440000000000000000000000)
            mstore(add(data, 53), 0xe4135d085e66541f164ddfd4dd9d622a50176c98e7bcdbbc6634d80cd31e9421)
            let ptr := add(data, 21)
            for { } lt(i, end) { i := add(i, 1) } {
                mstore(ptr, i)
                pop(call(gas(), keccak256(data, 85), callvalue(), callvalue(), callvalue(), callvalue(), callvalue()))
            }
        }
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"salt","type":"uint256"}],"name":"computeAddress2","outputs":[{"internalType":"address","name":"child","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"free","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"freeFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"freeFromUpTo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"freeUpTo","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReduxBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReduxMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

8619:11174:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8967:31;;;:::i;:::-;;;;;;;;;;;;;;;;8704:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14372:469;;;;;;;;;;;;;;;;-1:-1:-1;14372:469:0;;;;;;;;;:::i;15317:161::-;;;;;;;;;;;;;;;;-1:-1:-1;15317:161:0;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;9557:127;;;:::i;9099:122::-;;;:::i;15486:312::-;;;;;;;;;;;;;;;;-1:-1:-1;15486:312:0;;;;;;;;;;;;;;;;;;:::i;9301:137::-;;;:::i;8794:34::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14849:131;;;;;;;;;;;;;;;;-1:-1:-1;14849:131:0;;;;;;;;;:::i;:::-;;14057:307;;;;;;;;;;;;;;;;-1:-1:-1;14057:307:0;;:::i;17138:120::-;;;;;;;;;;;;;;;;-1:-1:-1;17138:120:0;;;;:::i;9509:39::-;;;;;;;;;;;;;;;;-1:-1:-1;9509:39:0;;;;:::i;9005:31::-;;;:::i;9692:4234::-;;;;;;;;;;;;;;;;-1:-1:-1;9692:4234:0;;:::i;15142:167::-;;;;;;;;;;;;;;;;-1:-1:-1;15142:167:0;;;;;;;;;:::i;18421:480::-;;;;;;;;;;;;;;;;-1:-1:-1;18421:480:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;16260:870;;;;;;;;;;;;;;;;-1:-1:-1;16260:870:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;13934:115::-;;;;;;;;;;;;;;;;-1:-1:-1;13934:115:0;;:::i;14988:146::-;;;;;;;;;;;;;;;;-1:-1:-1;14988:146:0;;;;;;;;;;;:::i;8967:31::-;;;;:::o;8704:37::-;;;;;;;;;;;;;;;;;;;:::o;14372:469::-;14492:16;;;14450:7;14492:16;;;;;;;;;;;14523:19;;;14519:71;;;14567:11;14559:19;;14519:71;14626:18;;;14602:21;14626:18;;;:12;:18;;;;;;;;14645:10;14626:30;;;;;;;;14671:21;;;14667:75;;;14717:13;14709:21;;14667:75;14752:22;14762:4;14768:5;14752:9;:22::i;:::-;14785:23;14802:5;14785:16;:23::i;:::-;-1:-1:-1;14828:5:0;;14372:469;-1:-1:-1;;;14372:469:0:o;15317:161::-;15394:4;15411:37;15420:10;15432:7;15441:6;15411:8;:37::i;:::-;-1:-1:-1;15466:4:0;15317:161;;;;:::o;9557:127::-;9611:7;9638:38;9659:16;;9638;;:20;;:38;;;;:::i;:::-;9631:45;;9557:127;:::o;9099:122::-;9141:80;9099:122;:::o;15486:312::-;15586:4;15603:36;15613:6;15621:9;15632:6;15603:9;:36::i;:::-;15650:118;15659:6;15667:10;15679:88;15716:6;15679:88;;;;;;;;;;;;;;;;;:20;;;;;;;:12;:20;;;;;;;;15700:10;15679:32;;;;;;;;;:88;:36;:88::i;:::-;15650:8;:118::i;:::-;-1:-1:-1;15786:4:0;15486:312;;;;;:::o;9301:137::-;9343:95;9301:137;:::o;8794:34::-;8827:1;8794:34;:::o;14849:131::-;14916:22;14926:4;14932:5;14916:9;:22::i;:::-;14949:23;14966:5;14949:16;:23::i;:::-;14849:131;;:::o;14057:307::-;14170:10;14117:7;14159:22;;;;;;;;;;;14196:19;;;14192:71;;;14240:11;14232:19;;14192:71;14273:24;14279:10;14291:5;14273;:24::i;:::-;14308:23;14325:5;14308:16;:23::i;:::-;-1:-1:-1;14351:5:0;;14057:307;-1:-1:-1;14057:307:0:o;17138:120::-;17231:19;;17204:7;17231:19;;;;;;;;;;;;17138:120::o;9509:39::-;;;;;;;;;;;;;:::o;9005:31::-;;;;:::o;9692:4234::-;9767:16;;11309:66;11296:11;11289:87;11257:18;;;11417:2;11406:14;;11392:2290;11422:1;11392:2290;;;11506:6;11498:2;11485:11;;11464:53;11460:58;11573:1;11565:6;11561:14;11557:2;11544:11;11531;11523:53;11519:58;11649:1;11641:6;11637:14;11633:2;11620:11;11607;11599:53;11595:58;11708:1;11700:6;11696:14;11692:2;11679:11;11666;11658:53;11654:58;11784:1;11776:6;11772:14;11768:2;11755:11;11742;11734:53;11730:58;11843:1;11835:6;11831:14;11827:2;11814:11;11801;11793:53;11789:58;11919:1;11911:6;11907:14;11903:2;11890:11;11877;11869:53;11865:58;11978:1;11970:6;11966:14;11962:2;11949:11;11936;11928:53;11924:58;12054:1;12046:6;12042:14;12038:2;12025:11;12012;12004:53;12000:58;12113:1;12105:6;12101:14;12097:2;12084:11;12071;12063:53;12059:58;12189:2;12181:6;12177:15;12173:2;12160:11;12147;12139:54;12135:59;12249:2;12241:6;12237:15;12233:2;12220:11;12207;12199:54;12195:59;12326:2;12318:6;12314:15;12310:2;12297:11;12284;12276:54;12272:59;12386:2;12378:6;12374:15;12370:2;12357:11;12344;12336:54;12332:59;12463:2;12455:6;12451:15;12447:2;12434:11;12421;12413:54;12409:59;12523:2;12515:6;12511:15;12507:2;12494:11;12481;12473:54;12469:59;12600:2;12592:6;12588:15;12584:2;12571:11;12558;12550:54;12546:59;12660:2;12652:6;12648:15;12644:2;12631:11;12618;12610:54;12606:59;12737:2;12729:6;12725:15;12721:2;12708:11;12695;12687:54;12683:59;12797:2;12789:6;12785:15;12781:2;12768:11;12755;12747:54;12743:59;12874:2;12866:6;12862:15;12858:2;12845:11;12832;12824:54;12820:59;12934:2;12926:6;12922:15;12918:2;12905:11;12892;12884:54;12880:59;13011:2;13003:6;12999:15;12995:2;12982:11;12969;12961:54;12957:59;13071:2;13063:6;13059:15;13055:2;13042:11;13029;13021:54;13017:59;13148:2;13140:6;13136:15;13132:2;13119:11;13106;13098:54;13094:59;13208:2;13200:6;13196:15;13192:2;13179:11;13166;13158:54;13154:59;13285:2;13277:6;13273:15;13269:2;13256:11;13243;13235:54;13231:59;13345:2;13337:6;13333:15;13329:2;13316:11;13303;13295:54;13291:59;13422:2;13414:6;13410:15;13406:2;13393:11;13380;13372:54;13368:59;13482:2;13474:6;13470:15;13466:2;13453:11;13440;13432:54;13428:59;13559:2;13551:6;13547:15;13543:2;13530:11;13517;13509:54;13505:59;13619:2;13611:6;13607:15;13603:2;13590:11;13577;13569:54;-1:-1:-1;13664:2:0;13652:15;;;;;11430:9;;11392:2290;;;11396:25;13698:137;13717:3;13709:6;13706:15;13698:137;;;13812:6;13808:2;13795:11;13782;13774:45;13770:50;13746:1;13738:6;13734:14;13724:24;;13698:137;;;13702:3;13858:24;13864:10;13876:5;13858;:24::i;:::-;13893:16;:25;-1:-1:-1;9692:4234:0:o;15142:167::-;15222:4;15239:40;15249:10;15261:9;15272:6;15239:9;:40::i;18421:480::-;18549:4;18543:11;18581:66;18568:80;;18679:2;18669:13;;18662:27;;;;18725:66;18720:2;18710:13;;18703:89;18835:2;18819:19;;18840:42;18815:68;;18516:378::o;16260:870::-;16556:4;;;;;;;;;;;;;;;;;;16476:23;9141:80;16540:22;16564:12;:10;:12::i;:::-;16512:80;;;;;;;;;;;;;;;;;;;;;;;;;16586:4;16512:80;;;;;;;;;;;;;;;;;;;;;;;16502:91;;;;;;16512:80;16687:13;;;-1:-1:-1;16687:13:0;;;:6;:13;;;;;:15;;;;;;;;;9343:95;16635:78;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16625:89;;;;;;16752:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16742:68;;;;;;;;;16841:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16502:91;;-1:-1:-1;16625:89:0;16742:68;;-1:-1:-1;;16687:15:0;;16841:26;;;;;16512:80;-1:-1:-1;16841:26:0;;;;;;;;;;;16687:15;16841:26;;;;;;;;;;;;;;;-1:-1:-1;;16841:26:0;;;;;;-1:-1:-1;;16886:23:0;;;16878:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16971:5;16958:18;;:9;:18;;;16950:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17039:8;17020:15;:27;;17012:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17090:32;17099:5;17106:7;17115:6;17090:8;:32::i;:::-;16260:870;;;;;;;;;;;:::o;13934:115::-;13983:24;13989:10;14001:5;13983;:24::i;:::-;14018:23;14035:5;14018:16;:23::i;:::-;13934:115;:::o;14988:146::-;15098:19;;;;15071:7;15098:19;;;:12;:19;;;;;;;;:28;;;;;;;;;;;;;14988:146::o;18185:228::-;18256:22;18262:7;18271:6;18256:5;:22::i;:::-;18289:116;18298:7;18307:10;18319:85;18357:6;18319:85;;;;;;;;;;;;;;;;;:21;;;;;;;:12;:21;;;;;;;;18341:10;18319:33;;;;;;;;;:85;:37;:85::i;18909:720::-;19009:21;19003:28;19063:5;19060:1;19056:13;19113:3;19090:21;19083:34;19151:4;19145:11;19183:66;19177:4;19170:80;19286:66;19281:2;19275:4;19271:13;19264:89;19388:2;19382:4;19378:13;19405:206;19419:3;19416:1;19413:10;19405:206;;;19474:1;19469:3;19462:14;19583:11;19570;19557;19544;19531;19526:2;19520:4;19510:19;19503:5;19498:97;19494:102;19438:1;19435;19431:9;19426:14;;19405:206;;;19409:3;;;;18979:643;:::o;17583:178::-;17668:19;;;;;;;;:12;:19;;;;;;;;:28;;;;;;;;;;;;;:37;;;17721:32;;;;;;;;;;;;;;;;;17583:178;;;:::o;4224:136::-;4282:7;4309:43;4313:1;4316;4309:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4302:50;4224:136;-1:-1:-1;;;4224:136:0:o;17266:309::-;17376:72;17399:6;17376:72;;;;;;;;;;;;;;;;;:18;;;:10;:18;;;;;;;;;;;;:72;:22;:72::i;:::-;17355:18;;;;:10;:18;;;;;;;;;;;:93;;;;17483:21;;;;;;;:33;;17509:6;17483:25;:33::i;:::-;17459:21;;;;:10;:21;;;;;;;;;;;;:57;;;;17532:35;;;;;;;17459:21;;17532:35;;;;;;;;;;;;;17266:309;;;:::o;4663:192::-;4749:7;4785:12;4777:6;;;;4769:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4821:5:0;;;4663:192::o;17958:219::-;18047:69;18071:6;18047:69;;;;;;;;;;;;;;;;;:19;;;:10;:19;;;;;;;;;;;;:69;:23;:69::i;:::-;18025:19;;;:10;:19;;;;;;;;;;;:91;;;;18132:37;;;;;;;18025:10;;18132:37;;;;;;;;;;;17958:219;;:::o;17769:181::-;17858:19;;;:10;:19;;;;;;;;;;;:31;;17882:6;17858:23;:31::i;:::-;17836:19;;;:10;:19;;;;;;;;;;;:53;;;;17905:37;;;;;;;17836:19;;:10;;17905:37;;;;;;;;;;17769:181;;:::o;19637:153::-;19747:9;19637:153;:::o;3760:181::-;3818:7;3850:5;;;3874:6;;;;3866:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://e40a3e267f67c15228b18ecc63b035c73fa0b6a563f396ef30b40fcc178554c3