Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(    - function _afterTokenTransfer( library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ... library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(    - function recover(    - function tryRecover(    - function recover(    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function _domainSeparatorV4()    - function _buildDomainSeparator(    - function _hashTypedDataV4(bytes32 str ... library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ...    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR()    - function _useNonce(address owner) interface IFactory    - function createPair(address tokenA, a ... interface IRouter    - function factory()    - function WETH()  contract cute is ERC20Permit, Owna ... *    - function setFeeAccount(address accoun ...    - function setBalanceLimit(uint amount)    - function setTax(uint8 buy, uint8 sell ...    - function _transfer(    - function _transferBuy(    - function _transferSell(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-08-10
*/

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


/**
Twitter: https://twitter.com/3CuteMeme
Telegram: https://t.me/ThreeCute3
Website: https://www.3cute.io/
**/

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/access/Ownable.sol

// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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/token/ERC20/extensions/draft-IERC20Permit.sol

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


// OpenZeppelin Contracts (last updated v4.6.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/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.6.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, 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 `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 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/utils/Strings.sol


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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (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 constant _PERMIT_TYPEHASH =
    keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

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

interface IFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}




interface IRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
}


contract cute is ERC20Permit, Ownable{

    uint public _balanceLimit = 690e12 * 1e16;
    uint public _startBlock;

    uint8 public _buyTax;
    address public _pair;
    uint8 public _sellTax;
    address public _feeAccount = address(0xFe42769dc3c77211379Eb7Ee9a265D753C1E5818);




    constructor(
        string memory name,
        string memory symbol
    ) ERC20(name, symbol) ERC20Permit(name) {

        IRouter router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _pair = IFactory(router.factory()).createPair(address(this), router.WETH());

        _mint(msg.sender, 690e12 * 1e18);
    }

    function setFeeAccount(address account) external onlyOwner{
        _feeAccount = account;
    }

    function setBalanceLimit(uint amount) external onlyOwner {
        _balanceLimit = amount;
    }

    function setTax(uint8 buy, uint8 sell) external onlyOwner {
        require(buy < 100, "can not large than 100");
        require(sell < 100, "can not large than 100");

        _buyTax = buy;
        _sellTax = sell;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (_pair == from) {
            // buy
            _transferBuy(from, to, amount);
            require(balanceOf(to) <= _balanceLimit, "balance over limit");

        }else if (_pair == to) {
            // sell
            if (_startBlock == 0) {
                super._transfer(from, to, amount);
                _startBlock = block.number;
            }else{
                _transferSell(from, to, amount);
            }
        }else {
            // common
            super._transfer(from, to, amount);
            require(balanceOf(to) <= _balanceLimit, "balance over limit");
        }
    }

    function _transferBuy(
        address from,
        address to,
        uint256 amount
    ) internal {

        uint tax = _buyTax;
        if (tax == 0) {
            uint delta = block.number - _startBlock;
            if (delta > 35) {
                tax = 2;
            }else if (delta > 28 || delta <= 35) {
                tax = 3;
            }else if (delta >= 3 || delta <= 28) {
               tax = 30;
            }else{
               tax = 100;
            }
        }

        uint fee = amount * tax / 100;
        super._transfer(from, to ,amount - fee);
        super._transfer(from, _feeAccount, fee);
    }

    function _transferSell(
        address from,
        address to,
        uint256 amount
    ) internal {
        uint tax = _sellTax;
        if (tax == 0) {
            uint delta = block.number - _startBlock;
            if (delta > 35) {
                tax = 2;
            }else if (delta > 28 || delta <= 35) {
                tax = 8;
            }else if (delta >= 3 || delta <= 28) {
                tax = 70;
            }else{
                tax = 100;
            }
        }

        uint fee = amount * tax / 100;
        super._transfer(from, to ,amount - fee);
        super._transfer(from, _feeAccount, fee);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_balanceLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_buyTax","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_feeAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_sellTax","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_startBlock","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":[],"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":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setBalanceLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"setFeeAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"buy","type":"uint8"},{"internalType":"uint8","name":"sell","type":"uint8"}],"name":"setTax","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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

000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000005334355544500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000053343555445000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): 3CUTE
Arg [1] : symbol (string): 3CUTE

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 3343555445000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 3343555445000000000000000000000000000000000000000000000000000000

43390:3323:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11607:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13958:201;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;12727:108::-;;;:::i;:::-;;;;;;;:::i;14739:295::-;;;;;;:::i;:::-;;:::i;43484:23::-;;;:::i;44144:98::-;;;;;;:::i;:::-;;:::i;:::-;;12569:93;;;:::i;:::-;;;;;;;:::i;42661:115::-;;;:::i;15443:238::-;;;;;;:::i;:::-;;:::i;43516:20::-;;;:::i;44038:98::-;;;;;;:::i;:::-;;:::i;12898:127::-;;;;;;:::i;:::-;;:::i;2667:103::-;;;:::i;42403:128::-;;;;;;:::i;:::-;;:::i;43436:41::-;;;:::i;2016:87::-;;;:::i;:::-;;;;;;;:::i;11826:104::-;;;:::i;16184:424::-;;;;;;:::i;:::-;;:::i;13231:193::-;;;;;;:::i;:::-;;:::i;44250:229::-;;;;;;:::i;:::-;;:::i;43543:20::-;;;:::i;43598:80::-;;;:::i;43570:21::-;;;:::i;41692:645::-;;;;;;:::i;:::-;;:::i;13487:151::-;;;;;;:::i;:::-;;:::i;2925:201::-;;;;;;:::i;:::-;;:::i;11607:100::-;11661:13;11694:5;11687:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11607:100;;:::o;13958:201::-;14041:4;14058:13;14074:12;:10;:12::i;:::-;14058:28;;14097:32;14106:5;14113:7;14122:6;14097:8;:32::i;:::-;-1:-1:-1;14147:4:0;;13958:201;-1:-1:-1;;;13958:201:0:o;12727:108::-;12815:12;;12727:108;:::o;14739:295::-;14870:4;14887:15;14905:12;:10;:12::i;:::-;14887:30;;14928:38;14944:4;14950:7;14959:6;14928:15;:38::i;:::-;14977:27;14987:4;14993:2;14997:6;14977:9;:27::i;:::-;-1:-1:-1;15022:4:0;;14739:295;-1:-1:-1;;;;14739:295:0:o;43484:23::-;;;;:::o;44144:98::-;2247:12;:10;:12::i;:::-;-1:-1:-1;;;;;2236:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2236:23:0;;2228:68;;;;-1:-1:-1;;;2228:68:0;;;;;;;:::i;:::-;;;;;;;;;44212:13:::1;:22:::0;44144:98::o;12569:93::-;12652:2;12569:93;:::o;42661:115::-;42721:7;42748:20;:18;:20::i;:::-;42741:27;;42661:115;:::o;15443:238::-;15531:4;15548:13;15564:12;:10;:12::i;:::-;15548:28;;15587:64;15596:5;15603:7;15640:10;15612:25;15622:5;15629:7;15612:9;:25::i;:::-;:38;;;;:::i;:::-;15587:8;:64::i;43516:20::-;;;;;;:::o;44038:98::-;2247:12;:10;:12::i;:::-;-1:-1:-1;;;;;2236:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2236:23:0;;2228:68;;;;-1:-1:-1;;;2228:68:0;;;;;;;:::i;:::-;44107:11:::1;:21:::0;;-1:-1:-1;;;;;;44107:21:0::1;-1:-1:-1::0;;;;;44107:21:0;;;::::1;::::0;;;::::1;::::0;;44038:98::o;12898:127::-;-1:-1:-1;;;;;12999:18:0;;12972:7;12999:18;;;;;;;;;;;12898:127;;;;:::o;2667:103::-;2247:12;:10;:12::i;:::-;-1:-1:-1;;;;;2236:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2236:23:0;;2228:68;;;;-1:-1:-1;;;2228:68:0;;;;;;;:::i;:::-;2732:30:::1;2759:1;2732:18;:30::i;:::-;2667:103::o:0;42403:128::-;-1:-1:-1;;;;;42499:14:0;;42472:7;42499:14;;;:7;:14;;;;;:24;;:22;:24::i;:::-;42492:31;42403:128;-1:-1:-1;;42403:128:0:o;43436:41::-;;;;:::o;2016:87::-;2089:6;;-1:-1:-1;;;;;2089:6:0;2016:87;:::o;11826:104::-;11882:13;11915:7;11908:14;;;;;:::i;16184:424::-;16277:4;16294:13;16310:12;:10;:12::i;:::-;16294:28;;16333:24;16360:25;16370:5;16377:7;16360:9;:25::i;:::-;16333:52;;16424:15;16404:16;:35;;16396:85;;;;-1:-1:-1;;;16396:85:0;;;;;;;:::i;:::-;16509:60;16518:5;16525:7;16553:15;16534:16;:34;16509:8;:60::i;13231:193::-;13310:4;13327:13;13343:12;:10;:12::i;:::-;13327:28;;13366;13376:5;13383:2;13387:6;13366:9;:28::i;44250:229::-;2247:12;:10;:12::i;:::-;-1:-1:-1;;;;;2236:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2236:23:0;;2228:68;;;;-1:-1:-1;;;2228:68:0;;;;;;;:::i;:::-;44333:3:::1;44327;:9;;;44319:44;;;;-1:-1:-1::0;;;44319:44:0::1;;;;;;;:::i;:::-;44389:3;44382:4;:10;;;44374:45;;;;-1:-1:-1::0;;;44374:45:0::1;;;;;;;:::i;:::-;44432:7;:13:::0;;::::1;44456:15:::0;;::::1;-1:-1:-1::0;;;44456:15:0::1;-1:-1:-1::0;;;;44432:13:0;;;::::1;-1:-1:-1::0;;44432:13:0;;::::1;;44456:15:::0;;;::::1;;::::0;;44250:229::o;43543:20::-;;;;;;-1:-1:-1;;;;;43543:20:0;;:::o;43598:80::-;;;-1:-1:-1;;;;;43598:80:0;;:::o;43570:21::-;;;-1:-1:-1;;;43570:21:0;;;;;:::o;41692:645::-;41936:8;41917:15;:27;;41909:69;;;;-1:-1:-1;;;41909:69:0;;;;;;;:::i;:::-;41991:18;41130:95;42051:5;42058:7;42067:5;42074:16;42084:5;42074:9;:16::i;:::-;42092:8;42022:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42012:90;;;;;;41991:111;;42115:12;42130:28;42147:10;42130:16;:28::i;:::-;42115:43;;42171:14;42188:28;42202:4;42208:1;42211;42214;42188:13;:28::i;:::-;42171:45;;42245:5;-1:-1:-1;;;;;42235:15:0;:6;-1:-1:-1;;;;;42235:15:0;;42227:58;;;;-1:-1:-1;;;42227:58:0;;;;;;;:::i;:::-;42298:31;42307:5;42314:7;42323:5;42298:8;:31::i;:::-;41692:645;;;;;;;;;;:::o;13487:151::-;-1:-1:-1;;;;;13603:18:0;;;13576:7;13603:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;13487:151::o;2925:201::-;2247:12;:10;:12::i;:::-;-1:-1:-1;;;;;2236:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2236:23:0;;2228:68;;;;-1:-1:-1;;;2228:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3014:22:0;::::1;3006:73;;;;-1:-1:-1::0;;;3006:73:0::1;;;;;;;:::i;:::-;3090:28;3109:8;3090:18;:28::i;:::-;2925:201:::0;:::o;742:98::-;822:10;742:98;:::o;19782:380::-;-1:-1:-1;;;;;19918:19:0;;19910:68;;;;-1:-1:-1;;;19910:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;19997:21:0;;19989:68;;;;-1:-1:-1;;;19989:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20070:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;20122:32;;;;;20100:6;;20122:32;:::i;:::-;;;;;;;;19782:380;;;:::o;20453:441::-;20588:24;20615:25;20625:5;20632:7;20615:9;:25::i;:::-;20588:52;;-1:-1:-1;;20655:16:0;:37;20651:236;;20737:6;20717:16;:26;;20709:68;;;;-1:-1:-1;;;20709:68:0;;;;;;;:::i;:::-;20813:51;20822:5;20829:7;20857:6;20838:16;:25;20813:8;:51::i;:::-;20453:441;;;;:::o;44487:899::-;-1:-1:-1;;;;;44619:18:0;;44611:68;;;;-1:-1:-1;;;44611:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;44698:16:0;;44690:64;;;;-1:-1:-1;;;44690:64:0;;;;;;;:::i;:::-;44771:5;;-1:-1:-1;;;;;44771:13:0;;;:5;;;;;:13;44767:612;;;44821:30;44834:4;44840:2;44844:6;44821:12;:30::i;:::-;44891:13;;44874;44884:2;44874:9;:13::i;:::-;:30;;44866:61;;;;-1:-1:-1;;;44866:61:0;;;;;;;:::i;:::-;44767:612;;;44950:5;;-1:-1:-1;;;;;44950:11:0;;;:5;;;;;:11;44946:433;;;45003:11;;44999:205;;45040:33;45056:4;45062:2;45066:6;45040:15;:33::i;:::-;45106:12;45092:11;:26;44999:205;;;45157:31;45171:4;45177:2;45181:6;45157:13;:31::i;44946:433::-;45258:33;45274:4;45280:2;45284:6;45258:15;:33::i;:::-;45331:13;;45314;45324:2;45314:9;:13::i;:::-;:30;;45306:61;;;;-1:-1:-1;;;45306:61:0;;;;;;;:::i;:::-;44487:899;;;:::o;37238:314::-;37291:7;37323:4;-1:-1:-1;;;;;37332:12:0;37315:29;;:66;;;;;37365:16;37348:13;:33;37315:66;37311:234;;;-1:-1:-1;37405:24:0;37398:31;;37311:234;37469:64;37491:10;37503:12;37517:15;37469:21;:64::i;:::-;37462:71;;;;3286:191;3379:6;;;-1:-1:-1;;;;;3396:17:0;;;-1:-1:-1;;;;;;3396:17:0;;;;;;;3429:40;;3379:6;;;3396:17;3379:6;;3429:40;;3360:16;;3429:40;3286:191;;:::o;39509:114::-;39601:14;;39509:114::o;42914:207::-;-1:-1:-1;;;;;43035:14:0;;42974:15;43035:14;;;:7;:14;;;;;43070:15;43035:14;43070:13;:15::i;:::-;43060:25;;43096:17;:5;:15;:17::i;:::-;42914:207;;;;:::o;38465:167::-;38542:7;38569:55;38591:20;:18;:20::i;:::-;38613:10;38569:21;:55::i;32116:279::-;32244:7;32265:17;32284:18;32306:25;32317:4;32323:1;32326;32329;32306:10;:25::i;:::-;32264:67;;;;32342:18;32354:5;32342:11;:18::i;:::-;-1:-1:-1;32378:9:0;32116:279;-1:-1:-1;;;;;32116:279:0:o;45394:653::-;45525:7;;;;45547:8;45543:355;;45572:10;45600:11;;45585:12;:26;;;;:::i;:::-;45572:39;;45638:2;45630:5;:10;45626:261;;;45667:1;45661:7;;45626:261;;;45701:2;45693:5;:10;:25;;;;45716:2;45707:5;:11;;45693:25;45689:198;;;45745:1;45739:7;;45689:198;;;45780:1;45771:5;:10;;:25;;;;45794:2;45785:5;:11;;45771:25;45767:120;;;45822:2;45816:8;;45767:120;;;45868:3;45862:9;;45767:120;45543:355;;45910:8;45936:3;45921:12;45930:3;45921:6;:12;:::i;:::-;:18;;;;:::i;:::-;45910:29;-1:-1:-1;45950:39:0;45966:4;45972:2;45976:12;45910:29;45976:6;:12;:::i;:::-;45950:15;:39::i;:::-;46022:11;;46000:39;;46016:4;;-1:-1:-1;;;;;46022:11:0;46035:3;46000:15;:39::i;:::-;45394:653;;;;;:::o;17087:659::-;-1:-1:-1;;;;;17218:18:0;;17210:68;;;;-1:-1:-1;;;17210:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17297:16:0;;17289:64;;;;-1:-1:-1;;;17289:64:0;;;;;;;:::i;:::-;17366:38;17387:4;17393:2;17397:6;17366:20;:38::i;:::-;-1:-1:-1;;;;;17439:15:0;;17417:19;17439:15;;;;;;;;;;;17473:21;;;;17465:72;;;;-1:-1:-1;;;17465:72:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17565:15:0;;;:9;:15;;;;;;;;;;;17583:20;;;17565:38;;17621:13;;;;;;;;:23;;17597:6;;17565:9;17621:23;;17597:6;;17621:23;:::i;:::-;;;;;;;;17677:2;-1:-1:-1;;;;;17662:26:0;17671:4;-1:-1:-1;;;;;17662:26:0;;17681:6;17662:26;;;;;;:::i;:::-;;;;;;;;17701:37;17721:4;17727:2;17731:6;17701:19;:37::i;46055:655::-;46185:8;;-1:-1:-1;;;46185:8:0;;;;;46204:357;;46233:10;46261:11;;46246:12;:26;;;;:::i;:::-;46233:39;;46299:2;46291:5;:10;46287:263;;;46328:1;46322:7;;46287:263;;;46362:2;46354:5;:10;:25;;;;46377:2;46368:5;:11;;46354:25;46350:200;;;46406:1;46400:7;;46350:200;;;46441:1;46432:5;:10;;:25;;;;46455:2;46446:5;:11;;46432:25;46428:122;;;46484:2;46478:8;;46428:122;;37560:263;37704:7;37752:8;37762;37772:11;37785:13;37808:4;37741:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;37731:84;;;;;;37724:91;;37560:263;;;;;:::o;39631:115::-;39712:19;;39730:1;39712:19;;;39631:115::o;33807:196::-;33900:7;33966:15;33983:10;33937:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;33927:68;;;;;;33920:75;;33807:196;;;;:::o;30345:1632::-;30476:7;;31410:66;31397:79;;31393:163;;;-1:-1:-1;31509:1:0;;-1:-1:-1;31513:30:0;31493:51;;31393:163;31570:1;:7;;31575:2;31570:7;;:18;;;;;31581:1;:7;;31586:2;31581:7;;31570:18;31566:102;;;-1:-1:-1;31621:1:0;;-1:-1:-1;31625:30:0;31605:51;;31566:102;31765:14;31782:24;31792:4;31798:1;31801;31804;31782:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31782:24:0;;-1:-1:-1;;31782:24:0;;;-1:-1:-1;;;;;;;31821:20:0;;31817:103;;31874:1;31878:29;31858:50;;;;;;;31817:103;31940:6;-1:-1:-1;31948:20:0;;-1:-1:-1;30345:1632:0;;;;;;;;:::o;25054:643::-;25132:20;25123:5;:29;;;;;;-1:-1:-1;;;25123:29:0;;;;;;;;;;25119:571;;;25169:7;;25119:571;25230:29;25221:5;:38;;;;;;-1:-1:-1;;;25221:38:0;;;;;;;;;;25217:473;;;25276:34;;-1:-1:-1;;;25276:34:0;;;;;;;:::i;25217:473::-;25341:35;25332:5;:44;;;;;;-1:-1:-1;;;25332:44:0;;;;;;;;;;25328:362;;;25393:41;;-1:-1:-1;;;25393:41:0;;;;;;;:::i;25328:362::-;25465:30;25456:5;:39;;;;;;-1:-1:-1;;;25456:39:0;;;;;;;;;;25452:238;;;25512:44;;-1:-1:-1;;;25512:44:0;;;;;;;:::i;25452:238::-;25587:30;25578:5;:39;;;;;;-1:-1:-1;;;25578:39:0;;;;;;;;;;25574:116;;;25634:44;;-1:-1:-1;;;25634:44:0;;;;;;;:::i;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:158;262:20;;322:4;311:16;;301:27;;291:2;;342:1;339;332:12;357:198;;469:2;457:9;448:7;444:23;440:32;437:2;;;490:6;482;475:22;437:2;518:31;539:9;518:31;:::i;:::-;508:41;427:128;-1:-1:-1;;;427:128:1:o;560:274::-;;;689:2;677:9;668:7;664:23;660:32;657:2;;;710:6;702;695:22;657:2;738:31;759:9;738:31;:::i;:::-;728:41;;788:40;824:2;813:9;809:18;788:40;:::i;:::-;778:50;;647:187;;;;;:::o;839:342::-;;;;985:2;973:9;964:7;960:23;956:32;953:2;;;1006:6;998;991:22;953:2;1034:31;1055:9;1034:31;:::i;:::-;1024:41;;1084:40;1120:2;1109:9;1105:18;1084:40;:::i;:::-;1074:50;;1171:2;1160:9;1156:18;1143:32;1133:42;;943:238;;;;;:::o;1186:622::-;;;;;;;;1398:3;1386:9;1377:7;1373:23;1369:33;1366:2;;;1420:6;1412;1405:22;1366:2;1448:31;1469:9;1448:31;:::i;:::-;1438:41;;1498:40;1534:2;1523:9;1519:18;1498:40;:::i;:::-;1488:50;;1585:2;1574:9;1570:18;1557:32;1547:42;;1636:2;1625:9;1621:18;1608:32;1598:42;;1659:39;1693:3;1682:9;1678:19;1659:39;:::i;:::-;1649:49;;1745:3;1734:9;1730:19;1717:33;1707:43;;1797:3;1786:9;1782:19;1769:33;1759:43;;1356:452;;;;;;;;;;:::o;1813:266::-;;;1942:2;1930:9;1921:7;1917:23;1913:32;1910:2;;;1963:6;1955;1948:22;1910:2;1991:31;2012:9;1991:31;:::i;:::-;1981:41;2069:2;2054:18;;;;2041:32;;-1:-1:-1;;;1900:179:1:o;2084:190::-;;2196:2;2184:9;2175:7;2171:23;2167:32;2164:2;;;2217:6;2209;2202:22;2164:2;-1:-1:-1;2245:23:1;;2154:120;-1:-1:-1;2154:120:1:o;2279:266::-;;;2404:2;2392:9;2383:7;2379:23;2375:32;2372:2;;;2425:6;2417;2410:22;2372:2;2453:29;2472:9;2453:29;:::i;:::-;2443:39;;2501:38;2535:2;2524:9;2520:18;2501:38;:::i;2550:392::-;-1:-1:-1;;;2808:27:1;;2860:1;2851:11;;2844:27;;;;2896:2;2887:12;;2880:28;2933:2;2924:12;;2798:144::o;2947:203::-;-1:-1:-1;;;;;3111:32:1;;;;3093:51;;3081:2;3066:18;;3048:102::o;3155:187::-;3320:14;;3313:22;3295:41;;3283:2;3268:18;;3250:92::o;3347:177::-;3493:25;;;3481:2;3466:18;;3448:76::o;3529:591::-;3816:25;;;-1:-1:-1;;;;;3915:15:1;;;3910:2;3895:18;;3888:43;3967:15;;;;3962:2;3947:18;;3940:43;4014:2;3999:18;;3992:34;4057:3;4042:19;;4035:35;;;;3868:3;4086:19;;4079:35;3803:3;3788:19;;3770:350::o;4125:489::-;4384:25;;;4440:2;4425:18;;4418:34;;;;4483:2;4468:18;;4461:34;;;;4526:2;4511:18;;4504:34;-1:-1:-1;;;;;4575:32:1;4569:3;4554:19;;4547:61;4371:3;4356:19;;4338:276::o;4619:398::-;4846:25;;;4919:4;4907:17;;;;4902:2;4887:18;;4880:45;4956:2;4941:18;;4934:34;4999:2;4984:18;;4977:34;4833:3;4818:19;;4800:217::o;5022:603::-;;5163:2;5192;5181:9;5174:21;5224:6;5218:13;5267:6;5262:2;5251:9;5247:18;5240:34;5292:4;5305:140;5319:6;5316:1;5313:13;5305:140;;;5414:14;;;5410:23;;5404:30;5380:17;;;5399:2;5376:26;5369:66;5334:10;;5305:140;;;5463:6;5460:1;5457:13;5454:2;;;5533:4;5528:2;5519:6;5508:9;5504:22;5500:31;5493:45;5454:2;-1:-1:-1;5609:2:1;5588:15;-1:-1:-1;;5584:29:1;5569:45;;;;5616:2;5565:54;;5143:482;-1:-1:-1;;;5143:482:1:o;5630:348::-;5832:2;5814:21;;;5871:2;5851:18;;;5844:30;5910:26;5905:2;5890:18;;5883:54;5969:2;5954:18;;5804:174::o;5983:399::-;6185:2;6167:21;;;6224:2;6204:18;;;6197:30;6263:34;6258:2;6243:18;;6236:62;-1:-1:-1;;;6329:2:1;6314:18;;6307:33;6372:3;6357:19;;6157:225::o;6387:355::-;6589:2;6571:21;;;6628:2;6608:18;;;6601:30;6667:33;6662:2;6647:18;;6640:61;6733:2;6718:18;;6561:181::o;6747:402::-;6949:2;6931:21;;;6988:2;6968:18;;;6961:30;7027:34;7022:2;7007:18;;7000:62;-1:-1:-1;;;7093:2:1;7078:18;;7071:36;7139:3;7124:19;;6921:228::o;7154:398::-;7356:2;7338:21;;;7395:2;7375:18;;;7368:30;7434:34;7429:2;7414:18;;7407:62;-1:-1:-1;;;7500:2:1;7485:18;;7478:32;7542:3;7527:19;;7328:224::o;7557:353::-;7759:2;7741:21;;;7798:2;7778:18;;;7771:30;7837:31;7832:2;7817:18;;7810:59;7901:2;7886:18;;7731:179::o;7915:353::-;8117:2;8099:21;;;8156:2;8136:18;;;8129:30;8195:31;8190:2;8175:18;;8168:59;8259:2;8244:18;;8089:179::o;8273:402::-;8475:2;8457:21;;;8514:2;8494:18;;;8487:30;8553:34;8548:2;8533:18;;8526:62;-1:-1:-1;;;8619:2:1;8604:18;;8597:36;8665:3;8650:19;;8447:228::o;8680:398::-;8882:2;8864:21;;;8921:2;8901:18;;;8894:30;8960:34;8955:2;8940:18;;8933:62;-1:-1:-1;;;9026:2:1;9011:18;;9004:32;9068:3;9053:19;;8854:224::o;9083:398::-;9285:2;9267:21;;;9324:2;9304:18;;;9297:30;9363:34;9358:2;9343:18;;9336:62;-1:-1:-1;;;9429:2:1;9414:18;;9407:32;9471:3;9456:19;;9257:224::o;9486:342::-;9688:2;9670:21;;;9727:2;9707:18;;;9700:30;-1:-1:-1;;;9761:2:1;9746:18;;9739:48;9819:2;9804:18;;9660:168::o;9833:354::-;10035:2;10017:21;;;10074:2;10054:18;;;10047:30;10113:32;10108:2;10093:18;;10086:60;10178:2;10163:18;;10007:180::o;10192:356::-;10394:2;10376:21;;;10413:18;;;10406:30;10472:34;10467:2;10452:18;;10445:62;10539:2;10524:18;;10366:182::o;10553:401::-;10755:2;10737:21;;;10794:2;10774:18;;;10767:30;10833:34;10828:2;10813:18;;10806:62;-1:-1:-1;;;10899:2:1;10884:18;;10877:35;10944:3;10929:19;;10727:227::o;10959:400::-;11161:2;11143:21;;;11200:2;11180:18;;;11173:30;11239:34;11234:2;11219:18;;11212:62;-1:-1:-1;;;11305:2:1;11290:18;;11283:34;11349:3;11334:19;;11133:226::o;11364:346::-;11566:2;11548:21;;;11605:2;11585:18;;;11578:30;-1:-1:-1;;;11639:2:1;11624:18;;11617:52;11701:2;11686:18;;11538:172::o;11715:401::-;11917:2;11899:21;;;11956:2;11936:18;;;11929:30;11995:34;11990:2;11975:18;;11968:62;-1:-1:-1;;;12061:2:1;12046:18;;12039:35;12106:3;12091:19;;11889:227::o;12303:184::-;12475:4;12463:17;;;;12445:36;;12433:2;12418:18;;12400:87::o;12492:128::-;;12563:1;12559:6;12556:1;12553:13;12550:2;;;12569:18;;:::i;:::-;-1:-1:-1;12605:9:1;;12540:80::o;12625:217::-;;12691:1;12681:2;;-1:-1:-1;;;12716:31:1;;12770:4;12767:1;12760:15;12798:4;12723:1;12788:15;12681:2;-1:-1:-1;12827:9:1;;12671:171::o;12847:168::-;;12953:1;12949;12945:6;12941:14;12938:1;12935:21;12930:1;12923:9;12916:17;12912:45;12909:2;;;12960:18;;:::i;:::-;-1:-1:-1;13000:9:1;;12899:116::o;13020:125::-;;13088:1;13085;13082:8;13079:2;;;13093:18;;:::i;:::-;-1:-1:-1;13130:9:1;;13069:76::o;13150:380::-;13235:1;13225:12;;13282:1;13272:12;;;13293:2;;13347:4;13339:6;13335:17;13325:27;;13293:2;13400;13392:6;13389:14;13369:18;13366:38;13363:2;;;13446:10;13441:3;13437:20;13434:1;13427:31;13481:4;13478:1;13471:15;13509:4;13506:1;13499:15;13535:127;13596:10;13591:3;13587:20;13584:1;13577:31;13627:4;13624:1;13617:15;13651:4;13648:1;13641:15

ipfs://1dac25fb7275a1bc0553b8e8a08f67faf2b0525e704f62c3e7ea8ed659582ea6