Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library MerkleProof    - function verify(bytes32[] memory proo ...    - function verifyCalldata(bytes32[] cal ...    - function processProof(bytes32[] memor ...    - function processProofCalldata(bytes32 ...    - function multiProofVerify(    - function multiProofVerifyCalldata(    - function processMultiProof(    - function processMultiProofCalldata(    - function _hashPair(bytes32 a, bytes32 ...    - function _efficientHash(bytes32 a, by ... library SafeMath    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b, st ...    - function div(uint256 a, uint256 b, st ...    - function mod(uint256 a, uint256 b, st ... interface IERC20Errors interface IERC721Errors interface IERC1155Errors    - function _msgSender()    - function _msgData()    - function _contextSuffixLength()    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... 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(address from, a ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - 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(address from, a ...    - function _transfer(address from, addr ...    - function _update(address from, addres ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _approve(address owner, addr ...    - function _spendAllowance(address owne ...  contract Shima is ERC20, Ownable *    - function remainingSupply()    - function currentPhase()    - function presalePrice()    - function publicSalePrice()    - function saleTotalSupply()    - function maxPerWallet()    - function setCurrentPhase(uint256 newP ...    - function setPresalePrice(uint256 newP ...    - function setPublicSalePrice(uint256 n ...    - function setSaleTotalSupply(uint256 n ...    - function setMaxPerWallet(uint256 newM ...    - function withdrawETH(address _address ...    - function withdrawTokens(address to)    - function setRoot(bytes32 _newRoot)    - function isValid(bytes32[] calldata _ ...    - function buy(uint256 _amount, bytes32 ...    - function airDropBatch(address[] memor ...    - function _update(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-02-20
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.24;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
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 v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @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}.
 *
 * 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.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => 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 returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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 `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` 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 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        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 `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` 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.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` 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.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}



pragma solidity ^0.8.24;



contract Shima is ERC20, Ownable {
    using SafeMath for uint256;
    uint256 constant private MAX_SUPPLY = 5000000000; 
    uint256 private _remainingSupply = MAX_SUPPLY;
    uint256 private _currentPhase = 0;
    uint256 private _presalePrice = 0.000000055 ether;
    uint256 private _publicSalePrice = 0.000000075 ether;
    uint256 private _saleTotalSupply = 1000000000;
    uint256 private _maxPerWallet = 4000000;
    uint256 private _totalTokensSold;
    bytes32 public root;

    constructor()
        ERC20("SHIMA", "SHIMA")
        Ownable(msg.sender)
    {
        _mint(address(this), MAX_SUPPLY.mul(10**decimals()));
        _remainingSupply = _remainingSupply.mul(10**decimals());
        _saleTotalSupply = _saleTotalSupply.mul(10**decimals());
        _maxPerWallet = _maxPerWallet.mul(10**decimals());
    }

    // -------------     GETTERS     -------------

    function remainingSupply() public view returns (uint256) {
        return _remainingSupply;
    }

    function currentPhase() public view returns (uint256) {
        return _currentPhase;
    }

    function presalePrice() public view returns (uint256) {
        return _presalePrice;
    }

    function publicSalePrice() public view returns (uint256) {
        return _publicSalePrice;
    }

    function saleTotalSupply() public view returns (uint256) {
        return _saleTotalSupply;
    }

    function maxPerWallet() public view returns (uint256){
        return _maxPerWallet;
    }
 
    // -------------     SETTERS     -------------
    /**
     * @notice Set phase for sale tokens.
     * @param newPhase Presale = 1 ; PublicSale = 2 ; Paused = 0 ;
     */
    function setCurrentPhase(uint256 newPhase) public onlyOwner {
        require(newPhase >= 0 && newPhase <= 2, "Phase must be greater or equal than 0 and less or equal than 2");
        _currentPhase = newPhase;
    }

    function setPresalePrice(uint256 newPrice) public onlyOwner {
        _presalePrice = newPrice;
    }

    function setPublicSalePrice(uint256 newPrice) public onlyOwner {
        _publicSalePrice = newPrice;
    }

    function setSaleTotalSupply(uint256 newSaleTotalSupply) public onlyOwner {
        _saleTotalSupply = newSaleTotalSupply.mul(10**decimals());
    }

    function setMaxPerWallet(uint256 newMaxPerWallet) public onlyOwner {
        _maxPerWallet = newMaxPerWallet.mul(10**decimals());
    }

    function withdrawETH(address _address) external onlyOwner {
        uint256 balance = address(this).balance;
        payable(_address).transfer(balance);
    }

    function withdrawTokens(address to) external onlyOwner {
        _transfer(address(this), to, _remainingSupply);
        _remainingSupply = 0;
    }

    function setRoot(bytes32 _newRoot) external onlyOwner {
        root = _newRoot;
    }

    function isValid(bytes32[] calldata _merkleProof) internal view returns (bool){
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(_merkleProof, root, leaf), "Address is not whitelisted!");
        return true;
    }

    function buy(uint256 _amount, bytes32[] calldata proofs) public payable {
        uint256 balance = balanceOf(msg.sender);
        uint256 requiredEth;
        uint256 amount = _amount.mul(10**decimals());

        require(_currentPhase != 0, "Buying not allowed at the moment");
        require(_totalTokensSold.add(amount) <= _saleTotalSupply, "Buy amount exceeds maximum allowed");
        require(balance.add(amount) <= _maxPerWallet,"Buy amount exceeds maximum per wallet");

        if (_currentPhase == 1) {
            require(isValid(proofs), "You're not whitelisted");
            requiredEth = _amount.mul (_presalePrice);
            require(msg.value == requiredEth, "Incorrect value");
        } else if (_currentPhase == 2) {
            requiredEth = _amount.mul(_publicSalePrice);
            require(msg.value == requiredEth, "Incorrect value");
        }
        _transfer(address(this), msg.sender, amount);
        _totalTokensSold+=amount;
        _remainingSupply-=amount;
    }

    function airDropBatch(address[] memory recipients, uint256[] memory amounts)
        external
        onlyOwner
    {
        require(
            recipients.length == amounts.length,
            "Mismatched array lengths"
        );

        for (uint256 i = 0; i < recipients.length; i++) {
            address to = recipients[i];
            uint256 amount = amounts[i].mul(10**decimals());

            _transfer(owner(), to, amount);
        }
    }

    function _update(
        address from,
        address to,
        uint256 value
    ) internal override(ERC20){
        super._update(from, to, value);
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"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":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airDropBatch","outputs":[],"stateMutability":"nonpayable","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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"proofs","type":"bytes32[]"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"currentPhase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"presalePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSalePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"saleTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPhase","type":"uint256"}],"name":"setCurrentPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxPerWallet","type":"uint256"}],"name":"setMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPresalePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPublicSalePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newRoot","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSaleTotalSupply","type":"uint256"}],"name":"setSaleTotalSupply","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":"value","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":"value","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"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

42850:4881:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43965:93;;;;;;;;;;-1:-1:-1;44037:13:0;;43965:93;;;160:25:1;;;148:2;133:18;43965:93:0;;;;;;;;43864;;;;;;;;;;-1:-1:-1;43936:13:0;;43864:93;;33484:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;35777:190::-;;;;;;;;;;-1:-1:-1;35777:190:0;;;;;:::i;:::-;;:::i;:::-;;;1351:14:1;;1344:22;1326:41;;1314:2;1299:18;35777:190:0;1186:187:1;44173:99:0;;;;;;;;;;-1:-1:-1;44248:16:0;;44173:99;;34586;;;;;;;;;;-1:-1:-1;34665:12:0;;34586:99;;36545:249;;;;;;;;;;-1:-1:-1;36545:249:0;;;;;:::i;:::-;;:::i;34437:84::-;;;;;;;;;;-1:-1:-1;34437:84:0;;34511:2;1853:36:1;;1841:2;1826:18;34437:84:0;1711:184:1;44789:103:0;;;;;;;;;;-1:-1:-1;44789:103:0;;;;;:::i;:::-;;:::i;:::-;;44280:92;;;;;;;;;;-1:-1:-1;44351:13:0;;44280:92;;45489:151;;;;;;;;;;-1:-1:-1;45489:151:0;;;;;:::i;:::-;;:::i;46020:1021::-;;;;;;:::i;:::-;;:::i;45319:162::-;;;;;;;;;;-1:-1:-1;45319:162:0;;;;;:::i;:::-;;:::i;34748:118::-;;;;;;;;;;-1:-1:-1;34748:118:0;;;;;:::i;:::-;-1:-1:-1;;;;;34840:18:0;34813:7;34840:18;;;;;;;;;;;;34748:118;27097:103;;;;;;;;;;;;;:::i;44900:109::-;;;;;;;;;;-1:-1:-1;44900:109:0;;;;;:::i;:::-;;:::i;44562:219::-;;;;;;;;;;-1:-1:-1;44562:219:0;;;;;:::i;:::-;;:::i;26422:87::-;;;;;;;;;;-1:-1:-1;26495:6:0;;26422:87;;-1:-1:-1;;;;;26495:6:0;;;3110:51:1;;3098:2;3083:18;26422:87:0;2964:203:1;47049:469:0;;;;;;;;;;-1:-1:-1;47049:469:0;;;;;:::i;:::-;;:::i;33694:95::-;;;;;;;;;;;;;:::i;44066:99::-;;;;;;;;;;-1:-1:-1;44141:16:0;;44066:99;;35071:182;;;;;;;;;;-1:-1:-1;35071:182:0;;;;;:::i;:::-;;:::i;45017:149::-;;;;;;;;;;-1:-1:-1;45017:149:0;;;;;:::i;:::-;;:::i;43757:99::-;;;;;;;;;;-1:-1:-1;43832:16:0;;43757:99;;45648:88;;;;;;;;;;-1:-1:-1;45648:88:0;;;;;:::i;:::-;;:::i;35316:142::-;;;;;;;;;;-1:-1:-1;35316:142:0;;;;;:::i;:::-;-1:-1:-1;;;;;35423:18:0;;;35396:7;35423:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;35316:142;45174:137;;;;;;;;;;-1:-1:-1;45174:137:0;;;;;:::i;:::-;;:::i;43323:19::-;;;;;;;;;;;;;;;;27355:220;;;;;;;;;;-1:-1:-1;27355:220:0;;;;;:::i;:::-;;:::i;33484:91::-;33529:13;33562:5;33555:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33484:91;:::o;35777:190::-;35850:4;24511:10;35906:31;24511:10;35922:7;35931:5;35906:8;:31::i;:::-;35955:4;35948:11;;;35777:190;;;;;:::o;36545:249::-;36632:4;24511:10;36690:37;36706:4;24511:10;36721:5;36690:15;:37::i;:::-;36738:26;36748:4;36754:2;36758:5;36738:9;:26::i;:::-;-1:-1:-1;36782:4:0;;36545:249;-1:-1:-1;;;;36545:249:0:o;44789:103::-;26308:13;:11;:13::i;:::-;44860::::1;:24:::0;44789:103::o;45489:151::-;26308:13;:11;:13::i;:::-;45555:46:::1;45573:4;45580:2;45584:16;;45555:9;:46::i;:::-;-1:-1:-1::0;45631:1:0::1;45612:16;:20:::0;45489:151::o;46020:1021::-;46131:10;46103:15;34840:18;;;;;;;;;;;;46103:15;46200:27;46212:14;34511:2;46212;:14;:::i;:::-;46200:7;;:11;:27::i;:::-;46183:44;;46248:13;;46265:1;46248:18;46240:63;;;;-1:-1:-1;;;46240:63:0;;8324:2:1;46240:63:0;;;8306:21:1;;;8343:18;;;8336:30;8402:34;8382:18;;;8375:62;8454:18;;46240:63:0;;;;;;;;;46354:16;;46322;;:28;;46343:6;46322:20;:28::i;:::-;:48;;46314:95;;;;-1:-1:-1;;;46314:95:0;;8685:2:1;46314:95:0;;;8667:21:1;8724:2;8704:18;;;8697:30;8763:34;8743:18;;;8736:62;-1:-1:-1;;;8814:18:1;;;8807:32;8856:19;;46314:95:0;8483:398:1;46314:95:0;46451:13;;46428:19;:7;46440:6;46428:11;:19::i;:::-;:36;;46420:85;;;;-1:-1:-1;;;46420:85:0;;9088:2:1;46420:85:0;;;9070:21:1;9127:2;9107:18;;;9100:30;9166:34;9146:18;;;9139:62;-1:-1:-1;;;9217:18:1;;;9210:35;9262:19;;46420:85:0;8886:401:1;46420:85:0;46522:13;;46539:1;46522:18;46518:391;;46565:15;46573:6;;46565:7;:15::i;:::-;46557:50;;;;-1:-1:-1;;;46557:50:0;;9494:2:1;46557:50:0;;;9476:21:1;9533:2;9513:18;;;9506:30;-1:-1:-1;;;9552:18:1;;;9545:52;9614:18;;46557:50:0;9292:346:1;46557:50:0;46649:13;;46636:27;;:7;;:11;:27::i;:::-;46622:41;;46699:11;46686:9;:24;46678:52;;;;-1:-1:-1;;;46678:52:0;;9845:2:1;46678:52:0;;;9827:21:1;9884:2;9864:18;;;9857:30;-1:-1:-1;;;9903:18:1;;;9896:45;9958:18;;46678:52:0;9643:339:1;46678:52:0;46518:391;;;46752:13;;46769:1;46752:18;46748:161;;46813:16;;46801:29;;:7;;:11;:29::i;:::-;46787:43;;46866:11;46853:9;:24;46845:52;;;;-1:-1:-1;;;46845:52:0;;9845:2:1;46845:52:0;;;9827:21:1;9884:2;9864:18;;;9857:30;-1:-1:-1;;;9903:18:1;;;9896:45;9958:18;;46845:52:0;9643:339:1;46845:52:0;46919:44;46937:4;46944:10;46956:6;46919:9;:44::i;:::-;46992:6;46974:16;;:24;;;;;;;:::i;:::-;;;;;;;;47027:6;47009:16;;:24;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;;46020:1021:0:o;45319:162::-;26308:13;:11;:13::i;:::-;45438:35:::1;::::0;45406:21:::1;::::0;-1:-1:-1;;;;;45438:26:0;::::1;::::0;:35;::::1;;;::::0;45406:21;;45388:15:::1;45438:35:::0;45388:15;45438:35;45406:21;45438:26;:35;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;45377:104;45319:162:::0;:::o;27097:103::-;26308:13;:11;:13::i;:::-;27162:30:::1;27189:1;27162:18;:30::i;:::-;27097:103::o:0;44900:109::-;26308:13;:11;:13::i;:::-;44974:16:::1;:27:::0;44900:109::o;44562:219::-;26308:13;:11;:13::i;:::-;44670:1:::1;44658:8;:13;;44633:105;;;::::0;-1:-1:-1;;;44633:105:0;;10452:2:1;44633:105:0::1;::::0;::::1;10434:21:1::0;10491:2;10471:18;;;10464:30;10530:34;10510:18;;;10503:62;10601:32;10581:18;;;10574:60;10651:19;;44633:105:0::1;10250:426:1::0;44633:105:0::1;44749:13;:24:::0;44562:219::o;47049:469::-;26308:13;:11;:13::i;:::-;47222:7:::1;:14;47201:10;:17;:35;47179:109;;;::::0;-1:-1:-1;;;47179:109:0;;10883:2:1;47179:109:0::1;::::0;::::1;10865:21:1::0;10922:2;10902:18;;;10895:30;10961:26;10941:18;;;10934:54;11005:18;;47179:109:0::1;10681:348:1::0;47179:109:0::1;47306:9;47301:210;47325:10;:17;47321:1;:21;47301:210;;;47364:10;47377;47388:1;47377:13;;;;;;;;:::i;:::-;;;;;;;47364:26;;47405:14;47422:30;47441:10;34511:2:::0;;34437:84;47441:10:::1;47437:14;::::0;:2:::1;:14;:::i;:::-;47422:7;47430:1;47422:10;;;;;;;;:::i;:::-;;;;;;;:14;;:30;;;;:::i;:::-;47405:47;;47469:30;47479:7;26495:6:::0;;-1:-1:-1;;;;;26495:6:0;;26422:87;47479:7:::1;47488:2;47492:6;47469:9;:30::i;:::-;-1:-1:-1::0;;47344:3:0::1;;47301:210;;33694:95:::0;33741:13;33774:7;33767:14;;;;;:::i;35071:182::-;35140:4;24511:10;35196:27;24511:10;35213:2;35217:5;35196:9;:27::i;45017:149::-;26308:13;:11;:13::i;:::-;45120:38:::1;34511:2:::0;45147:10:::1;45143:14;::::0;:2:::1;:14;:::i;:::-;45120:18:::0;;:22:::1;:38::i;:::-;45101:16;:57:::0;-1:-1:-1;45017:149:0:o;45648:88::-;26308:13;:11;:13::i;:::-;45713:4:::1;:15:::0;45648:88::o;45174:137::-;26308:13;:11;:13::i;:::-;45268:35:::1;34511:2:::0;45292:10:::1;34437:84:::0;45268:35:::1;45252:13;:51:::0;-1:-1:-1;45174:137:0:o;27355:220::-;26308:13;:11;:13::i;:::-;-1:-1:-1;;;;;27440:22:0;::::1;27436:93;;27486:31;::::0;-1:-1:-1;;;27486:31:0;;27514:1:::1;27486:31;::::0;::::1;3110:51:1::0;3083:18;;27486:31:0::1;2964:203:1::0;27436:93:0::1;27539:28;27558:8;27539:18;:28::i;:::-;27355:220:::0;:::o;40604:130::-;40689:37;40698:5;40705:7;40714:5;40721:4;40689:8;:37::i;42320:487::-;-1:-1:-1;;;;;35423:18:0;;;42420:24;35423:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;42487:37:0;;42483:317;;42564:5;42545:16;:24;42541:132;;;42597:60;;-1:-1:-1;;;42597:60:0;;-1:-1:-1;;;;;11386:32:1;;42597:60:0;;;11368:51:1;11435:18;;;11428:34;;;11478:18;;;11471:34;;;11341:18;;42597:60:0;11166:345:1;42541:132:0;42716:57;42725:5;42732:7;42760:5;42741:16;:24;42767:5;42716:8;:57::i;:::-;42409:398;42320:487;;;:::o;37179:308::-;-1:-1:-1;;;;;37263:18:0;;37259:88;;37305:30;;-1:-1:-1;;;37305:30:0;;37332:1;37305:30;;;3110:51:1;3083:18;;37305:30:0;2964:203:1;37259:88:0;-1:-1:-1;;;;;37361:16:0;;37357:88;;37401:32;;-1:-1:-1;;;37401:32:0;;37430:1;37401:32;;;3110:51:1;3083:18;;37401:32:0;2964:203:1;37357:88:0;37455:24;37463:4;37469:2;37473:5;37455:7;:24::i;26587:166::-;26495:6;;-1:-1:-1;;;;;26495:6:0;24511:10;26647:23;26643:103;;26694:40;;-1:-1:-1;;;26694:40:0;;24511:10;26694:40;;;3110:51:1;3083:18;;26694:40:0;2964:203:1;13681:98:0;13739:7;13766:5;13770:1;13766;:5;:::i;:::-;13759:12;13681:98;-1:-1:-1;;;13681:98:0:o;12943:::-;13001:7;13028:5;13032:1;13028;:5;:::i;45744:268::-;45858:28;;-1:-1:-1;;45875:10:0;11838:2:1;11834:15;11830:53;45858:28:0;;;11818:66:1;45817:4:0;;;;11900:12:1;;45858:28:0;;;;;;;;;;;;45848:39;;;;;;45833:54;;45906:44;45925:12;;45906:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45939:4:0;;;-1:-1:-1;45945:4:0;;-1:-1:-1;45906:18:0;:44::i;:::-;45898:84;;;;-1:-1:-1;;;45898:84:0;;12125:2:1;45898:84:0;;;12107:21:1;12164:2;12144:18;;;12137:30;12203:29;12183:18;;;12176:57;12250:18;;45898:84:0;11923:351:1;27735:191:0;27828:6;;;-1:-1:-1;;;;;27845:17:0;;;-1:-1:-1;;;;;;27845:17:0;;;;;;;27878:40;;27828:6;;;27845:17;27828:6;;27878:40;;27809:16;;27878:40;27798:128;27735:191;:::o;41585:443::-;-1:-1:-1;;;;;41698:19:0;;41694:91;;41741:32;;-1:-1:-1;;;41741:32:0;;41770:1;41741:32;;;3110:51:1;3083:18;;41741:32:0;2964:203:1;41694:91:0;-1:-1:-1;;;;;41799:21:0;;41795:92;;41844:31;;-1:-1:-1;;;41844:31:0;;41872:1;41844:31;;;3110:51:1;3083:18;;41844:31:0;2964:203:1;41795:92:0;-1:-1:-1;;;;;41897:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;41943:78;;;;41994:7;-1:-1:-1;;;;;41978:31:0;41987:5;-1:-1:-1;;;;;41978:31:0;;42003:5;41978:31;;;;160:25:1;;148:2;133:18;;14:177;41978:31:0;;;;;;;;41585:443;;;;:::o;47526:165::-;47653:30;47667:4;47673:2;47677:5;47653:13;:30::i;1369:156::-;1460:4;1513;1484:25;1497:5;1504:4;1484:12;:25::i;:::-;:33;;1369:156;-1:-1:-1;;;;1369:156:0:o;37811:1135::-;-1:-1:-1;;;;;37901:18:0;;37897:552;;38055:5;38039:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;37897:552:0;;-1:-1:-1;37897:552:0;;-1:-1:-1;;;;;38115:15:0;;38093:19;38115:15;;;;;;;;;;;38149:19;;;38145:117;;;38196:50;;-1:-1:-1;;;38196:50:0;;-1:-1:-1;;;;;11386:32:1;;38196:50:0;;;11368:51:1;11435:18;;;11428:34;;;11478:18;;;11471:34;;;11341:18;;38196:50:0;11166:345:1;38145:117:0;-1:-1:-1;;;;;38385:15:0;;:9;:15;;;;;;;;;;38403:19;;;;38385:37;;37897:552;-1:-1:-1;;;;;38465:16:0;;38461:435;;38631:12;:21;;;;;;;38461:435;;;-1:-1:-1;;;;;38847:13:0;;:9;:13;;;;;;;;;;:22;;;;;;38461:435;38928:2;-1:-1:-1;;;;;38913:25:0;38922:4;-1:-1:-1;;;;;38913:25:0;;38932:5;38913:25;;;;160::1;;148:2;133:18;;14:177;38913:25:0;;;;;;;;37811:1135;;;:::o;2088:296::-;2171:7;2214:4;2171:7;2229:118;2253:5;:12;2249:1;:16;2229:118;;;2302:33;2312:12;2326:5;2332:1;2326:8;;;;;;;;:::i;:::-;;;;;;;2302:9;:33::i;:::-;2287:48;-1:-1:-1;2267:3:0;;2229:118;;;-1:-1:-1;2364:12:0;2088:296;-1:-1:-1;;;2088:296:0:o;9518:149::-;9581:7;9612:1;9608;:5;:51;;9860:13;9954:15;;;9990:4;9983:15;;;10037:4;10021:21;;9608:51;;;9860:13;9954:15;;;9990:4;9983:15;;;10037:4;10021:21;;9616:20;9792:268;196:548:1;308:4;337:2;366;355:9;348:21;398:6;392:13;441:6;436:2;425:9;421:18;414:34;466:1;476:140;490:6;487:1;484:13;476:140;;;585:14;;;581:23;;575:30;551:17;;;570:2;547:26;540:66;505:10;;476:140;;;480:3;665:1;660:2;651:6;640:9;636:22;632:31;625:42;735:2;728;724:7;719:2;711:6;707:15;703:29;692:9;688:45;684:54;676:62;;;;196:548;;;;:::o;749:173::-;817:20;;-1:-1:-1;;;;;866:31:1;;856:42;;846:70;;912:1;909;902:12;846:70;749:173;;;:::o;927:254::-;995:6;1003;1056:2;1044:9;1035:7;1031:23;1027:32;1024:52;;;1072:1;1069;1062:12;1024:52;1095:29;1114:9;1095:29;:::i;:::-;1085:39;1171:2;1156:18;;;;1143:32;;-1:-1:-1;;;927:254:1:o;1378:328::-;1455:6;1463;1471;1524:2;1512:9;1503:7;1499:23;1495:32;1492:52;;;1540:1;1537;1530:12;1492:52;1563:29;1582:9;1563:29;:::i;:::-;1553:39;;1611:38;1645:2;1634:9;1630:18;1611:38;:::i;:::-;1601:48;;1696:2;1685:9;1681:18;1668:32;1658:42;;1378:328;;;;;:::o;1900:180::-;1959:6;2012:2;2000:9;1991:7;1987:23;1983:32;1980:52;;;2028:1;2025;2018:12;1980:52;-1:-1:-1;2051:23:1;;1900:180;-1:-1:-1;1900:180:1:o;2085:186::-;2144:6;2197:2;2185:9;2176:7;2172:23;2168:32;2165:52;;;2213:1;2210;2203:12;2165:52;2236:29;2255:9;2236:29;:::i;2276:683::-;2371:6;2379;2387;2440:2;2428:9;2419:7;2415:23;2411:32;2408:52;;;2456:1;2453;2446:12;2408:52;2492:9;2479:23;2469:33;;2553:2;2542:9;2538:18;2525:32;2576:18;2617:2;2609:6;2606:14;2603:34;;;2633:1;2630;2623:12;2603:34;2671:6;2660:9;2656:22;2646:32;;2716:7;2709:4;2705:2;2701:13;2697:27;2687:55;;2738:1;2735;2728:12;2687:55;2778:2;2765:16;2804:2;2796:6;2793:14;2790:34;;;2820:1;2817;2810:12;2790:34;2873:7;2868:2;2858:6;2855:1;2851:14;2847:2;2843:23;2839:32;2836:45;2833:65;;;2894:1;2891;2884:12;2833:65;2925:2;2921;2917:11;2907:21;;2947:6;2937:16;;;;;2276:683;;;;;:::o;3172:127::-;3233:10;3228:3;3224:20;3221:1;3214:31;3264:4;3261:1;3254:15;3288:4;3285:1;3278:15;3304:275;3375:2;3369:9;3440:2;3421:13;;-1:-1:-1;;3417:27:1;3405:40;;3475:18;3460:34;;3496:22;;;3457:62;3454:88;;;3522:18;;:::i;:::-;3558:2;3551:22;3304:275;;-1:-1:-1;3304:275:1:o;3584:183::-;3644:4;3677:18;3669:6;3666:30;3663:56;;;3699:18;;:::i;:::-;-1:-1:-1;3744:1:1;3740:14;3756:4;3736:25;;3584:183::o;3772:668::-;3826:5;3879:3;3872:4;3864:6;3860:17;3856:27;3846:55;;3897:1;3894;3887:12;3846:55;3933:6;3920:20;3959:4;3983:60;3999:43;4039:2;3999:43;:::i;:::-;3983:60;:::i;:::-;4065:3;4089:2;4084:3;4077:15;4117:4;4112:3;4108:14;4101:21;;4174:4;4168:2;4165:1;4161:10;4153:6;4149:23;4145:34;4131:48;;4202:3;4194:6;4191:15;4188:35;;;4219:1;4216;4209:12;4188:35;4255:4;4247:6;4243:17;4269:142;4285:6;4280:3;4277:15;4269:142;;;4351:17;;4339:30;;4389:12;;;;4302;;4269:142;;;-1:-1:-1;4429:5:1;3772:668;-1:-1:-1;;;;;;3772:668:1:o;4445:1146::-;4563:6;4571;4624:2;4612:9;4603:7;4599:23;4595:32;4592:52;;;4640:1;4637;4630:12;4592:52;4680:9;4667:23;4709:18;4750:2;4742:6;4739:14;4736:34;;;4766:1;4763;4756:12;4736:34;4804:6;4793:9;4789:22;4779:32;;4849:7;4842:4;4838:2;4834:13;4830:27;4820:55;;4871:1;4868;4861:12;4820:55;4907:2;4894:16;4929:4;4953:60;4969:43;5009:2;4969:43;:::i;4953:60::-;5047:15;;;5129:1;5125:10;;;;5117:19;;5113:28;;;5078:12;;;;5153:19;;;5150:39;;;5185:1;5182;5175:12;5150:39;5209:11;;;;5229:148;5245:6;5240:3;5237:15;5229:148;;;5311:23;5330:3;5311:23;:::i;:::-;5299:36;;5262:12;;;;5355;;;;5229:148;;;5396:5;-1:-1:-1;;5439:18:1;;5426:32;;-1:-1:-1;;5470:16:1;;;5467:36;;;5499:1;5496;5489:12;5467:36;;5522:63;5577:7;5566:8;5555:9;5551:24;5522:63;:::i;:::-;5512:73;;;4445:1146;;;;;:::o;5781:260::-;5849:6;5857;5910:2;5898:9;5889:7;5885:23;5881:32;5878:52;;;5926:1;5923;5916:12;5878:52;5949:29;5968:9;5949:29;:::i;:::-;5939:39;;5997:38;6031:2;6020:9;6016:18;5997:38;:::i;:::-;5987:48;;5781:260;;;;;:::o;6228:380::-;6307:1;6303:12;;;;6350;;;6371:61;;6425:4;6417:6;6413:17;6403:27;;6371:61;6478:2;6470:6;6467:14;6447:18;6444:38;6441:161;;6524:10;6519:3;6515:20;6512:1;6505:31;6559:4;6556:1;6549:15;6587:4;6584:1;6577:15;6441:161;;6228:380;;;:::o;6613:127::-;6674:10;6669:3;6665:20;6662:1;6655:31;6705:4;6702:1;6695:15;6729:4;6726:1;6719:15;6745:416;6834:1;6871:5;6834:1;6885:270;6906:7;6896:8;6893:21;6885:270;;;6965:4;6961:1;6957:6;6953:17;6947:4;6944:27;6941:53;;;6974:18;;:::i;:::-;7024:7;7014:8;7010:22;7007:55;;;7044:16;;;;7007:55;7123:22;;;;7083:15;;;;6885:270;;;6889:3;6745:416;;;;;:::o;7166:806::-;7215:5;7245:8;7235:80;;-1:-1:-1;7286:1:1;7300:5;;7235:80;7334:4;7324:76;;-1:-1:-1;7371:1:1;7385:5;;7324:76;7416:4;7434:1;7429:59;;;;7502:1;7497:130;;;;7409:218;;7429:59;7459:1;7450:10;;7473:5;;;7497:130;7534:3;7524:8;7521:17;7518:43;;;7541:18;;:::i;:::-;-1:-1:-1;;7597:1:1;7583:16;;7612:5;;7409:218;;7711:2;7701:8;7698:16;7692:3;7686:4;7683:13;7679:36;7673:2;7663:8;7660:16;7655:2;7649:4;7646:12;7642:35;7639:77;7636:159;;;-1:-1:-1;7748:19:1;;;7780:5;;7636:159;7827:34;7852:8;7846:4;7827:34;:::i;:::-;7897:6;7893:1;7889:6;7885:19;7876:7;7873:32;7870:58;;;7908:18;;:::i;:::-;7946:20;;7166:806;-1:-1:-1;;;7166:806:1:o;7977:140::-;8035:5;8064:47;8105:4;8095:8;8091:19;8085:4;8064:47;:::i;9987:125::-;10052:9;;;10073:10;;;10070:36;;;10086:18;;:::i;10117:128::-;10184:9;;;10205:11;;;10202:37;;;10219:18;;:::i;11034:127::-;11095:10;11090:3;11086:20;11083:1;11076:31;11126:4;11123:1;11116:15;11150:4;11147:1;11140:15;11516:168;11589:9;;;11620;;11637:15;;;11631:22;;11617:37;11607:71;;11658:18;;:::i

ipfs://feb34c74c8f9757b0b8f81a3f3633418ddd4a771c1c816e5ef440bd9a23eb84b