Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-03-09
*/

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

// File @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol@v4.5.0
// SPDX-License-Identifier: MIT

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.5.0

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        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/extensions/IERC20Metadata.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File @openzeppelin/contracts/utils/Context.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File @openzeppelin/contracts/token/ERC20/ERC20.sol@v4.5.0

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        address owner = _msgSender();
        _approve(owner, spender, _allowances[owner][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        address owner = _msgSender();
        uint256 currentAllowance = _allowances[owner][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(
            fromBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File @openzeppelin/contracts/utils/Strings.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File @openzeppelin/contracts/utils/cryptography/ECDSA.sol@v4.5.0

// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

/**
 * @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 {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. 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.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature)
        internal
        pure
        returns (address, RecoverError)
    {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @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)
    {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs &
            bytes32(
                0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
            );
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // 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 (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): 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.
        if (
            uint256(s) >
            0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
        ) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * 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)
            );
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked(
                    "\x19Ethereum Signed Message:\n",
                    Strings.toString(s.length),
                    s
                )
            );
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", domainSeparator, structHash)
            );
    }
}

// File @openzeppelin/contracts/utils/cryptography/draft-EIP712.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(
            typeHash,
            hashedName,
            hashedVersion
        );
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (
            address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID
        ) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return
                _buildDomainSeparator(
                    _TYPE_HASH,
                    _HASHED_NAME,
                    _HASHED_VERSION
                );
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    typeHash,
                    nameHash,
                    versionHash,
                    block.chainid,
                    address(this)
                )
            );
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash)
        internal
        view
        virtual
        returns (bytes32)
    {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// File @openzeppelin/contracts/utils/Counters.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File @openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH =
        keccak256(
            "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
        );

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(
            abi.encode(
                _PERMIT_TYPEHASH,
                owner,
                spender,
                value,
                _useNonce(owner),
                deadline
            )
        );

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner)
        internal
        virtual
        returns (uint256 current)
    {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File @openzeppelin/contracts/utils/math/SafeMath.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
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)
    {
        unchecked {
            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)
    {
        unchecked {
            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)
    {
        unchecked {
            // 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)
    {
        unchecked {
            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)
    {
        unchecked {
            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) {
        return a + b;
    }

    /**
     * @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 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) {
        return a * b;
    }

    /**
     * @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.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        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) {
        unchecked {
            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.
     *
     * 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) {
        unchecked {
            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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File @openzeppelin/contracts/utils/Address.sol@v4.5.0

// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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"
        );

        (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");

        (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");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.5.0

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^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 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'
        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) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _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
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// File contracts/Token.sol

pragma solidity 0.8.9;

contract Token is ERC20Permit {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    uint256 public constant MAX_SUPPLY = 3500000 ether;
    uint256 public constant MAX_CLAIM = 2432000 ether;
    uint256 public immutable CLAIM_END;

    uint256 public constant FEES = 200; // 2%;
    uint256 public constant FEES_DENOMINATOR = 10000;

    IERC20 public immutable TOKEN;
    address public immutable BURN_ADDRESS;

    uint256 public totalClaimed;

    event TokensClaimed(address user, uint256 amount);

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor()
        ERC20("Value Network Token", "VNTWIN")
        ERC20Permit("Value Network Token")
    {
        TOKEN = IERC20(0xd0f05D3D4e4d1243Ac826d8c6171180c58eaa9BC);
        CLAIM_END = _getNow().add(864000); // 10*24*60*60 = 864000
        BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

        // 3500000-2432000 = 1068000 (max supply - tokens to claim)
        _mint(_msgSender(), MAX_SUPPLY - MAX_CLAIM);
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     * overrided hence cannot be external
     */
    function transfer(address recipient, uint256 amount)
        public
        override
        returns (bool)
    {
        uint256 toBurn = _toBurn(amount);

        _transfer(_msgSender(), recipient, amount.sub(toBurn));
        _burn(_msgSender(), toBurn);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     * overrided hence cannot be external
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        uint256 toBurn = _toBurn(amount);

        _spendAllowance(sender, _msgSender(), amount);
        _transfer(sender, recipient, amount.sub(toBurn));
        _burn(sender, toBurn);
        return true;
    }

    /**
     * @dev Returns amount to transfer after burning fees.
     * @param amount amount of tokens to transfer
     */
    function _toBurn(uint256 amount) internal pure returns (uint256 toBurn) {
        toBurn = (amount * FEES) / FEES_DENOMINATOR;
    }

    function _getNow() internal view returns (uint256) {
        return block.timestamp;
    }

    /**
     * @dev Allows users to claim new tokens by transferring old tokens to owner's address.
     * @dev In order to transfer the tokens, the old tokens must be approved to the contract.
     * @param amount amount of tokens to exchange
     */
    function claim(uint256 amount) external inClaimPeriod {
        require(amount != 0, "ZERO_AMOUNT");

        totalClaimed = totalClaimed.add(amount);
        require(totalClaimed <= MAX_CLAIM, "TRANSACTION_EXCEEDING_MAX_CAP");

        _mint(_msgSender(), amount);
        TOKEN.safeTransferFrom(_msgSender(), BURN_ADDRESS, amount);
        emit TokensClaimed(_msgSender(), amount);
    }

    modifier inClaimPeriod() {
        require(_getNow() < CLAIM_END, "CLAIM_PERIOD_ENDED");
        _;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensClaimed","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":"BURN_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CLAIM_END","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEES","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FEES_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_CLAIM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"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":"amount","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","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":"value","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":"totalClaimed","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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

62827:3822:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62989:49;;63025:13;62989:49;;;;;160:25:1;;;148:2;133:18;62989:49:0;;;;;;;;9188:100;;;:::i;:::-;;;;;;;:::i;11680:242::-;;;;;;:::i;:::-;;:::i;:::-;;;1449:14:1;;1442:22;1424:41;;1412:2;1397:18;11680:242:0;1284:187:1;10308:108:0;10396:12;;10308:108;;65136:360;;;;;;:::i;:::-;;:::i;10150:93::-;;;10233:2;1951:36:1;;1939:2;1924:18;10150:93:0;1809:184:1;62932:50:0;;62969:13;62932:50;;41633:115;;;:::i;66132:398::-;;;;;;:::i;:::-;;:::i;:::-;;13206:272;;;;;;:::i;:::-;;:::i;63045:34::-;;;;;10479:177;;;;;;:::i;:::-;-1:-1:-1;;;;;10630:18:0;10598:7;10630:18;;;;;;;;;;;;10479:177;41325:178;;;;;;:::i;:::-;;:::i;63193:29::-;;;;;;;;-1:-1:-1;;;;;2734:32:1;;;2716:51;;2704:2;2689:18;63193:29:0;2556:217:1;63088:34:0;;63119:3;63088:34;;9407:104;;;:::i;13981:507::-;;;;;;:::i;:::-;;:::i;64317:294::-;;;;;;:::i;:::-;;:::i;63136:48::-;;63179:5;63136:48;;40473:786;;;;;;:::i;:::-;;:::i;63275:27::-;;;;;;11159:201;;;;;;:::i;:::-;-1:-1:-1;;;;;11325:18:0;;;11293:7;11325:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;11159:201;63229:37;;;;;9188:100;9242:13;9275:5;9268:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9188:100;:::o;11680:242::-;11799:4;6910:10;11860:32;6910:10;11876:7;11885:6;11860:8;:32::i;:::-;-1:-1:-1;11910:4:0;;11680:242;-1:-1:-1;;;11680:242:0:o;65136:360::-;65268:4;65285:14;65302:15;65310:6;65302:7;:15::i;:::-;65285:32;-1:-1:-1;65330:45:0;65346:6;6910:10;65368:6;65330:15;:45::i;:::-;65386:48;65396:6;65404:9;65415:18;:6;65426;65415:10;:18::i;:::-;65386:9;:48::i;:::-;65445:21;65451:6;65459;65445:5;:21::i;:::-;65484:4;65477:11;;;65136:360;;;;;;:::o;41633:115::-;41693:7;41720:20;:18;:20::i;:::-;41713:27;;41633:115;:::o;66132:398::-;66594:9;65844:15;66582:21;66574:52;;;;-1:-1:-1;;;66574:52:0;;4536:2:1;66574:52:0;;;4518:21:1;4575:2;4555:18;;;4548:30;-1:-1:-1;;;4594:18:1;;;4587:48;4652:18;;66574:52:0;;;;;;;;;66205:11;66197:35:::1;;;::::0;-1:-1:-1;;;66197:35:0;;4883:2:1;66197:35:0::1;::::0;::::1;4865:21:1::0;4922:2;4902:18;;;4895:30;-1:-1:-1;;;4941:18:1;;;4934:41;4992:18;;66197:35:0::1;4681:335:1::0;66197:35:0::1;66260:12;::::0;:24:::1;::::0;66277:6;66260:16:::1;:24::i;:::-;66245:12;:39:::0;;;63025:13:::1;-1:-1:-1::0;66303:25:0::1;66295:67;;;::::0;-1:-1:-1;;;66295:67:0;;5223:2:1;66295:67:0::1;::::0;::::1;5205:21:1::0;5262:2;5242:18;;;5235:30;5301:31;5281:18;;;5274:59;5350:18;;66295:67:0::1;5021:353:1::0;66295:67:0::1;66375:27;6910:10:::0;66395:6:::1;66375:5;:27::i;:::-;66413:58;:5;-1:-1:-1::0;;;;;66413:22:0::1;6910:10:::0;66450:12:::1;66464:6:::0;66413:22:::1;:58::i;:::-;66487:35;6910:10:::0;66487:35:::1;::::0;;-1:-1:-1;;;;;5571:32:1;;;5553:51;;5635:2;5620:18;;5613:34;;;5526:18;66487:35:0::1;;;;;;;66132:398:::0;:::o;13206:272::-;6910:10;13321:4;13407:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;13407:27:0;;;;;;;;;;13321:4;;6910:10;13382:66;;6910:10;;13407:27;;:40;;13437:10;;13407:40;:::i;:::-;13382:8;:66::i;41325:178::-;-1:-1:-1;;;;;41471:14:0;;41439:7;41471:14;;;:7;:14;;;;;38491;41471:24;41464:31;41325:178;-1:-1:-1;;41325:178:0:o;9407:104::-;9463:13;9496:7;9489:14;;;;;:::i;13981:507::-;6910:10;14101:4;14189:18;;;:11;:18;;;;;;;;-1:-1:-1;;;;;14189:27:0;;;;;;;;;;14101:4;;6910:10;14249:35;;;;14227:122;;;;-1:-1:-1;;;14227:122:0;;6125:2:1;14227:122:0;;;6107:21:1;6164:2;6144:18;;;6137:30;6203:34;6183:18;;;6176:62;-1:-1:-1;;;6254:18:1;;;6247:35;6299:19;;14227:122:0;5923:401:1;14227:122:0;14385:60;14394:5;14401:7;14429:15;14410:16;:34;14385:8;:60::i;:::-;-1:-1:-1;14476:4:0;;13981:507;-1:-1:-1;;;;13981:507:0:o;64317:294::-;64422:4;64444:14;64461:15;64469:6;64461:7;:15::i;:::-;64444:32;-1:-1:-1;64489:54:0;6910:10;64513:9;64524:18;:6;64535;64524:10;:18::i;64489:54::-;64554:27;6910:10;64574:6;64554:5;:27::i;40473:786::-;40717:8;40698:15;:27;;40690:69;;;;-1:-1:-1;;;40690:69:0;;6531:2:1;40690:69:0;;;6513:21:1;6570:2;6550:18;;;6543:30;6609:31;6589:18;;;6582:59;6658:18;;40690:69:0;6329:353:1;40690:69:0;40772:18;40846:16;40881:5;40905:7;40931:5;40955:16;40965:5;40955:9;:16::i;:::-;40817:196;;;;;;6974:25:1;;;;-1:-1:-1;;;;;7073:15:1;;;7053:18;;;7046:43;7125:15;;;;7105:18;;;7098:43;7157:18;;;7150:34;7200:19;;;7193:35;7244:19;;;7237:35;;;6946:19;;40817:196:0;;;;;;;;;;;;40793:231;;;;;;40772:252;;41037:12;41052:28;41069:10;41052:16;:28::i;:::-;41037:43;;41093:14;41110:28;41124:4;41130:1;41133;41136;41110:13;:28::i;:::-;41093:45;;41167:5;-1:-1:-1;;;;;41157:15:0;:6;-1:-1:-1;;;;;41157:15:0;;41149:58;;;;-1:-1:-1;;;41149:58:0;;7485:2:1;41149:58:0;;;7467:21:1;7524:2;7504:18;;;7497:30;7563:32;7543:18;;;7536:60;7613:18;;41149:58:0;7283:354:1;41149:58:0;41220:31;41229:5;41236:7;41245:5;41220:8;:31::i;:::-;40679:580;;;40473:786;;;;;;;:::o;45158:98::-;45216:7;45243:5;45247:1;45243;:5;:::i;17723:380::-;-1:-1:-1;;;;;17859:19:0;;17851:68;;;;-1:-1:-1;;;17851:68:0;;7844:2:1;17851:68:0;;;7826:21:1;7883:2;7863:18;;;7856:30;7922:34;7902:18;;;7895:62;-1:-1:-1;;;7973:18:1;;;7966:34;8017:19;;17851:68:0;7642:400:1;17851:68:0;-1:-1:-1;;;;;17938:21:0;;17930:68;;;;-1:-1:-1;;;17930:68:0;;8249:2:1;17930:68:0;;;8231:21:1;8288:2;8268:18;;;8261:30;8327:34;8307:18;;;8300:62;-1:-1:-1;;;8378:18:1;;;8371:32;8420:19;;17930:68:0;8047:398:1;17930:68:0;-1:-1:-1;;;;;18011:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18063:32;;160:25:1;;;18063:32:0;;133:18:1;18063:32:0;;;;;;;;17723:380;;;:::o;65633:134::-;65689:14;63179:5;65726:13;63119:3;65726:6;:13;:::i;:::-;65725:34;;;;:::i;18390:502::-;-1:-1:-1;;;;;11325:18:0;;;18525:24;11325:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;18592:37:0;;18588:297;;18692:6;18672:16;:26;;18646:117;;;;-1:-1:-1;;;18646:117:0;;9047:2:1;18646:117:0;;;9029:21:1;9086:2;9066:18;;;9059:30;9125:31;9105:18;;;9098:59;9174:18;;18646:117:0;8845:353:1;18646:117:0;18807:51;18816:5;18823:7;18851:6;18832:16;:25;18807:8;:51::i;:::-;18514:378;18390:502;;;:::o;45539:98::-;45597:7;45624:5;45628:1;45624;:5;:::i;14967:708::-;-1:-1:-1;;;;;15098:18:0;;15090:68;;;;-1:-1:-1;;;15090:68:0;;9535:2:1;15090:68:0;;;9517:21:1;9574:2;9554:18;;;9547:30;9613:34;9593:18;;;9586:62;-1:-1:-1;;;9664:18:1;;;9657:35;9709:19;;15090:68:0;9333:401:1;15090:68:0;-1:-1:-1;;;;;15177:16:0;;15169:64;;;;-1:-1:-1;;;15169:64:0;;9941:2:1;15169:64:0;;;9923:21:1;9980:2;9960:18;;;9953:30;10019:34;9999:18;;;9992:62;-1:-1:-1;;;10070:18:1;;;10063:33;10113:19;;15169:64:0;9739:399:1;15169:64:0;-1:-1:-1;;;;;15319:15:0;;15297:19;15319:15;;;;;;;;;;;15367:21;;;;15345:109;;;;-1:-1:-1;;;15345:109:0;;10345:2:1;15345:109:0;;;10327:21:1;10384:2;10364:18;;;10357:30;10423:34;10403:18;;;10396:62;-1:-1:-1;;;10474:18:1;;;10467:36;10520:19;;15345:109:0;10143:402:1;15345:109:0;-1:-1:-1;;;;;15490:15:0;;;:9;:15;;;;;;;;;;;15508:20;;;15490:38;;15550:13;;;;;;;;:23;;15522:6;;15490:9;15550:23;;15522:6;;15550:23;:::i;:::-;;;;;;;;15606:2;-1:-1:-1;;;;;15591:26:0;15600:4;-1:-1:-1;;;;;15591:26:0;;15610:6;15591:26;;;;160:25:1;;148:2;133:18;;14:177;15591:26:0;;;;;;;;15630:37;16694:591;;-1:-1:-1;;;;;16778:21:0;;16770:67;;;;-1:-1:-1;;;16770:67:0;;10752:2:1;16770:67:0;;;10734:21:1;10791:2;10771:18;;;10764:30;10830:34;10810:18;;;10803:62;-1:-1:-1;;;10881:18:1;;;10874:31;10922:19;;16770:67:0;10550:397:1;16770:67:0;-1:-1:-1;;;;;16937:18:0;;16912:22;16937:18;;;;;;;;;;;16974:24;;;;16966:71;;;;-1:-1:-1;;;16966:71:0;;11154:2:1;16966:71:0;;;11136:21:1;11193:2;11173:18;;;11166:30;11232:34;11212:18;;;11205:62;-1:-1:-1;;;11283:18:1;;;11276:32;11325:19;;16966:71:0;10952:398:1;16966:71:0;-1:-1:-1;;;;;17073:18:0;;:9;:18;;;;;;;;;;17094:23;;;17073:44;;17139:12;:22;;17111:6;;17073:9;17139:22;;17111:6;;17139:22;:::i;:::-;;;;-1:-1:-1;;17179:37:0;;160:25:1;;;17205:1:0;;-1:-1:-1;;;;;17179:37:0;;;;;148:2:1;133:18;17179:37:0;14:177:1;17229:48:0;16759:526;16694:591;;:::o;35789:437::-;35842:7;35888:4;-1:-1:-1;;;;;35897:12:0;35880:29;;:66;;;;;35930:16;35913:13;:33;35880:66;35862:357;;;-1:-1:-1;35980:24:0;;35789:437::o;35862:357::-;-1:-1:-1;36446:197:0;;;36105:10;36446:197;;;;12354:25:1;;;;36138:12:0;12395:18:1;;;12388:34;36173:15:0;12438:18:1;;;12431:34;36575:13:0;12481:18:1;;;12474:34;36619:4:0;12524:19:1;;;;12517:61;;;;36446:197:0;;;;;;;;;;12326:19:1;;;;36446:197:0;;;36418:240;;;;;;41633:115::o;15962:399::-;-1:-1:-1;;;;;16046:21:0;;16038:65;;;;-1:-1:-1;;;16038:65:0;;11557:2:1;16038:65:0;;;11539:21:1;11596:2;11576:18;;;11569:30;11635:33;11615:18;;;11608:61;11686:18;;16038:65:0;11355:355:1;16038:65:0;16194:6;16178:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;16211:18:0;;:9;:18;;;;;;;;;;:28;;16233:6;;16211:9;:28;;16233:6;;16211:28;:::i;:::-;;;;-1:-1:-1;;16255:37:0;;160:25:1;;;-1:-1:-1;;;;;16255:37:0;;;16272:1;;16255:37;;148:2:1;133:18;16255:37:0;;;;;;;15962:399;;:::o;59250:285::-;59448:68;;;-1:-1:-1;;;;;11973:15:1;;;59448:68:0;;;11955:34:1;12025:15;;12005:18;;;11998:43;12057:18;;;;12050:34;;;59448:68:0;;;;;;;;;;11890:18:1;;;;59448:68:0;;;;;;;;-1:-1:-1;;;;;59448:68:0;-1:-1:-1;;;59448:68:0;;;59394:133;;59428:5;;59394:19;:133::i;41886:239::-;-1:-1:-1;;;;;42039:14:0;;41973:15;42039:14;;;:7;:14;;;;;38491;;38628:1;38610:19;;;;38491:14;42100:17;41995:130;41886:239;;;:::o;37308:208::-;37421:7;37453:55;37475:20;:18;:20::i;:::-;37497:10;32420:57;;-1:-1:-1;;;32420:57:0;;;13540:27:1;13583:11;;;13576:27;;;13619:12;;;13612:28;;;32347:7:0;;13656:12:1;;32420:57:0;;;;;;;;;;;;32392:100;;;;;;32372:120;;32227:273;;;;;30300:279;30428:7;30449:17;30468:18;30490:25;30501:4;30507:1;30510;30513;30490:10;:25::i;:::-;30448:67;;;;30526:18;30538:5;30526:11;:18::i;:::-;-1:-1:-1;30562:9:0;30300:279;-1:-1:-1;;;;;30300:279:0:o;61961:802::-;62385:23;62411:106;62453:4;62411:106;;;;;;;;;;;;;;;;;62419:5;-1:-1:-1;;;;;62411:27:0;;;:106;;;;;:::i;:::-;62532:17;;62385:132;;-1:-1:-1;62532:21:0;62528:228;;62647:10;62636:30;;;;;;;;;;;;:::i;:::-;62610:134;;;;-1:-1:-1;;;62610:134:0;;13073:2:1;62610:134:0;;;13055:21:1;13112:2;13092:18;;;13085:30;13151:34;13131:18;;;13124:62;-1:-1:-1;;;13202:18:1;;;13195:40;13252:19;;62610:134:0;12871:406:1;28492:1669:0;28623:7;;29584:66;29558:92;;29540:200;;;-1:-1:-1;29693:1:0;;-1:-1:-1;29697:30:0;29677:51;;29540:200;29754:1;:7;;29759:2;29754:7;;:18;;;;;29765:1;:7;;29770:2;29765:7;;29754:18;29750:102;;;-1:-1:-1;29805:1:0;;-1:-1:-1;29809:30:0;29789:51;;29750:102;29966:24;;;29949:14;29966:24;;;;;;;;;13906:25:1;;;13979:4;13967:17;;13947:18;;;13940:45;;;;14001:18;;;13994:34;;;14044:18;;;14037:34;;;29966:24:0;;13878:19:1;;29966:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;29966:24:0;;-1:-1:-1;;29966:24:0;;;-1:-1:-1;;;;;;;30005:20:0;;30001:103;;30058:1;30062:29;30042:50;;;;;;;30001:103;30124:6;-1:-1:-1;30132:20:0;;-1:-1:-1;28492:1669:0;;;;;;;;:::o;23092:643::-;23170:20;23161:5;:29;;;;;;;;:::i;:::-;;23157:571;;;23092:643;:::o;23157:571::-;23268:29;23259:5;:38;;;;;;;;:::i;:::-;;23255:473;;;23314:34;;-1:-1:-1;;;23314:34:0;;14416:2:1;23314:34:0;;;14398:21:1;14455:2;14435:18;;;14428:30;14494:26;14474:18;;;14467:54;14538:18;;23314:34:0;14214:348:1;23255:473:0;23379:35;23370:5;:44;;;;;;;;:::i;:::-;;23366:362;;;23431:41;;-1:-1:-1;;;23431:41:0;;14769:2:1;23431:41:0;;;14751:21:1;14808:2;14788:18;;;14781:30;14847:33;14827:18;;;14820:61;14898:18;;23431:41:0;14567:355:1;23366:362:0;23503:30;23494:5;:39;;;;;;;;:::i;:::-;;23490:238;;;23550:44;;-1:-1:-1;;;23550:44:0;;15129:2:1;23550:44:0;;;15111:21:1;15168:2;15148:18;;;15141:30;15207:34;15187:18;;;15180:62;-1:-1:-1;;;15258:18:1;;;15251:32;15300:19;;23550:44:0;14927:398:1;23490:238:0;23625:30;23616:5;:39;;;;;;;;:::i;:::-;;23612:116;;;23672:44;;-1:-1:-1;;;23672:44:0;;15532:2:1;23672:44:0;;;15514:21:1;15571:2;15551:18;;;15544:30;15610:34;15590:18;;;15583:62;-1:-1:-1;;;15661:18:1;;;15654:32;15703:19;;23672:44:0;15330:398:1;23612:116:0;23092:643;:::o;53402:229::-;53539:12;53571:52;53593:6;53601:4;53607:1;53610:12;53571:21;:52::i;:::-;53564:59;53402:229;-1:-1:-1;;;;53402:229:0:o;54618:571::-;54788:12;54860:5;54835:21;:30;;54813:118;;;;-1:-1:-1;;;54813:118:0;;15935:2:1;54813:118:0;;;15917:21:1;15974:2;15954:18;;;15947:30;16013:34;15993:18;;;15986:62;-1:-1:-1;;;16064:18:1;;;16057:36;16110:19;;54813:118:0;15733:402:1;54813:118:0;-1:-1:-1;;;;;50855:19:0;;;54942:60;;;;-1:-1:-1;;;54942:60:0;;16342:2:1;54942:60:0;;;16324:21:1;16381:2;16361:18;;;16354:30;16420:31;16400:18;;;16393:59;16469:18;;54942:60:0;16140:353:1;54942:60:0;55016:12;55030:23;55057:6;-1:-1:-1;;;;;55057:11:0;55076:5;55097:4;55057:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55015:97;;;;55130:51;55147:7;55156:10;55168:12;55130:16;:51::i;:::-;55123:58;54618:571;-1:-1:-1;;;;;;;54618:571:0:o;57578:712::-;57728:12;57757:7;57753:530;;;-1:-1:-1;57788:10:0;57781:17;;57753:530;57902:17;;:21;57898:374;;58100:10;58094:17;58161:15;58148:10;58144:2;58140:19;58133:44;57898:374;58243:12;58236:20;;-1:-1:-1;;;58236:20:0;;;;;;;;:::i;196:258:1:-;268:1;278:113;292:6;289:1;286:13;278:113;;;368:11;;;362:18;349:11;;;342:39;314:2;307:10;278:113;;;409:6;406:1;403:13;400:48;;;-1:-1:-1;;444:1:1;426:16;;419:27;196:258::o;459:383::-;608:2;597:9;590:21;571:4;640:6;634:13;683:6;678:2;667:9;663:18;656:34;699:66;758:6;753:2;742:9;738:18;733:2;725:6;721:15;699:66;:::i;:::-;826:2;805:15;-1:-1:-1;;801:29:1;786:45;;;;833:2;782:54;;459:383;-1:-1:-1;;459:383:1:o;847:173::-;915:20;;-1:-1:-1;;;;;964:31:1;;954:42;;944:70;;1010:1;1007;1000:12;944:70;847:173;;;:::o;1025:254::-;1093:6;1101;1154:2;1142:9;1133:7;1129:23;1125:32;1122:52;;;1170:1;1167;1160:12;1122:52;1193:29;1212:9;1193:29;:::i;:::-;1183:39;1269:2;1254:18;;;;1241:32;;-1:-1:-1;;;1025:254:1:o;1476:328::-;1553:6;1561;1569;1622:2;1610:9;1601:7;1597:23;1593:32;1590:52;;;1638:1;1635;1628:12;1590:52;1661:29;1680:9;1661:29;:::i;:::-;1651:39;;1709:38;1743:2;1732:9;1728:18;1709:38;:::i;:::-;1699:48;;1794:2;1783:9;1779:18;1766:32;1756:42;;1476:328;;;;;:::o;2180:180::-;2239:6;2292:2;2280:9;2271:7;2267:23;2263:32;2260:52;;;2308:1;2305;2298:12;2260:52;-1:-1:-1;2331:23:1;;2180:180;-1:-1:-1;2180:180:1:o;2365:186::-;2424:6;2477:2;2465:9;2456:7;2452:23;2448:32;2445:52;;;2493:1;2490;2483:12;2445:52;2516:29;2535:9;2516:29;:::i;2778:693::-;2889:6;2897;2905;2913;2921;2929;2937;2990:3;2978:9;2969:7;2965:23;2961:33;2958:53;;;3007:1;3004;2997:12;2958:53;3030:29;3049:9;3030:29;:::i;:::-;3020:39;;3078:38;3112:2;3101:9;3097:18;3078:38;:::i;:::-;3068:48;;3163:2;3152:9;3148:18;3135:32;3125:42;;3214:2;3203:9;3199:18;3186:32;3176:42;;3268:3;3257:9;3253:19;3240:33;3313:4;3306:5;3302:16;3295:5;3292:27;3282:55;;3333:1;3330;3323:12;3282:55;2778:693;;;;-1:-1:-1;2778:693:1;;;;3356:5;3408:3;3393:19;;3380:33;;-1:-1:-1;3460:3:1;3445:19;;;3432:33;;2778:693;-1:-1:-1;;2778:693:1:o;3476:260::-;3544:6;3552;3605:2;3593:9;3584:7;3580:23;3576:32;3573:52;;;3621:1;3618;3611:12;3573:52;3644:29;3663:9;3644:29;:::i;:::-;3634:39;;3692:38;3726:2;3715:9;3711:18;3692:38;:::i;:::-;3682:48;;3476:260;;;;;:::o;3949:380::-;4028:1;4024:12;;;;4071;;;4092:61;;4146:4;4138:6;4134:17;4124:27;;4092:61;4199:2;4191:6;4188:14;4168:18;4165:38;4162:161;;;4245:10;4240:3;4236:20;4233:1;4226:31;4280:4;4277:1;4270:15;4308:4;4305:1;4298:15;5658:127;5719:10;5714:3;5710:20;5707:1;5700:31;5750:4;5747:1;5740:15;5774:4;5771:1;5764:15;5790:128;5830:3;5861:1;5857:6;5854:1;5851:13;5848:39;;;5867:18;;:::i;:::-;-1:-1:-1;5903:9:1;;5790:128::o;8450:168::-;8490:7;8556:1;8552;8548:6;8544:14;8541:1;8538:21;8533:1;8526:9;8519:17;8515:45;8512:71;;;8563:18;;:::i;:::-;-1:-1:-1;8603:9:1;;8450:168::o;8623:217::-;8663:1;8689;8679:132;;8733:10;8728:3;8724:20;8721:1;8714:31;8768:4;8765:1;8758:15;8796:4;8793:1;8786:15;8679:132;-1:-1:-1;8825:9:1;;8623:217::o;9203:125::-;9243:4;9271:1;9268;9265:8;9262:34;;;9276:18;;:::i;:::-;-1:-1:-1;9313:9:1;;9203:125::o;12589:277::-;12656:6;12709:2;12697:9;12688:7;12684:23;12680:32;12677:52;;;12725:1;12722;12715:12;12677:52;12757:9;12751:16;12810:5;12803:13;12796:21;12789:5;12786:32;12776:60;;12832:1;12829;12822:12;14082:127;14143:10;14138:3;14134:20;14131:1;14124:31;14174:4;14171:1;14164:15;14198:4;14195:1;14188:15;16498:274;16627:3;16665:6;16659:13;16681:53;16727:6;16722:3;16715:4;16707:6;16703:17;16681:53;:::i;:::-;16750:16;;;;;16498:274;-1:-1:-1;;16498:274:1:o

ipfs://25e75aac0914646171427c45f95900e515670e260f9729ed4cf2fea95cad8cb9