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 2023-09-14
*/

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

// 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

// 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

// OpenZeppelin Contracts (last updated v4.9.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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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}.
     *
     * 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 default value returned by this function, unless
     * it's 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, allowance(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 = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * 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/security/ReentrancyGuard.sol

// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol

// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol

// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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

// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol

// OpenZeppelin Contracts (last updated v4.9.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 // Deprecated in v4.8
    }

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

    /**
     * @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) {
        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.
            /// @solidity memory-safe-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 {
            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 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 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @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 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// File: contracts/UrbsToken.sol

pragma solidity ^0.8.11;




contract UrbsToken is ERC20, Ownable, ReentrancyGuard {
    uint256 public constant MAX_SUPPLY = 420000000000 * 10 ** 18;
    mapping(uint256 => bool) usedNonces;
    address public gameWallet;

    event TokensTransferredWithSignature(
        address indexed signer,
        address indexed receiver,
        uint256 quantity
    );
    event GameWalletUpdated(address indexed newGameWallet);

    constructor() ERC20("Urbs Token", "URBS") {}

    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }

    function setGameWallet(address _gameWallet) public onlyOwner {
        require(_gameWallet != address(0), "GameWallet cannot be zero address");
        gameWallet = _gameWallet;
        emit GameWalletUpdated(_gameWallet);
    }

    function isGameWallet(address account) public view returns (bool) {
        return account == gameWallet;
    }

    function claimPayment(
        address to,
        uint256 amount,
        uint256 nonce,
        bytes memory sig
    ) public nonReentrant {
        require(!usedNonces[nonce], "Nonce has already been used");

        usedNonces[nonce] = true;

        bytes32 message = keccak256(
            abi.encodePacked(to, amount, nonce, address(this))
        );

        bytes32 prefixedMessage = ECDSA.toEthSignedMessageHash(message);

        address recoveredAddress = recoverSigner(prefixedMessage, sig);

        require(recoveredAddress == gameWallet, "Signature is not valid!");

        _transfer(gameWallet, to, amount);

        emit TokensTransferredWithSignature(recoveredAddress, to, amount);
    }

    function recoverSigner(
        bytes32 message,
        bytes memory sig
    ) internal pure returns (address) {
        return ECDSA.recover(message, sig);
    }
}

• 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":true,"internalType":"address","name":"newGameWallet","type":"address"}],"name":"GameWalletUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"TokensTransferredWithSignature","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":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"claimPayment","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":[],"name":"gameWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":[{"internalType":"address","name":"account","type":"address"}],"name":"isGameWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_gameWallet","type":"address"}],"name":"setGameWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

50300:1915:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6642:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9002:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7771:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9783:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7613:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50361:60;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10453:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50764:173;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51306:730;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7942:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22745:103;;;:::i;:::-;;50945:232;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22104:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6861:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51185:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11194:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8275:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8531:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50470:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23003:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6642:100;6696:13;6729:5;6722:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6642:100;:::o;9002:201::-;9085:4;9102:13;9118:12;:10;:12::i;:::-;9102:28;;9141:32;9150:5;9157:7;9166:6;9141:8;:32::i;:::-;9191:4;9184:11;;;9002:201;;;;:::o;7771:108::-;7832:7;7859:12;;7852:19;;7771:108;:::o;9783:261::-;9880:4;9897:15;9915:12;:10;:12::i;:::-;9897:30;;9938:38;9954:4;9960:7;9969:6;9938:15;:38::i;:::-;9987:27;9997:4;10003:2;10007:6;9987:9;:27::i;:::-;10032:4;10025:11;;;9783:261;;;;;:::o;7613:93::-;7671:5;7696:2;7689:9;;7613:93;:::o;50361:60::-;50398:23;50361:60;:::o;10453:238::-;10541:4;10558:13;10574:12;:10;:12::i;:::-;10558:28;;10597:64;10606:5;10613:7;10650:10;10622:25;10632:5;10639:7;10622:9;:25::i;:::-;:38;;;;:::i;:::-;10597:8;:64::i;:::-;10679:4;10672:11;;;10453:238;;;;:::o;50764:173::-;21990:13;:11;:13::i;:::-;50398:23:::1;50858:6;50842:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:36;;50834:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;50912:17;50918:2;50922:6;50912:5;:17::i;:::-;50764:173:::0;;:::o;51306:730::-;19978:21;:19;:21::i;:::-;51472:10:::1;:17;51483:5;51472:17;;;;;;;;;;;;;;;;;;;;;51471:18;51463:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51554:4;51534:10;:17;51545:5;51534:17;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;51571:15;51630:2;51634:6;51642:5;51657:4;51613:50;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;51589:85;;;;;;51571:103;;51687:23;51713:37;51742:7;51713:28;:37::i;:::-;51687:63;;51763:24;51790:35;51804:15;51821:3;51790:13;:35::i;:::-;51763:62;;51866:10;;;;;;;;;;;51846:30;;:16;:30;;;51838:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;51917:33;51927:10;;;;;;;;;;;51939:2;51943:6;51917:9;:33::i;:::-;52017:2;51968:60;;51999:16;51968:60;;;52021:6;51968:60;;;;;;:::i;:::-;;;;;;;;51452:584;;;20022:20:::0;:18;:20::i;:::-;51306:730;;;;:::o;7942:127::-;8016:7;8043:9;:18;8053:7;8043:18;;;;;;;;;;;;;;;;8036:25;;7942:127;;;:::o;22745:103::-;21990:13;:11;:13::i;:::-;22810:30:::1;22837:1;22810:18;:30::i;:::-;22745:103::o:0;50945:232::-;21990:13;:11;:13::i;:::-;51048:1:::1;51025:25;;:11;:25;;;;51017:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;51112:11;51099:10;;:24;;;;;;;;;;;;;;;;;;51157:11;51139:30;;;;;;;;;;;;50945:232:::0;:::o;22104:87::-;22150:7;22177:6;;;;;;;;;;;22170:13;;22104:87;:::o;6861:104::-;6917:13;6950:7;6943:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6861:104;:::o;51185:113::-;51245:4;51280:10;;;;;;;;;;;51269:21;;:7;:21;;;51262:28;;51185:113;;;:::o;11194:436::-;11287:4;11304:13;11320:12;:10;:12::i;:::-;11304:28;;11343:24;11370:25;11380:5;11387:7;11370:9;:25::i;:::-;11343:52;;11434:15;11414:16;:35;;11406:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;11527:60;11536:5;11543:7;11571:15;11552:16;:34;11527:8;:60::i;:::-;11618:4;11611:11;;;;11194:436;;;;:::o;8275:193::-;8354:4;8371:13;8387:12;:10;:12::i;:::-;8371:28;;8410;8420:5;8427:2;8431:6;8410:9;:28::i;:::-;8456:4;8449:11;;;8275:193;;;;:::o;8531:151::-;8620:7;8647:11;:18;8659:5;8647:18;;;;;;;;;;;;;;;:27;8666:7;8647:27;;;;;;;;;;;;;;;;8640:34;;8531:151;;;;:::o;50470:25::-;;;;;;;;;;;;;:::o;23003:201::-;21990:13;:11;:13::i;:::-;23112:1:::1;23092:22;;:8;:22;;;;23084:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;23168:28;23187:8;23168:18;:28::i;:::-;23003:201:::0;:::o;4284:98::-;4337:7;4364:10;4357:17;;4284:98;:::o;15187:346::-;15306:1;15289:19;;:5;:19;;;;15281:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;15387:1;15368:21;;:7;:21;;;;15360:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;15471:6;15441:11;:18;15453:5;15441:18;;;;;;;;;;;;;;;:27;15460:7;15441:27;;;;;;;;;;;;;;;:36;;;;15509:7;15493:32;;15502:5;15493:32;;;15518:6;15493:32;;;;;;:::i;:::-;;;;;;;;15187:346;;;:::o;15824:419::-;15925:24;15952:25;15962:5;15969:7;15952:9;:25::i;:::-;15925:52;;16012:17;15992:16;:37;15988:248;;16074:6;16054:16;:26;;16046:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;16158:51;16167:5;16174:7;16202:6;16183:16;:25;16158:8;:51::i;:::-;15988:248;15914:329;15824:419;;;:::o;12100:806::-;12213:1;12197:18;;:4;:18;;;;12189:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12290:1;12276:16;;:2;:16;;;;12268:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;12345:38;12366:4;12372:2;12376:6;12345:20;:38::i;:::-;12396:19;12418:9;:15;12428:4;12418:15;;;;;;;;;;;;;;;;12396:37;;12467:6;12452:11;:21;;12444:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;12584:6;12570:11;:20;12552:9;:15;12562:4;12552:15;;;;;;;;;;;;;;;:38;;;;12787:6;12770:9;:13;12780:2;12770:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;12837:2;12822:26;;12831:4;12822:26;;;12841:6;12822:26;;;;;;:::i;:::-;;;;;;;;12861:37;12881:4;12887:2;12891:6;12861:19;:37::i;:::-;12178:728;12100:806;;;:::o;22269:132::-;22344:12;:10;:12::i;:::-;22333:23;;:7;:5;:7::i;:::-;:23;;;22325:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22269:132::o;13193:548::-;13296:1;13277:21;;:7;:21;;;;13269:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;13347:49;13376:1;13380:7;13389:6;13347:20;:49::i;:::-;13425:6;13409:12;;:22;;;;;;;:::i;:::-;;;;;;;;13602:6;13580:9;:18;13590:7;13580:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;13656:7;13635:37;;13652:1;13635:37;;;13665:6;13635:37;;;;;;:::i;:::-;;;;;;;;13685:48;13713:1;13717:7;13726:6;13685:19;:48::i;:::-;13193:548;;:::o;20058:293::-;19460:1;20192:7;;:19;;20184:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;19460:1;20325:7;:18;;;;20058:293::o;48164:405::-;48233:15;48438:34;48432:4;48425:48;48500:4;48494;48487:18;48546:4;48540;48530:21;48519:32;;48164:405;;;:::o;52044:168::-;52150:7;52177:27;52191:7;52200:3;52177:13;:27::i;:::-;52170:34;;52044:168;;;;:::o;20359:213::-;19416:1;20542:7;:22;;;;20359:213::o;23364:191::-;23438:16;23457:6;;;;;;;;;;;23438:25;;23483:8;23474:6;;:17;;;;;;;;;;;;;;;;;;23538:8;23507:40;;23528:8;23507:40;;;;;;;;;;;;23427:128;23364:191;:::o;16843:91::-;;;;:::o;17538:90::-;;;;:::o;44628:231::-;44706:7;44727:17;44746:18;44768:27;44779:4;44785:9;44768:10;:27::i;:::-;44726:69;;;;44806:18;44818:5;44806:11;:18::i;:::-;44842:9;44835:16;;;;44628:231;;;;:::o;43079:747::-;43160:7;43169:12;43218:2;43198:9;:16;:22;43194:625;;;43237:9;43261;43285:7;43542:4;43531:9;43527:20;43521:27;43516:32;;43592:4;43581:9;43577:20;43571:27;43566:32;;43650:4;43639:9;43635:20;43629:27;43626:1;43621:36;43616:41;;43693:25;43704:4;43710:1;43713;43716;43693:10;:25::i;:::-;43686:32;;;;;;;;;43194:625;43767:1;43771:35;43751:56;;;;43079:747;;;;;;:::o;41472:521::-;41550:20;41541:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;41537:449;;;41587:7;;41537:449;41648:29;41639:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;41635:351;;;41694:34;;;;;;;;;;:::i;:::-;;;;;;;;41635:351;41759:35;41750:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;41746:240;;;41811:41;;;;;;;;;;:::i;:::-;;;;;;;;41746:240;41883:30;41874:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;41870:116;;;41930:44;;;;;;;;;;:::i;:::-;;;;;;;;41870:116;41472:521;;:::o;46012:1477::-;46100:7;46109:12;47034:66;47029:1;47021:10;;:79;47017:163;;;47133:1;47137:30;47117:51;;;;;;47017:163;47277:14;47294:24;47304:4;47310:1;47313;47316;47294:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47277:41;;47351:1;47333:20;;:6;:20;;;47329:103;;;47386:1;47390:29;47370:50;;;;;;;47329:103;47452:6;47460:20;47444:37;;;;;46012:1477;;;;;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:307::-;355:1;365:113;379:6;376:1;373:13;365:113;;;464:1;459:3;455:11;449:18;445:1;440:3;436:11;429:39;401:2;398:1;394:10;389:15;;365:113;;;496:6;493:1;490:13;487:101;;;576:1;567:6;562:3;558:16;551:27;487:101;336:258;287:307;;;:::o;600:102::-;641:6;692:2;688:7;683:2;676:5;672:14;668:28;658:38;;600:102;;;:::o;708:364::-;796:3;824:39;857:5;824:39;:::i;:::-;879:71;943:6;938:3;879:71;:::i;:::-;872:78;;959:52;1004:6;999:3;992:4;985:5;981:16;959:52;:::i;:::-;1036:29;1058:6;1036:29;:::i;:::-;1031:3;1027:39;1020:46;;800:272;708:364;;;;:::o;1078:313::-;1191:4;1229:2;1218:9;1214:18;1206:26;;1278:9;1272:4;1268:20;1264:1;1253:9;1249:17;1242:47;1306:78;1379:4;1370:6;1306:78;:::i;:::-;1298:86;;1078:313;;;;:::o;1397:75::-;1430:6;1463:2;1457:9;1447:19;;1397:75;:::o;1478:117::-;1587:1;1584;1577:12;1601:117;1710:1;1707;1700:12;1724:126;1761:7;1801:42;1794:5;1790:54;1779:65;;1724:126;;;:::o;1856:96::-;1893:7;1922:24;1940:5;1922:24;:::i;:::-;1911:35;;1856:96;;;:::o;1958:122::-;2031:24;2049:5;2031:24;:::i;:::-;2024:5;2021:35;2011:63;;2070:1;2067;2060:12;2011:63;1958:122;:::o;2086:139::-;2132:5;2170:6;2157:20;2148:29;;2186:33;2213:5;2186:33;:::i;:::-;2086:139;;;;:::o;2231:77::-;2268:7;2297:5;2286:16;;2231:77;;;:::o;2314:122::-;2387:24;2405:5;2387:24;:::i;:::-;2380:5;2377:35;2367:63;;2426:1;2423;2416:12;2367:63;2314:122;:::o;2442:139::-;2488:5;2526:6;2513:20;2504:29;;2542:33;2569:5;2542:33;:::i;:::-;2442:139;;;;:::o;2587:474::-;2655:6;2663;2712:2;2700:9;2691:7;2687:23;2683:32;2680:119;;;2718:79;;:::i;:::-;2680:119;2838:1;2863:53;2908:7;2899:6;2888:9;2884:22;2863:53;:::i;:::-;2853:63;;2809:117;2965:2;2991:53;3036:7;3027:6;3016:9;3012:22;2991:53;:::i;:::-;2981:63;;2936:118;2587:474;;;;;:::o;3067:90::-;3101:7;3144:5;3137:13;3130:21;3119:32;;3067:90;;;:::o;3163:109::-;3244:21;3259:5;3244:21;:::i;:::-;3239:3;3232:34;3163:109;;:::o;3278:210::-;3365:4;3403:2;3392:9;3388:18;3380:26;;3416:65;3478:1;3467:9;3463:17;3454:6;3416:65;:::i;:::-;3278:210;;;;:::o;3494:118::-;3581:24;3599:5;3581:24;:::i;:::-;3576:3;3569:37;3494:118;;:::o;3618:222::-;3711:4;3749:2;3738:9;3734:18;3726:26;;3762:71;3830:1;3819:9;3815:17;3806:6;3762:71;:::i;:::-;3618:222;;;;:::o;3846:619::-;3923:6;3931;3939;3988:2;3976:9;3967:7;3963:23;3959:32;3956:119;;;3994:79;;:::i;:::-;3956:119;4114:1;4139:53;4184:7;4175:6;4164:9;4160:22;4139:53;:::i;:::-;4129:63;;4085:117;4241:2;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4212:118;4369:2;4395:53;4440:7;4431:6;4420:9;4416:22;4395:53;:::i;:::-;4385:63;;4340:118;3846:619;;;;;:::o;4471:86::-;4506:7;4546:4;4539:5;4535:16;4524:27;;4471:86;;;:::o;4563:112::-;4646:22;4662:5;4646:22;:::i;:::-;4641:3;4634:35;4563:112;;:::o;4681:214::-;4770:4;4808:2;4797:9;4793:18;4785:26;;4821:67;4885:1;4874:9;4870:17;4861:6;4821:67;:::i;:::-;4681:214;;;;:::o;4901:117::-;5010:1;5007;5000:12;5024:117;5133:1;5130;5123:12;5147:180;5195:77;5192:1;5185:88;5292:4;5289:1;5282:15;5316:4;5313:1;5306:15;5333:281;5416:27;5438:4;5416:27;:::i;:::-;5408:6;5404:40;5546:6;5534:10;5531:22;5510:18;5498:10;5495:34;5492:62;5489:88;;;5557:18;;:::i;:::-;5489:88;5597:10;5593:2;5586:22;5376:238;5333:281;;:::o;5620:129::-;5654:6;5681:20;;:::i;:::-;5671:30;;5710:33;5738:4;5730:6;5710:33;:::i;:::-;5620:129;;;:::o;5755:307::-;5816:4;5906:18;5898:6;5895:30;5892:56;;;5928:18;;:::i;:::-;5892:56;5966:29;5988:6;5966:29;:::i;:::-;5958:37;;6050:4;6044;6040:15;6032:23;;5755:307;;;:::o;6068:154::-;6152:6;6147:3;6142;6129:30;6214:1;6205:6;6200:3;6196:16;6189:27;6068:154;;;:::o;6228:410::-;6305:5;6330:65;6346:48;6387:6;6346:48;:::i;:::-;6330:65;:::i;:::-;6321:74;;6418:6;6411:5;6404:21;6456:4;6449:5;6445:16;6494:3;6485:6;6480:3;6476:16;6473:25;6470:112;;;6501:79;;:::i;:::-;6470:112;6591:41;6625:6;6620:3;6615;6591:41;:::i;:::-;6311:327;6228:410;;;;;:::o;6657:338::-;6712:5;6761:3;6754:4;6746:6;6742:17;6738:27;6728:122;;6769:79;;:::i;:::-;6728:122;6886:6;6873:20;6911:78;6985:3;6977:6;6970:4;6962:6;6958:17;6911:78;:::i;:::-;6902:87;;6718:277;6657:338;;;;:::o;7001:943::-;7096:6;7104;7112;7120;7169:3;7157:9;7148:7;7144:23;7140:33;7137:120;;;7176:79;;:::i;:::-;7137:120;7296:1;7321:53;7366:7;7357:6;7346:9;7342:22;7321:53;:::i;:::-;7311:63;;7267:117;7423:2;7449:53;7494:7;7485:6;7474:9;7470:22;7449:53;:::i;:::-;7439:63;;7394:118;7551:2;7577:53;7622:7;7613:6;7602:9;7598:22;7577:53;:::i;:::-;7567:63;;7522:118;7707:2;7696:9;7692:18;7679:32;7738:18;7730:6;7727:30;7724:117;;;7760:79;;:::i;:::-;7724:117;7865:62;7919:7;7910:6;7899:9;7895:22;7865:62;:::i;:::-;7855:72;;7650:287;7001:943;;;;;;;:::o;7950:329::-;8009:6;8058:2;8046:9;8037:7;8033:23;8029:32;8026:119;;;8064:79;;:::i;:::-;8026:119;8184:1;8209:53;8254:7;8245:6;8234:9;8230:22;8209:53;:::i;:::-;8199:63;;8155:117;7950:329;;;;:::o;8285:118::-;8372:24;8390:5;8372:24;:::i;:::-;8367:3;8360:37;8285:118;;:::o;8409:222::-;8502:4;8540:2;8529:9;8525:18;8517:26;;8553:71;8621:1;8610:9;8606:17;8597:6;8553:71;:::i;:::-;8409:222;;;;:::o;8637:474::-;8705:6;8713;8762:2;8750:9;8741:7;8737:23;8733:32;8730:119;;;8768:79;;:::i;:::-;8730:119;8888:1;8913:53;8958:7;8949:6;8938:9;8934:22;8913:53;:::i;:::-;8903:63;;8859:117;9015:2;9041:53;9086:7;9077:6;9066:9;9062:22;9041:53;:::i;:::-;9031:63;;8986:118;8637:474;;;;;:::o;9117:180::-;9165:77;9162:1;9155:88;9262:4;9259:1;9252:15;9286:4;9283:1;9276:15;9303:320;9347:6;9384:1;9378:4;9374:12;9364:22;;9431:1;9425:4;9421:12;9452:18;9442:81;;9508:4;9500:6;9496:17;9486:27;;9442:81;9570:2;9562:6;9559:14;9539:18;9536:38;9533:84;;;9589:18;;:::i;:::-;9533:84;9354:269;9303:320;;;:::o;9629:180::-;9677:77;9674:1;9667:88;9774:4;9771:1;9764:15;9798:4;9795:1;9788:15;9815:305;9855:3;9874:20;9892:1;9874:20;:::i;:::-;9869:25;;9908:20;9926:1;9908:20;:::i;:::-;9903:25;;10062:1;9994:66;9990:74;9987:1;9984:81;9981:107;;;10068:18;;:::i;:::-;9981:107;10112:1;10109;10105:9;10098:16;;9815:305;;;;:::o;10126:168::-;10266:20;10262:1;10254:6;10250:14;10243:44;10126:168;:::o;10300:366::-;10442:3;10463:67;10527:2;10522:3;10463:67;:::i;:::-;10456:74;;10539:93;10628:3;10539:93;:::i;:::-;10657:2;10652:3;10648:12;10641:19;;10300:366;;;:::o;10672:419::-;10838:4;10876:2;10865:9;10861:18;10853:26;;10925:9;10919:4;10915:20;10911:1;10900:9;10896:17;10889:47;10953:131;11079:4;10953:131;:::i;:::-;10945:139;;10672:419;;;:::o;11097:177::-;11237:29;11233:1;11225:6;11221:14;11214:53;11097:177;:::o;11280:366::-;11422:3;11443:67;11507:2;11502:3;11443:67;:::i;:::-;11436:74;;11519:93;11608:3;11519:93;:::i;:::-;11637:2;11632:3;11628:12;11621:19;;11280:366;;;:::o;11652:419::-;11818:4;11856:2;11845:9;11841:18;11833:26;;11905:9;11899:4;11895:20;11891:1;11880:9;11876:17;11869:47;11933:131;12059:4;11933:131;:::i;:::-;11925:139;;11652:419;;;:::o;12077:94::-;12110:8;12158:5;12154:2;12150:14;12129:35;;12077:94;;;:::o;12177:::-;12216:7;12245:20;12259:5;12245:20;:::i;:::-;12234:31;;12177:94;;;:::o;12277:100::-;12316:7;12345:26;12365:5;12345:26;:::i;:::-;12334:37;;12277:100;;;:::o;12383:157::-;12488:45;12508:24;12526:5;12508:24;:::i;:::-;12488:45;:::i;:::-;12483:3;12476:58;12383:157;;:::o;12546:79::-;12585:7;12614:5;12603:16;;12546:79;;;:::o;12631:157::-;12736:45;12756:24;12774:5;12756:24;:::i;:::-;12736:45;:::i;:::-;12731:3;12724:58;12631:157;;:::o;12794:679::-;12990:3;13005:75;13076:3;13067:6;13005:75;:::i;:::-;13105:2;13100:3;13096:12;13089:19;;13118:75;13189:3;13180:6;13118:75;:::i;:::-;13218:2;13213:3;13209:12;13202:19;;13231:75;13302:3;13293:6;13231:75;:::i;:::-;13331:2;13326:3;13322:12;13315:19;;13344:75;13415:3;13406:6;13344:75;:::i;:::-;13444:2;13439:3;13435:12;13428:19;;13464:3;13457:10;;12794:679;;;;;;;:::o;13479:173::-;13619:25;13615:1;13607:6;13603:14;13596:49;13479:173;:::o;13658:366::-;13800:3;13821:67;13885:2;13880:3;13821:67;:::i;:::-;13814:74;;13897:93;13986:3;13897:93;:::i;:::-;14015:2;14010:3;14006:12;13999:19;;13658:366;;;:::o;14030:419::-;14196:4;14234:2;14223:9;14219:18;14211:26;;14283:9;14277:4;14273:20;14269:1;14258:9;14254:17;14247:47;14311:131;14437:4;14311:131;:::i;:::-;14303:139;;14030:419;;;:::o;14455:220::-;14595:34;14591:1;14583:6;14579:14;14572:58;14664:3;14659:2;14651:6;14647:15;14640:28;14455:220;:::o;14681:366::-;14823:3;14844:67;14908:2;14903:3;14844:67;:::i;:::-;14837:74;;14920:93;15009:3;14920:93;:::i;:::-;15038:2;15033:3;15029:12;15022:19;;14681:366;;;:::o;15053:419::-;15219:4;15257:2;15246:9;15242:18;15234:26;;15306:9;15300:4;15296:20;15292:1;15281:9;15277:17;15270:47;15334:131;15460:4;15334:131;:::i;:::-;15326:139;;15053:419;;;:::o;15478:224::-;15618:34;15614:1;15606:6;15602:14;15595:58;15687:7;15682:2;15674:6;15670:15;15663:32;15478:224;:::o;15708:366::-;15850:3;15871:67;15935:2;15930:3;15871:67;:::i;:::-;15864:74;;15947:93;16036:3;15947:93;:::i;:::-;16065:2;16060:3;16056:12;16049:19;;15708:366;;;:::o;16080:419::-;16246:4;16284:2;16273:9;16269:18;16261:26;;16333:9;16327:4;16323:20;16319:1;16308:9;16304:17;16297:47;16361:131;16487:4;16361:131;:::i;:::-;16353:139;;16080:419;;;:::o;16505:225::-;16645:34;16641:1;16633:6;16629:14;16622:58;16714:8;16709:2;16701:6;16697:15;16690:33;16505:225;:::o;16736:366::-;16878:3;16899:67;16963:2;16958:3;16899:67;:::i;:::-;16892:74;;16975:93;17064:3;16975:93;:::i;:::-;17093:2;17088:3;17084:12;17077:19;;16736:366;;;:::o;17108:419::-;17274:4;17312:2;17301:9;17297:18;17289:26;;17361:9;17355:4;17351:20;17347:1;17336:9;17332:17;17325:47;17389:131;17515:4;17389:131;:::i;:::-;17381:139;;17108:419;;;:::o;17533:223::-;17673:34;17669:1;17661:6;17657:14;17650:58;17742:6;17737:2;17729:6;17725:15;17718:31;17533:223;:::o;17762:366::-;17904:3;17925:67;17989:2;17984:3;17925:67;:::i;:::-;17918:74;;18001:93;18090:3;18001:93;:::i;:::-;18119:2;18114:3;18110:12;18103:19;;17762:366;;;:::o;18134:419::-;18300:4;18338:2;18327:9;18323:18;18315:26;;18387:9;18381:4;18377:20;18373:1;18362:9;18358:17;18351:47;18415:131;18541:4;18415:131;:::i;:::-;18407:139;;18134:419;;;:::o;18559:221::-;18699:34;18695:1;18687:6;18683:14;18676:58;18768:4;18763:2;18755:6;18751:15;18744:29;18559:221;:::o;18786:366::-;18928:3;18949:67;19013:2;19008:3;18949:67;:::i;:::-;18942:74;;19025:93;19114:3;19025:93;:::i;:::-;19143:2;19138:3;19134:12;19127:19;;18786:366;;;:::o;19158:419::-;19324:4;19362:2;19351:9;19347:18;19339:26;;19411:9;19405:4;19401:20;19397:1;19386:9;19382:17;19375:47;19439:131;19565:4;19439:131;:::i;:::-;19431:139;;19158:419;;;:::o;19583:179::-;19723:31;19719:1;19711:6;19707:14;19700:55;19583:179;:::o;19768:366::-;19910:3;19931:67;19995:2;19990:3;19931:67;:::i;:::-;19924:74;;20007:93;20096:3;20007:93;:::i;:::-;20125:2;20120:3;20116:12;20109:19;;19768:366;;;:::o;20140:419::-;20306:4;20344:2;20333:9;20329:18;20321:26;;20393:9;20387:4;20383:20;20379:1;20368:9;20364:17;20357:47;20421:131;20547:4;20421:131;:::i;:::-;20413:139;;20140:419;;;:::o;20565:224::-;20705:34;20701:1;20693:6;20689:14;20682:58;20774:7;20769:2;20761:6;20757:15;20750:32;20565:224;:::o;20795:366::-;20937:3;20958:67;21022:2;21017:3;20958:67;:::i;:::-;20951:74;;21034:93;21123:3;21034:93;:::i;:::-;21152:2;21147:3;21143:12;21136:19;;20795:366;;;:::o;21167:419::-;21333:4;21371:2;21360:9;21356:18;21348:26;;21420:9;21414:4;21410:20;21406:1;21395:9;21391:17;21384:47;21448:131;21574:4;21448:131;:::i;:::-;21440:139;;21167:419;;;:::o;21592:222::-;21732:34;21728:1;21720:6;21716:14;21709:58;21801:5;21796:2;21788:6;21784:15;21777:30;21592:222;:::o;21820:366::-;21962:3;21983:67;22047:2;22042:3;21983:67;:::i;:::-;21976:74;;22059:93;22148:3;22059:93;:::i;:::-;22177:2;22172:3;22168:12;22161:19;;21820:366;;;:::o;22192:419::-;22358:4;22396:2;22385:9;22381:18;22373:26;;22445:9;22439:4;22435:20;22431:1;22420:9;22416:17;22409:47;22473:131;22599:4;22473:131;:::i;:::-;22465:139;;22192:419;;;:::o;22617:225::-;22757:34;22753:1;22745:6;22741:14;22734:58;22826:8;22821:2;22813:6;22809:15;22802:33;22617:225;:::o;22848:366::-;22990:3;23011:67;23075:2;23070:3;23011:67;:::i;:::-;23004:74;;23087:93;23176:3;23087:93;:::i;:::-;23205:2;23200:3;23196:12;23189:19;;22848:366;;;:::o;23220:419::-;23386:4;23424:2;23413:9;23409:18;23401:26;;23473:9;23467:4;23463:20;23459:1;23448:9;23444:17;23437:47;23501:131;23627:4;23501:131;:::i;:::-;23493:139;;23220:419;;;:::o;23645:182::-;23785:34;23781:1;23773:6;23769:14;23762:58;23645:182;:::o;23833:366::-;23975:3;23996:67;24060:2;24055:3;23996:67;:::i;:::-;23989:74;;24072:93;24161:3;24072:93;:::i;:::-;24190:2;24185:3;24181:12;24174:19;;23833:366;;;:::o;24205:419::-;24371:4;24409:2;24398:9;24394:18;24386:26;;24458:9;24452:4;24448:20;24444:1;24433:9;24429:17;24422:47;24486:131;24612:4;24486:131;:::i;:::-;24478:139;;24205:419;;;:::o;24630:181::-;24770:33;24766:1;24758:6;24754:14;24747:57;24630:181;:::o;24817:366::-;24959:3;24980:67;25044:2;25039:3;24980:67;:::i;:::-;24973:74;;25056:93;25145:3;25056:93;:::i;:::-;25174:2;25169:3;25165:12;25158:19;;24817:366;;;:::o;25189:419::-;25355:4;25393:2;25382:9;25378:18;25370:26;;25442:9;25436:4;25432:20;25428:1;25417:9;25413:17;25406:47;25470:131;25596:4;25470:131;:::i;:::-;25462:139;;25189:419;;;:::o;25614:181::-;25754:33;25750:1;25742:6;25738:14;25731:57;25614:181;:::o;25801:366::-;25943:3;25964:67;26028:2;26023:3;25964:67;:::i;:::-;25957:74;;26040:93;26129:3;26040:93;:::i;:::-;26158:2;26153:3;26149:12;26142:19;;25801:366;;;:::o;26173:419::-;26339:4;26377:2;26366:9;26362:18;26354:26;;26426:9;26420:4;26416:20;26412:1;26401:9;26397:17;26390:47;26454:131;26580:4;26454:131;:::i;:::-;26446:139;;26173:419;;;:::o;26598:180::-;26646:77;26643:1;26636:88;26743:4;26740:1;26733:15;26767:4;26764:1;26757:15;26784:174;26924:26;26920:1;26912:6;26908:14;26901:50;26784:174;:::o;26964:366::-;27106:3;27127:67;27191:2;27186:3;27127:67;:::i;:::-;27120:74;;27203:93;27292:3;27203:93;:::i;:::-;27321:2;27316:3;27312:12;27305:19;;26964:366;;;:::o;27336:419::-;27502:4;27540:2;27529:9;27525:18;27517:26;;27589:9;27583:4;27579:20;27575:1;27564:9;27560:17;27553:47;27617:131;27743:4;27617:131;:::i;:::-;27609:139;;27336:419;;;:::o;27761:181::-;27901:33;27897:1;27889:6;27885:14;27878:57;27761:181;:::o;27948:366::-;28090:3;28111:67;28175:2;28170:3;28111:67;:::i;:::-;28104:74;;28187:93;28276:3;28187:93;:::i;:::-;28305:2;28300:3;28296:12;28289:19;;27948:366;;;:::o;28320:419::-;28486:4;28524:2;28513:9;28509:18;28501:26;;28573:9;28567:4;28563:20;28559:1;28548:9;28544:17;28537:47;28601:131;28727:4;28601:131;:::i;:::-;28593:139;;28320:419;;;:::o;28745:221::-;28885:34;28881:1;28873:6;28869:14;28862:58;28954:4;28949:2;28941:6;28937:15;28930:29;28745:221;:::o;28972:366::-;29114:3;29135:67;29199:2;29194:3;29135:67;:::i;:::-;29128:74;;29211:93;29300:3;29211:93;:::i;:::-;29329:2;29324:3;29320:12;29313:19;;28972:366;;;:::o;29344:419::-;29510:4;29548:2;29537:9;29533:18;29525:26;;29597:9;29591:4;29587:20;29583:1;29572:9;29568:17;29561:47;29625:131;29751:4;29625:131;:::i;:::-;29617:139;;29344:419;;;:::o;29769:77::-;29806:7;29835:5;29824:16;;29769:77;;;:::o;29852:118::-;29939:24;29957:5;29939:24;:::i;:::-;29934:3;29927:37;29852:118;;:::o;29976:545::-;30149:4;30187:3;30176:9;30172:19;30164:27;;30201:71;30269:1;30258:9;30254:17;30245:6;30201:71;:::i;:::-;30282:68;30346:2;30335:9;30331:18;30322:6;30282:68;:::i;:::-;30360:72;30428:2;30417:9;30413:18;30404:6;30360:72;:::i;:::-;30442;30510:2;30499:9;30495:18;30486:6;30442:72;:::i;:::-;29976:545;;;;;;;:::o

ipfs://13339bc19d75357486b7071932cb4e5ca94febf6b8f922a027c40440c8966c55