Token

Aifrenz (Aifrenz)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

891 Aifrenz

Holders

295

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xa2b069dcad258328082e30e2db0980a6ba5331d5

Filtered by Token Holder

0x53DfFa05086961935528A6094b5d8f6EE02B7284

0825pm.eth

Balance

2 Aifrenz

0x53dffa05086961935528a6094b5d8f6ee02b7284

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AiFrenz

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol

// █████╗ ██╗    ███████╗██████╗ ███████╗███╗   ██╗███████╗
//██╔══██╗██║    ██╔════╝██╔══██╗██╔════╝████╗  ██║╚══███╔╝
//███████║██║    █████╗  ██████╔╝█████╗  ██╔██╗ ██║  ███╔╝ 
//██╔══██║██║    ██╔══╝  ██╔══██╗██╔══╝  ██║╚██╗██║ ███╔╝  
//██║  ██║██║    ██║     ██║  ██║███████╗██║ ╚████║███████╗
//╚═╝  ╚═╝╚═╝    ╚═╝     ╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚══════╝
                                                         


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

// 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/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/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.6.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * 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.
 */
library MerkleProof {
    /**
     * @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 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.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = _efficientHash(computedHash, proofElement);
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = _efficientHash(proofElement, computedHash);
            }
        }
        return computedHash;
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// 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/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/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/utils/Address.sol


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


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

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;




/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(account, totalReceived, released(account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        uint256 payment = _pendingPayment(account, totalReceived, released(token, account));

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` 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 tokenId
    ) 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.
     * - `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 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: contracts/contract.sol


pragma solidity ^0.8.7;

/// @title Contract of your NFTs collection
/// @author AiFrenz


// █████╗ ██╗    ███████╗██████╗ ███████╗███╗   ██╗███████╗
//██╔══██╗██║    ██╔════╝██╔══██╗██╔════╝████╗  ██║╚══███╔╝
//███████║██║    █████╗  ██████╔╝█████╗  ██╔██╗ ██║  ███╔╝ 
//██╔══██║██║    ██╔══╝  ██╔══██╗██╔══╝  ██║╚██╗██║ ███╔╝  
//██║  ██║██║    ██║     ██║  ██║███████╗██║ ╚████║███████╗
//╚═╝  ╚═╝╚═╝    ╚═╝     ╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚══════╝
                                                         
contract AiFrenz is ERC721Enumerable, Ownable, ReentrancyGuard {

    //To increment the id of the NFTs
    using Counters for Counters.Counter;

    //To concatenate the URL of an NFT
    using Strings for uint256;

    //To check the addresses in the whitelist
    bytes32 public merkleRoot;

    //Id of the next NFT to mint
    Counters.Counter private _nftIdCounter;

    //Number of NFTs in the collection
    uint public constant MAX_SUPPLY = 10000;

     uint public constant FREE_SUPPLY = 3500;
    //Maximum number of NFTs an address can mint
    uint public max_mint_allowed = 3;
    //Price of one NFT in presale
    uint public pricePresale = 0.006 ether;
    //Price of one NFT in sale
    uint public priceSale = 0.00001 ether;

    //URI of the NFTs when revealed
    string public baseURI;
    //URI of the NFTs when not revealed
    string public notRevealedURI;
    //The extension of the file containing the Metadatas of the NFTs
    string public baseExtension = ".json";

    //Are the NFTs revealed yet ?
    bool public revealed = false;

    //Is the contract paused ?
    bool public paused = false;

    //The different stages of selling the collection
    enum Steps {
        Before,
        Freemint,
        Whitelist,
        Presale,
        Sale,
        SoldOut,
        Reveal
    }

    Steps public sellingStep;
    
    //Owner of the smart contract
    address private _owner;

    //Keep a track of the number of tokens per address
    mapping(address => uint) nftsPerWallet;
    
  mapping(address => bool) public isWhitelisted;
  mapping(address => uint) public tokensMintedByAddress;

    //Constructor of the collection
    constructor(string memory _theBaseURI, string memory _notRevealedURI, bytes32 _merkleRoot) ERC721("Aifrenz", "Aifrenz"){
        _nftIdCounter.increment();
        transferOwnership(msg.sender);
        sellingStep = Steps.Before;
        baseURI = _theBaseURI;
        notRevealedURI = _notRevealedURI;
        merkleRoot = _merkleRoot;
    }

    /**
    * @notice Edit the Merkle Root 
    *
    * @param _newMerkleRoot The new Merkle Root
    **/
    function changeMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
        merkleRoot = _newMerkleRoot;
    }

    /** 
    * @notice Set pause to true or false
    *
    * @param _paused True or false if you want the contract to be paused or not
    **/
    function setPaused(bool _paused) external onlyOwner {
        paused = _paused;
    }

    /** 
    * @notice Change the number of NFTs that an address can mint
    *
    * @param _maxMintAllowed The number of NFTs that an address can mint
    **/
    function changeMaxMintAllowed(uint _maxMintAllowed) external onlyOwner {
        max_mint_allowed = _maxMintAllowed;
    }

    /**
    * @notice Change the price of one NFT for the presale
    *
    * @param _pricePresale The new price of one NFT for the presale
    **/
    function changePricePresale(uint _pricePresale) external onlyOwner {
        pricePresale = _pricePresale;
    }

  
    /**
    * @notice Change the base URI
    *
    * @param _newBaseURI The new base URI
    **/
    function setBaseUri(string memory _newBaseURI) external onlyOwner {
        baseURI = _newBaseURI;
    }

    /**
    * @notice Change the not revealed URI
    *
    * @param _notRevealedURI The new not revealed URI
    **/
    function setNotRevealURI(string memory _notRevealedURI) external onlyOwner {
        notRevealedURI = _notRevealedURI;
    }

    /**
    * @notice Allows to set the revealed variable to true
    **/
    function reveal() external onlyOwner{
        revealed = true;
    }

    /**
    * @notice Return URI of the NFTs when revealed
    *
    * @return The URI of the NFTs when revealed
    **/
    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    /**
    * @notice Allows to change the base extension of the metadatas files
    *
    * @param _baseExtension the new extension of the metadatas files
    **/
    function setBaseExtension(string memory _baseExtension) external onlyOwner {
        baseExtension = _baseExtension;
    }

    function setUpWhitelistFreemint() external onlyOwner {
        sellingStep = Steps.Freemint;
    }

    function setUpPresale() external onlyOwner {
        sellingStep = Steps.Presale;
    }

  function WhitelistFreemint(uint256 _ammount) external payable nonReentrant {
        //Get the number of NFT sold
        uint numberNftSold = totalSupply();
        //Get the price of one NFT in Sale
        uint price = priceSale;
          //The user can only mint max 3 NFTs
        require(_ammount <= max_mint_allowed, "You can't mint more than 3 tokens");
        //If Sale didn't start yet
        require(sellingStep == Steps.Freemint, "Sorry, sale has not started yet.");
        //Did the user then enought Ethers to buy ammount NFTs ?
        require(msg.value >= price * _ammount, "Not enought funds.");
        //If the user try to mint any non-existent token
        require(numberNftSold + _ammount <= FREE_SUPPLY, "Freeminting is almost done and we don't have enought NFTs left.");
        //Add the ammount of NFTs minted by the user to the total he minted
        nftsPerWallet[msg.sender] += _ammount;
        //If this account minted the last NFTs available
        if(numberNftSold + _ammount == FREE_SUPPLY) {
            sellingStep = Steps.SoldOut;   
        }
        //Minting all the account NFTs
        for(uint i = 1 ; i <= _ammount ; i++) {
            _safeMint(msg.sender, numberNftSold + i);
        }
    }



    

    function PresaleMint(uint256 _ammount) external payable nonReentrant {
        //Get the number of NFT sold
        uint numberNftSold = totalSupply();
        //Get the price of one NFT in Sale
        uint price = pricePresale;
        //If everything has been bought
        require(sellingStep != Steps.SoldOut, "Sorry, no NFTs left.");
        //If Sale didn't start yet
        require(sellingStep == Steps.Presale, "Sorry, sale has not started yet.");
        //Did the user then enought Ethers to buy ammount NFTs ?
        require(msg.value >= price * _ammount, "Not enought funds.");
        //The user can only mint max 3 NFTs
        require(_ammount <= max_mint_allowed, "You can't mint more than 3 tokens");
        //If the user try to mint any non-existent token
        require(numberNftSold + FREE_SUPPLY + _ammount <= MAX_SUPPLY, "Sale is almost done and we don't have enought NFTs left.");
        //Add the ammount of NFTs minted by the user to the total he minted
        nftsPerWallet[msg.sender] += _ammount;
        //If this account minted the last NFTs available
        if(numberNftSold + FREE_SUPPLY + _ammount <= MAX_SUPPLY) {
            sellingStep = Steps.SoldOut;   
        }
        //Minting all the account NFTs
        for(uint i = 1 ; i <= _ammount ; i++) {
            _safeMint(msg.sender, numberNftSold + i);
        }
    }

    

 

    /**
    * @notice Return true or false if the account is whitelisted or not
    *
    * @param account The account of the user
    * @param proof The Merkle Proof
    *
    * @return true or false if the account is whitelisted or not
    **/
    function isWhiteListed(address account, bytes32[] calldata proof) internal view returns(bool) {
        return _verify(_leaf(account), proof);
    }


 function whitelist(address[] calldata _users) public onlyOwner {
      for (uint i = 0; i < _users.length; i++) {
          isWhitelisted[_users[i]] = true;
      }
  }
  
  function unWhitelist(address[] calldata _users) public onlyOwner {
     for(uint i = 0; i < _users.length; i++) {
          isWhitelisted[_users[i]] = false;
     }
  }


    /**
    * @notice Return the account hashed
    *
    * @param account The account to hash
    *
    * @return The account hashed
    **/
    function _leaf(address account) internal pure returns(bytes32) {
        return keccak256(abi.encodePacked(account));
    }

    /** 
    * @notice Returns true if a leaf can be proved to be a part of a Merkle tree defined by root
    *
    * @param leaf The leaf
    * @param proof The Merkle Proof
    *
    * @return True if a leaf can be provded to be a part of a Merkle tree defined by root
    **/
    function _verify(bytes32 leaf, bytes32[] memory proof) internal view returns(bool) {
        return MerkleProof.verify(proof, merkleRoot, leaf);
    }

    /**
    * @notice Allows to get the complete URI of a specific NFT by his ID
    *
    * @param _nftId The id of the NFT
    *
    * @return The token URI of the NFT which has _nftId Id
    **/
    function tokenURI(uint _nftId) public view override(ERC721) returns (string memory) {
        require(_exists(_nftId), "This NFT doesn't exist.");
        if(revealed == false) {
            return notRevealedURI;
        }
        
        string memory currentBaseURI = _baseURI();
        return 
            bytes(currentBaseURI).length > 0 
            ? string(abi.encodePacked(currentBaseURI, _nftId.toString(), baseExtension))
            : "";
    }

      function withdraw() public payable onlyOwner {
    (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
    require(success, "Withdrawal of funds failed");
  }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_theBaseURI","type":"string"},{"internalType":"string","name":"_notRevealedURI","type":"string"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"FREE_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ammount","type":"uint256"}],"name":"PresaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ammount","type":"uint256"}],"name":"WhitelistFreemint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintAllowed","type":"uint256"}],"name":"changeMaxMintAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newMerkleRoot","type":"bytes32"}],"name":"changeMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pricePresale","type":"uint256"}],"name":"changePricePresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"max_mint_allowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePresale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceSale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellingStep","outputs":[{"internalType":"enum AiFrenz.Steps","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setUpPresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setUpWhitelistFreemint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nftId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensMintedByAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_users","type":"address[]"}],"name":"unWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_users","type":"address[]"}],"name":"whitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c07d960b1ac6067884ece85e537090642c9c9882160000000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d50724e74593475704b6d5564586f6f6b566d6b71435a4e7a5257424263596e445731704172596f5a7757736b2f000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d50724e74593475704b6d5564586f6f6b566d6b71435a4e7a5257424263596e445731704172596f5a7757736b2f00000000000000000000

-----Decoded View---------------
Arg [0] : _theBaseURI (string): ipfs://QmPrNtY4upKmUdXookVmkqCZNzRWBBcYnDW1pArYoZwWsk/
Arg [1] : _notRevealedURI (string): ipfs://QmPrNtY4upKmUdXookVmkqCZNzRWBBcYnDW1pArYoZwWsk/
Arg [2] : _merkleRoot (bytes32): 0x7d960b1ac6067884ece85e537090642c9c988216000000000000000000000000

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 7d960b1ac6067884ece85e537090642c9c988216000000000000000000000000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [4] : 697066733a2f2f516d50724e74593475704b6d5564586f6f6b566d6b71435a4e
Arg [5] : 7a5257424263596e445731704172596f5a7757736b2f00000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [7] : 697066733a2f2f516d50724e74593475704b6d5564586f6f6b566d6b71435a4e
Arg [8] : 7a5257424263596e445731704172596f5a7757736b2f00000000000000000000

Deployed Bytecode Sourcemap

69000:9596:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61745:224;;;;;;;;;;-1:-1:-1;61745:224:0;;;;;:::i;:::-;;:::i;:::-;;;7975:14:1;;7968:22;7950:41;;7938:2;7923:18;61745:224:0;;;;;;;;48564:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;50124:221::-;;;;;;;;;;-1:-1:-1;50124:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;7273:32:1;;;7255:51;;7243:2;7228:18;50124:221:0;7109:203:1;49647:411:0;;;;;;;;;;-1:-1:-1;49647:411:0;;;;;:::i;:::-;;:::i;:::-;;73423:89;;;;;;;;;;;;;:::i;71471:87::-;;;;;;;;;;-1:-1:-1;71471:87:0;;;;;:::i;:::-;;:::i;73518:1266::-;;;;;;:::i;:::-;;:::i;62385:113::-;;;;;;;;;;-1:-1:-1;62473:10:0;:17;62385:113;;;8148:25:1;;;8136:2;8121:18;62385:113:0;8002:177:1;50874:339:0;;;;;;;;;;-1:-1:-1;50874:339:0;;;;;:::i;:::-;;:::i;69276:25::-;;;;;;;;;;;;;;;;62053:256;;;;;;;;;;-1:-1:-1;62053:256:0;;;;;:::i;:::-;;:::i;69431:39::-;;;;;;;;;;;;69465:5;69431:39;;70581:45;;;;;;;;;;-1:-1:-1;70581:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;78403:188;;;:::i;72017:114::-;;;;;;;;;;-1:-1:-1;72017:114:0;;;;;:::i;:::-;;:::i;51284:185::-;;;;;;;;;;-1:-1:-1;51284:185:0;;;;;:::i;:::-;;:::i;73315:100::-;;;;;;;;;;;;;:::i;62575:233::-;;;;;;;;;;-1:-1:-1;62575:233:0;;;;;:::i;:::-;;:::i;70065:28::-;;;;;;;;;;-1:-1:-1;70065:28:0;;;;;;;;71732:124;;;;;;;;;;-1:-1:-1;71732:124:0;;;;;:::i;:::-;;:::i;72483:126::-;;;;;;;;;;-1:-1:-1;72483:126:0;;;;;:::i;:::-;;:::i;70134:26::-;;;;;;;;;;-1:-1:-1;70134:26:0;;;;;;;;;;;70631:53;;;;;;;;;;-1:-1:-1;70631:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;48258:239;;;;;;;;;;-1:-1:-1;48258:239:0;;;;;:::i;:::-;;:::i;69810:21::-;;;;;;;;;;;;;:::i;47988:208::-;;;;;;;;;;-1:-1:-1;47988:208:0;;;;;:::i;:::-;;:::i;15526:103::-;;;;;;;;;;;;;:::i;69879:28::-;;;;;;;;;;;;;:::i;69727:37::-;;;;;;;;;;;;;;;;14875:87;;;;;;;;;;-1:-1:-1;14948:6:0;;-1:-1:-1;;;;;14948:6:0;14875:87;;69650:38;;;;;;;;;;;;;;;;48733:104;;;;;;;;;;;;;:::i;69480:39::-;;;;;;;;;;;;69515:4;69480:39;;72246:106;;;;;;;;;;-1:-1:-1;72246:106:0;;;;;:::i;:::-;;:::i;50417:155::-;;;;;;;;;;-1:-1:-1;50417:155:0;;;;;:::i;:::-;;:::i;72694:70::-;;;;;;;;;;;;;:::i;74804:1392::-;;;;;;:::i;:::-;;:::i;51540:328::-;;;;;;;;;;-1:-1:-1;51540:328:0;;;;;:::i;:::-;;:::i;69576:32::-;;;;;;;;;;;;;;;;76628:172;;;;;;;;;;-1:-1:-1;76628:172:0;;;;;:::i;:::-;;:::i;69984:37::-;;;;;;;;;;;;;:::i;77924:469::-;;;;;;;;;;-1:-1:-1;77924:469:0;;;;;:::i;:::-;;:::i;70373:24::-;;;;;;;;;;-1:-1:-1;70373:24:0;;;;;;;;;;;;;;;;;;:::i;73183:124::-;;;;;;;;;;-1:-1:-1;73183:124:0;;;;;:::i;:::-;;:::i;50643:164::-;;;;;;;;;;-1:-1:-1;50643:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;50764:25:0;;;50740:4;50764:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;50643:164;71199:115;;;;;;;;;;-1:-1:-1;71199:115:0;;;;;:::i;:::-;;:::i;15784:201::-;;;;;;;;;;-1:-1:-1;15784:201:0;;;;;:::i;:::-;;:::i;76808:172::-;;;;;;;;;;-1:-1:-1;76808:172:0;;;;;:::i;:::-;;:::i;61745:224::-;61847:4;-1:-1:-1;;;;;;61871:50:0;;-1:-1:-1;;;61871:50:0;;:90;;;61925:36;61949:11;61925:23;:36::i;:::-;61864:97;61745:224;-1:-1:-1;;61745:224:0:o;48564:100::-;48618:13;48651:5;48644:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48564:100;:::o;50124:221::-;50200:7;53467:16;;;:7;:16;;;;;;-1:-1:-1;;;;;53467:16:0;50220:73;;;;-1:-1:-1;;;50220:73:0;;15219:2:1;50220:73:0;;;15201:21:1;15258:2;15238:18;;;15231:30;15297:34;15277:18;;;15270:62;-1:-1:-1;;;15348:18:1;;;15341:42;15400:19;;50220:73:0;;;;;;;;;-1:-1:-1;50313:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;50313:24:0;;50124:221::o;49647:411::-;49728:13;49744:23;49759:7;49744:14;:23::i;:::-;49728:39;;49792:5;-1:-1:-1;;;;;49786:11:0;:2;-1:-1:-1;;;;;49786:11:0;;;49778:57;;;;-1:-1:-1;;;49778:57:0;;17169:2:1;49778:57:0;;;17151:21:1;17208:2;17188:18;;;17181:30;17247:34;17227:18;;;17220:62;-1:-1:-1;;;17298:18:1;;;17291:31;17339:19;;49778:57:0;16967:397:1;49778:57:0;13679:10;-1:-1:-1;;;;;49870:21:0;;;;:62;;-1:-1:-1;49895:37:0;49912:5;13679:10;50643:164;:::i;49895:37::-;49848:168;;;;-1:-1:-1;;;49848:168:0;;13612:2:1;49848:168:0;;;13594:21:1;13651:2;13631:18;;;13624:30;13690:34;13670:18;;;13663:62;13761:26;13741:18;;;13734:54;13805:19;;49848:168:0;13410:420:1;49848:168:0;50029:21;50038:2;50042:7;50029:8;:21::i;:::-;49717:341;49647:411;;:::o;73423:89::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;73477:11:::1;:27:::0;;73491:13:::1;::::0;73477:11;-1:-1:-1;;73477:27:0::1;::::0;73491:13;73477:27:::1;;;;;;73423:89::o:0;71471:87::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;71534:6:::1;:16:::0;;;::::1;;;;-1:-1:-1::0;;71534:16:0;;::::1;::::0;;;::::1;::::0;;71471:87::o;73518:1266::-;2820:1;3418:7;;:19;;3410:63;;;;-1:-1:-1;;;3410:63:0;;18402:2:1;3410:63:0;;;18384:21:1;18441:2;18421:18;;;18414:30;18480:33;18460:18;;;18453:61;18531:18;;3410:63:0;18200:355:1;3410:63:0;2820:1;3551:7;:18;73642::::1;73663:13;62473:10:::0;:17;;62385:113;73663:13:::1;73744:9;::::0;73831:16:::1;::::0;73642:34;;-1:-1:-1;73744:9:0;73819:28;::::1;;73811:74;;;;-1:-1:-1::0;;;73811:74:0::1;;;;;;;:::i;:::-;73955:14;73940:11;::::0;;;::::1;;;:29;::::0;::::1;;;;;;:::i;:::-;;73932:74;;;::::0;-1:-1:-1;;;73932:74:0;;18762:2:1;73932:74:0::1;::::0;::::1;18744:21:1::0;;;18781:18;;;18774:30;18840:34;18820:18;;;18813:62;18892:18;;73932:74:0::1;18560:356:1::0;73932:74:0::1;74104:16;74112:8:::0;74104:5;:16:::1;:::i;:::-;74091:9;:29;;74083:60;;;::::0;-1:-1:-1;;;74083:60:0;;8953:2:1;74083:60:0::1;::::0;::::1;8935:21:1::0;8992:2;8972:18;;;8965:30;-1:-1:-1;;;9011:18:1;;;9004:48;9069:18;;74083:60:0::1;8751:342:1::0;74083:60:0::1;69515:4;74220:24;74236:8:::0;74220:13;:24:::1;:::i;:::-;:39;;74212:115;;;::::0;-1:-1:-1;;;74212:115:0;;11653:2:1;74212:115:0::1;::::0;::::1;11635:21:1::0;11692:2;11672:18;;;11665:30;11731:34;11711:18;;;11704:62;11802:33;11782:18;;;11775:61;11853:19;;74212:115:0::1;11451:427:1::0;74212:115:0::1;74429:10;74415:25;::::0;;;:13:::1;:25;::::0;;;;:37;;74444:8;;74415:25;:37:::1;::::0;74444:8;;74415:37:::1;:::i;:::-;::::0;;;-1:-1:-1;69515:4:0::1;::::0;-1:-1:-1;74524:24:0::1;74540:8:::0;74524:13;:24:::1;:::i;:::-;:39;74521:101;;;74580:11;:27:::0;;-1:-1:-1;;74580:27:0::1;::::0;::::1;::::0;;74521:101:::1;74685:1;74672:105;74694:8;74689:1;:13;74672:105;;74725:40;74735:10;74747:17;74763:1:::0;74747:13;:17:::1;:::i;:::-;74725:9;:40::i;:::-;74705:3:::0;::::1;::::0;::::1;:::i;:::-;;;;74672:105;;;-1:-1:-1::0;;2776:1:0;3730:7;:22;-1:-1:-1;;73518:1266:0:o;50874:339::-;51069:41;13679:10;51102:7;51069:18;:41::i;:::-;51061:103;;;;-1:-1:-1;;;51061:103:0;;;;;;;:::i;:::-;51177:28;51187:4;51193:2;51197:7;51177:9;:28::i;62053:256::-;62150:7;62186:23;62203:5;62186:16;:23::i;:::-;62178:5;:31;62170:87;;;;-1:-1:-1;;;62170:87:0;;9300:2:1;62170:87:0;;;9282:21:1;9339:2;9319:18;;;9312:30;9378:34;9358:18;;;9351:62;-1:-1:-1;;;9429:18:1;;;9422:41;9480:19;;62170:87:0;9098:407:1;62170:87:0;-1:-1:-1;;;;;;62275:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;62053:256::o;78403:188::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;78474:58:::1;::::0;78456:12:::1;::::0;78482:10:::1;::::0;78506:21:::1;::::0;78456:12;78474:58;78456:12;78474:58;78506:21;78482:10;78474:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78455:77;;;78547:7;78539:46;;;::::0;-1:-1:-1;;;78539:46:0;;12844:2:1;78539:46:0::1;::::0;::::1;12826:21:1::0;12883:2;12863:18;;;12856:30;12922:28;12902:18;;;12895:56;12968:18;;78539:46:0::1;12642:350:1::0;78539:46:0::1;78448:143;78403:188::o:0;72017:114::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;72095:12:::1;:28:::0;72017:114::o;51284:185::-;51422:39;51439:4;51445:2;51449:7;51422:39;;;;;;;;;;;;:16;:39::i;73315:100::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;73379:11:::1;:28:::0;;73393:14:::1;::::0;73379:11;-1:-1:-1;;73379:28:0::1;::::0;73393:14;73379:28:::1;::::0;62575:233;62650:7;62686:30;62473:10;:17;;62385:113;62686:30;62678:5;:38;62670:95;;;;-1:-1:-1;;;62670:95:0;;17989:2:1;62670:95:0;;;17971:21:1;18028:2;18008:18;;;18001:30;18067:34;18047:18;;;18040:62;-1:-1:-1;;;18118:18:1;;;18111:42;18170:19;;62670:95:0;17787:408:1;62670:95:0;62783:10;62794:5;62783:17;;;;;;;;:::i;:::-;;;;;;;;;62776:24;;62575:233;;;:::o;71732:124::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;71814:16:::1;:34:::0;71732:124::o;72483:126::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;72569:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;:::-;;72483:126:::0;:::o;48258:239::-;48330:7;48366:16;;;:7;:16;;;;;;-1:-1:-1;;;;;48366:16:0;48401:19;48393:73;;;;-1:-1:-1;;;48393:73:0;;14448:2:1;48393:73:0;;;14430:21:1;14487:2;14467:18;;;14460:30;14526:34;14506:18;;;14499:62;-1:-1:-1;;;14577:18:1;;;14570:39;14626:19;;48393:73:0;14246:405:1;69810:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;47988:208::-;48060:7;-1:-1:-1;;;;;48088:19:0;;48080:74;;;;-1:-1:-1;;;48080:74:0;;14037:2:1;48080:74:0;;;14019:21:1;14076:2;14056:18;;;14049:30;14115:34;14095:18;;;14088:62;-1:-1:-1;;;14166:18:1;;;14159:40;14216:19;;48080:74:0;13835:406:1;48080:74:0;-1:-1:-1;;;;;;48172:16:0;;;;;:9;:16;;;;;;;47988:208::o;15526:103::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;15591:30:::1;15618:1;15591:18;:30::i;:::-;15526:103::o:0;69879:28::-;;;;;;;:::i;48733:104::-;48789:13;48822:7;48815:14;;;;;:::i;72246:106::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;72323:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;50417:155::-:0;50512:52;13679:10;50545:8;50555;50512:18;:52::i;72694:70::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;72741:8:::1;:15:::0;;-1:-1:-1;;72741:15:0::1;72752:4;72741:15;::::0;;72694:70::o;74804:1392::-;2820:1;3418:7;;:19;;3410:63;;;;-1:-1:-1;;;3410:63:0;;18402:2:1;3410:63:0;;;18384:21:1;18441:2;18421:18;;;18414:30;18480:33;18460:18;;;18453:61;18531:18;;3410:63:0;18200:355:1;3410:63:0;2820:1;3551:7;:18;74922::::1;74943:13;62473:10:::0;:17;;62385:113;74943:13:::1;75024:12;::::0;74922:34;;-1:-1:-1;75111:13:0::1;75096:11;::::0;;;::::1;;;:28;::::0;::::1;;;;;;:::i;:::-;;;75088:61;;;::::0;-1:-1:-1;;;75088:61:0;;15632:2:1;75088:61:0::1;::::0;::::1;15614:21:1::0;15671:2;15651:18;;;15644:30;-1:-1:-1;;;15690:18:1;;;15683:50;15750:18;;75088:61:0::1;15430:344:1::0;75088:61:0::1;75219:13;75204:11;::::0;;;::::1;;;:28;::::0;::::1;;;;;;:::i;:::-;;75196:73;;;::::0;-1:-1:-1;;;75196:73:0;;18762:2:1;75196:73:0::1;::::0;::::1;18744:21:1::0;;;18781:18;;;18774:30;18840:34;18820:18;;;18813:62;18892:18;;75196:73:0::1;18560:356:1::0;75196:73:0::1;75367:16;75375:8:::0;75367:5;:16:::1;:::i;:::-;75354:9;:29;;75346:60;;;::::0;-1:-1:-1;;;75346:60:0;;8953:2:1;75346:60:0::1;::::0;::::1;8935:21:1::0;8992:2;8972:18;;;8965:30;-1:-1:-1;;;9011:18:1;;;9004:48;9069:18;;75346:60:0::1;8751:342:1::0;75346:60:0::1;75482:16;;75470:8;:28;;75462:74;;;;-1:-1:-1::0;;;75462:74:0::1;;;;;;;:::i;:::-;69465:5;75643:8:::0;75613:27:::1;69515:4;75613:13:::0;:27:::1;:::i;:::-;:38;;;;:::i;:::-;:52;;75605:121;;;::::0;-1:-1:-1;;;75605:121:0;;15981:2:1;75605:121:0::1;::::0;::::1;15963:21:1::0;16020:2;16000:18;;;15993:30;16059:34;16039:18;;;16032:62;16130:26;16110:18;;;16103:54;16174:19;;75605:121:0::1;15779:420:1::0;75605:121:0::1;75828:10;75814:25;::::0;;;:13:::1;:25;::::0;;;;:37;;75843:8;;75814:25;:37:::1;::::0;75843:8;;75814:37:::1;:::i;:::-;::::0;;;-1:-1:-1;69465:5:0::1;::::0;-1:-1:-1;75953:8:0;75923:27:::1;69515:4;75923:13:::0;:27:::1;:::i;:::-;:38;;;;:::i;:::-;:52;75920:114;;75992:11;:27:::0;;-1:-1:-1;;75992:27:0::1;::::0;::::1;::::0;;75920:114:::1;76097:1;76084:105;76106:8;76101:1;:13;76084:105;;76137:40;76147:10;76159:17;76175:1:::0;76159:13;:17:::1;:::i;76137:40::-;76117:3:::0;::::1;::::0;::::1;:::i;:::-;;;;76084:105;;51540:328:::0;51715:41;13679:10;51748:7;51715:18;:41::i;:::-;51707:103;;;;-1:-1:-1;;;51707:103:0;;;;;;;:::i;:::-;51821:39;51835:4;51841:2;51845:7;51854:5;51821:13;:39::i;:::-;51540:328;;;;:::o;76628:172::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;76705:6:::1;76700:95;76717:17:::0;;::::1;76700:95;;;76781:4;76754:13;:24;76768:6;;76775:1;76768:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;76754:24:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;76754:24:0;:31;;-1:-1:-1;;76754:31:0::1;::::0;::::1;;::::0;;;::::1;::::0;;76736:3;::::1;::::0;::::1;:::i;:::-;;;;76700:95;;69984:37:::0;;;;;;;:::i;77924:469::-;53443:4;53467:16;;;:7;:16;;;;;;77993:13;;-1:-1:-1;;;;;53467:16:0;78019:51;;;;-1:-1:-1;;;78019:51:0;;10538:2:1;78019:51:0;;;10520:21:1;10577:2;10557:18;;;10550:30;10616:25;10596:18;;;10589:53;10659:18;;78019:51:0;10336:347:1;78019:51:0;78084:8;;;;78081:70;;78125:14;78118:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77924:469;;;:::o;78081:70::-;78171:28;78202:10;:8;:10::i;:::-;78171:41;;78275:1;78250:14;78244:28;:32;:141;;;;;;;;;;;;;;;;;78317:14;78333:17;:6;:15;:17::i;:::-;78352:13;78300:66;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78244:141;78223:162;77924:469;-1:-1:-1;;;77924:469:0:o;73183:124::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;73269:30;;::::1;::::0;:13:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;71199:115::-:0;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;71279:10:::1;:27:::0;71199:115::o;15784:201::-;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;15873:22:0;::::1;15865:73;;;::::0;-1:-1:-1;;;15865:73:0;;10131:2:1;15865:73:0::1;::::0;::::1;10113:21:1::0;10170:2;10150:18;;;10143:30;10209:34;10189:18;;;10182:62;-1:-1:-1;;;10260:18:1;;;10253:36;10306:19;;15865:73:0::1;9929:402:1::0;15865:73:0::1;15949:28;15968:8;15949:18;:28::i;76808:172::-:0;14948:6;;-1:-1:-1;;;;;14948:6:0;13679:10;15095:23;15087:68;;;;-1:-1:-1;;;15087:68:0;;;;;;;:::i;:::-;76885:6:::1;76881:94;76897:17:::0;;::::1;76881:94;;;76961:5;76934:13;:24;76948:6;;76955:1;76948:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;76934:24:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;76934:24:0;:32;;-1:-1:-1;;76934:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;76916:3;::::1;::::0;::::1;:::i;:::-;;;;76881:94;;7640:127:::0;7729:19;;7747:1;7729:19;;;7640:127::o;47619:305::-;47721:4;-1:-1:-1;;;;;;47758:40:0;;-1:-1:-1;;;47758:40:0;;:105;;-1:-1:-1;;;;;;;47815:48:0;;-1:-1:-1;;;47815:48:0;47758:105;:158;;;-1:-1:-1;;;;;;;;;;39387:40:0;;;47880:36;39278:157;57524:174;57599:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;57599:29:0;-1:-1:-1;;;;;57599:29:0;;;;;;;;:24;;57653:23;57599:24;57653:14;:23::i;:::-;-1:-1:-1;;;;;57644:46:0;;;;;;;;;;;57524:174;;:::o;54362:110::-;54438:26;54448:2;54452:7;54438:26;;;;;;;;;;;;:9;:26::i;53672:348::-;53765:4;53467:16;;;:7;:16;;;;;;-1:-1:-1;;;;;53467:16:0;53782:73;;;;-1:-1:-1;;;53782:73:0;;13199:2:1;53782:73:0;;;13181:21:1;13238:2;13218:18;;;13211:30;13277:34;13257:18;;;13250:62;-1:-1:-1;;;13328:18:1;;;13321:42;13380:19;;53782:73:0;12997:408:1;53782:73:0;53866:13;53882:23;53897:7;53882:14;:23::i;:::-;53866:39;;53935:5;-1:-1:-1;;;;;53924:16:0;:7;-1:-1:-1;;;;;53924:16:0;;:52;;;-1:-1:-1;;;;;;50764:25:0;;;50740:4;50764:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;53944:32;53924:87;;;;54004:7;-1:-1:-1;;;;;53980:31:0;:20;53992:7;53980:11;:20::i;:::-;-1:-1:-1;;;;;53980:31:0;;53924:87;53916:96;53672:348;-1:-1:-1;;;;53672:348:0:o;56781:625::-;56940:4;-1:-1:-1;;;;;56913:31:0;:23;56928:7;56913:14;:23::i;:::-;-1:-1:-1;;;;;56913:31:0;;56905:81;;;;-1:-1:-1;;;56905:81:0;;10890:2:1;56905:81:0;;;10872:21:1;10929:2;10909:18;;;10902:30;10968:34;10948:18;;;10941:62;-1:-1:-1;;;11019:18:1;;;11012:35;11064:19;;56905:81:0;10688:401:1;56905:81:0;-1:-1:-1;;;;;57005:16:0;;56997:65;;;;-1:-1:-1;;;56997:65:0;;12085:2:1;56997:65:0;;;12067:21:1;12124:2;12104:18;;;12097:30;12163:34;12143:18;;;12136:62;-1:-1:-1;;;12214:18:1;;;12207:34;12258:19;;56997:65:0;11883:400:1;56997:65:0;57075:39;57096:4;57102:2;57106:7;57075:20;:39::i;:::-;57179:29;57196:1;57200:7;57179:8;:29::i;:::-;-1:-1:-1;;;;;57221:15:0;;;;;;:9;:15;;;;;:20;;57240:1;;57221:15;:20;;57240:1;;57221:20;:::i;:::-;;;;-1:-1:-1;;;;;;;57252:13:0;;;;;;:9;:13;;;;;:18;;57269:1;;57252:13;:18;;57269:1;;57252:18;:::i;:::-;;;;-1:-1:-1;;57281:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;57281:21:0;-1:-1:-1;;;;;57281:21:0;;;;;;;;;57320:27;;57281:16;;57320:27;;;;;;;49717:341;49647:411;;:::o;16145:191::-;16238:6;;;-1:-1:-1;;;;;16255:17:0;;;-1:-1:-1;;;;;;16255:17:0;;;;;;;16288:40;;16238:6;;;16255:17;16238:6;;16288:40;;16219:16;;16288:40;16208:128;16145:191;:::o;57840:315::-;57995:8;-1:-1:-1;;;;;57986:17:0;:5;-1:-1:-1;;;;;57986:17:0;;;57978:55;;;;-1:-1:-1;;;57978:55:0;;12490:2:1;57978:55:0;;;12472:21:1;12529:2;12509:18;;;12502:30;12568:27;12548:18;;;12541:55;12613:18;;57978:55:0;12288:349:1;57978:55:0;-1:-1:-1;;;;;58044:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;58044:46:0;;;;;;;;;;58106:41;;7950::1;;;58106::0;;7923:18:1;58106:41:0;;;;;;;57840:315;;;:::o;52750:::-;52907:28;52917:4;52923:2;52927:7;52907:9;:28::i;:::-;52954:48;52977:4;52983:2;52987:7;52996:5;52954:22;:48::i;:::-;52946:111;;;;-1:-1:-1;;;52946:111:0;;;;;;;:::i;72898:108::-;72958:13;72991:7;72984:14;;;;;:::i;11161:723::-;11217:13;11438:10;11434:53;;-1:-1:-1;;11465:10:0;;;;;;;;;;;;-1:-1:-1;;;11465:10:0;;;;;11161:723::o;11434:53::-;11512:5;11497:12;11553:78;11560:9;;11553:78;;11586:8;;;;:::i;:::-;;-1:-1:-1;11609:10:0;;-1:-1:-1;11617:2:0;11609:10;;:::i;:::-;;;11553:78;;;11641:19;11673:6;11663:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11663:17:0;;11641:39;;11691:154;11698:10;;11691:154;;11725:11;11735:1;11725:11;;:::i;:::-;;-1:-1:-1;11794:10:0;11802:2;11794:5;:10;:::i;:::-;11781:24;;:2;:24;:::i;:::-;11768:39;;11751:6;11758;11751:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;11751:56:0;;;;;;;;-1:-1:-1;11822:11:0;11831:2;11822:11;;:::i;:::-;;;11691:154;;54699:321;54829:18;54835:2;54839:7;54829:5;:18::i;:::-;54880:54;54911:1;54915:2;54919:7;54928:5;54880:22;:54::i;:::-;54858:154;;;;-1:-1:-1;;;54858:154:0;;;;;;;:::i;63421:589::-;-1:-1:-1;;;;;63627:18:0;;63623:187;;63662:40;63694:7;64837:10;:17;;64810:24;;;;:15;:24;;;;;:44;;;64865:24;;;;;;;;;;;;64733:164;63662:40;63623:187;;;63732:2;-1:-1:-1;;;;;63724:10:0;:4;-1:-1:-1;;;;;63724:10:0;;63720:90;;63751:47;63784:4;63790:7;63751:32;:47::i;:::-;-1:-1:-1;;;;;63824:16:0;;63820:183;;63857:45;63894:7;63857:36;:45::i;63820:183::-;63930:4;-1:-1:-1;;;;;63924:10:0;:2;-1:-1:-1;;;;;63924:10:0;;63920:83;;63951:40;63979:2;63983:7;63951:27;:40::i;58720:799::-;58875:4;-1:-1:-1;;;;;58896:13:0;;17871:19;:23;58892:620;;58932:72;;-1:-1:-1;;;58932:72:0;;-1:-1:-1;;;;;58932:36:0;;;;;:72;;13679:10;;58983:4;;58989:7;;58998:5;;58932:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58932:72:0;;;;;;;;-1:-1:-1;;58932:72:0;;;;;;;;;;;;:::i;:::-;;;58928:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59174:13:0;;59170:272;;59217:60;;-1:-1:-1;;;59217:60:0;;;;;;;:::i;59170:272::-;59392:6;59386:13;59377:6;59373:2;59369:15;59362:38;58928:529;-1:-1:-1;;;;;;59055:51:0;-1:-1:-1;;;59055:51:0;;-1:-1:-1;59048:58:0;;58892:620;-1:-1:-1;59496:4:0;58720:799;;;;;;:::o;55356:439::-;-1:-1:-1;;;;;55436:16:0;;55428:61;;;;-1:-1:-1;;;55428:61:0;;14858:2:1;55428:61:0;;;14840:21:1;;;14877:18;;;14870:30;14936:34;14916:18;;;14909:62;14988:18;;55428:61:0;14656:356:1;55428:61:0;53443:4;53467:16;;;:7;:16;;;;;;-1:-1:-1;;;;;53467:16:0;:30;55500:58;;;;-1:-1:-1;;;55500:58:0;;11296:2:1;55500:58:0;;;11278:21:1;11335:2;11315:18;;;11308:30;11374;11354:18;;;11347:58;11422:18;;55500:58:0;11094:352:1;55500:58:0;55571:45;55600:1;55604:2;55608:7;55571:20;:45::i;:::-;-1:-1:-1;;;;;55629:13:0;;;;;;:9;:13;;;;;:18;;55646:1;;55629:13;:18;;55646:1;;55629:18;:::i;:::-;;;;-1:-1:-1;;55658:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;55658:21:0;-1:-1:-1;;;;;55658:21:0;;;;;;;;55697:33;;55658:16;;;55697:33;;55658:16;;55697:33;72569:32:::1;72483:126:::0;:::o;65524:988::-;65790:22;65840:1;65815:22;65832:4;65815:16;:22::i;:::-;:26;;;;:::i;:::-;65852:18;65873:26;;;:17;:26;;;;;;65790:51;;-1:-1:-1;66006:28:0;;;66002:328;;-1:-1:-1;;;;;66073:18:0;;66051:19;66073:18;;;:12;:18;;;;;;;;:34;;;;;;;;;66124:30;;;;;;:44;;;66241:30;;:17;:30;;;;;:43;;;66002:328;-1:-1:-1;66426:26:0;;;;:17;:26;;;;;;;;66419:33;;;-1:-1:-1;;;;;66470:18:0;;;;;:12;:18;;;;;:34;;;;;;;66463:41;65524:988::o;66807:1079::-;67085:10;:17;67060:22;;67085:21;;67105:1;;67085:21;:::i;:::-;67117:18;67138:24;;;:15;:24;;;;;;67511:10;:26;;67060:46;;-1:-1:-1;67138:24:0;;67060:46;;67511:26;;;;;;:::i;:::-;;;;;;;;;67489:48;;67575:11;67550:10;67561;67550:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;67655:28;;;:15;:28;;;;;;;:41;;;67827:24;;;;;67820:31;67862:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;66878:1008;;;66807:1079;:::o;64311:221::-;64396:14;64413:20;64430:2;64413:16;:20::i;:::-;-1:-1:-1;;;;;64444:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;64489:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;64311:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;747:70;650:173;;;:::o;828:160::-;893:20;;949:13;;942:21;932:32;;922:60;;978:1;975;968:12;993:186;1052:6;1105:2;1093:9;1084:7;1080:23;1076:32;1073:52;;;1121:1;1118;1111:12;1073:52;1144:29;1163:9;1144:29;:::i;1184:260::-;1252:6;1260;1313:2;1301:9;1292:7;1288:23;1284:32;1281:52;;;1329:1;1326;1319:12;1281:52;1352:29;1371:9;1352:29;:::i;:::-;1342:39;;1400:38;1434:2;1423:9;1419:18;1400:38;:::i;:::-;1390:48;;1184:260;;;;;:::o;1449:328::-;1526:6;1534;1542;1595:2;1583:9;1574:7;1570:23;1566:32;1563:52;;;1611:1;1608;1601:12;1563:52;1634:29;1653:9;1634:29;:::i;:::-;1624:39;;1682:38;1716:2;1705:9;1701:18;1682:38;:::i;:::-;1672:48;;1767:2;1756:9;1752:18;1739:32;1729:42;;1449:328;;;;;:::o;1782:666::-;1877:6;1885;1893;1901;1954:3;1942:9;1933:7;1929:23;1925:33;1922:53;;;1971:1;1968;1961:12;1922:53;1994:29;2013:9;1994:29;:::i;:::-;1984:39;;2042:38;2076:2;2065:9;2061:18;2042:38;:::i;:::-;2032:48;;2127:2;2116:9;2112:18;2099:32;2089:42;;2182:2;2171:9;2167:18;2154:32;2209:18;2201:6;2198:30;2195:50;;;2241:1;2238;2231:12;2195:50;2264:22;;2317:4;2309:13;;2305:27;-1:-1:-1;2295:55:1;;2346:1;2343;2336:12;2295:55;2369:73;2434:7;2429:2;2416:16;2411:2;2407;2403:11;2369:73;:::i;:::-;2359:83;;;1782:666;;;;;;;:::o;2453:254::-;2518:6;2526;2579:2;2567:9;2558:7;2554:23;2550:32;2547:52;;;2595:1;2592;2585:12;2547:52;2618:29;2637:9;2618:29;:::i;:::-;2608:39;;2666:35;2697:2;2686:9;2682:18;2666:35;:::i;2712:254::-;2780:6;2788;2841:2;2829:9;2820:7;2816:23;2812:32;2809:52;;;2857:1;2854;2847:12;2809:52;2880:29;2899:9;2880:29;:::i;:::-;2870:39;2956:2;2941:18;;;;2928:32;;-1:-1:-1;;;2712:254:1:o;2971:615::-;3057:6;3065;3118:2;3106:9;3097:7;3093:23;3089:32;3086:52;;;3134:1;3131;3124:12;3086:52;3174:9;3161:23;3203:18;3244:2;3236:6;3233:14;3230:34;;;3260:1;3257;3250:12;3230:34;3298:6;3287:9;3283:22;3273:32;;3343:7;3336:4;3332:2;3328:13;3324:27;3314:55;;3365:1;3362;3355:12;3314:55;3405:2;3392:16;3431:2;3423:6;3420:14;3417:34;;;3447:1;3444;3437:12;3417:34;3500:7;3495:2;3485:6;3482:1;3478:14;3474:2;3470:23;3466:32;3463:45;3460:65;;;3521:1;3518;3511:12;3460:65;3552:2;3544:11;;;;;3574:6;;-1:-1:-1;2971:615:1;;-1:-1:-1;;;;2971:615:1:o;3591:180::-;3647:6;3700:2;3688:9;3679:7;3675:23;3671:32;3668:52;;;3716:1;3713;3706:12;3668:52;3739:26;3755:9;3739:26;:::i;3776:180::-;3835:6;3888:2;3876:9;3867:7;3863:23;3859:32;3856:52;;;3904:1;3901;3894:12;3856:52;-1:-1:-1;3927:23:1;;3776:180;-1:-1:-1;3776:180:1:o;3961:245::-;4019:6;4072:2;4060:9;4051:7;4047:23;4043:32;4040:52;;;4088:1;4085;4078:12;4040:52;4127:9;4114:23;4146:30;4170:5;4146:30;:::i;4211:249::-;4280:6;4333:2;4321:9;4312:7;4308:23;4304:32;4301:52;;;4349:1;4346;4339:12;4301:52;4381:9;4375:16;4400:30;4424:5;4400:30;:::i;4465:450::-;4534:6;4587:2;4575:9;4566:7;4562:23;4558:32;4555:52;;;4603:1;4600;4593:12;4555:52;4643:9;4630:23;4676:18;4668:6;4665:30;4662:50;;;4708:1;4705;4698:12;4662:50;4731:22;;4784:4;4776:13;;4772:27;-1:-1:-1;4762:55:1;;4813:1;4810;4803:12;4762:55;4836:73;4901:7;4896:2;4883:16;4878:2;4874;4870:11;4836:73;:::i;5105:257::-;5146:3;5184:5;5178:12;5211:6;5206:3;5199:19;5227:63;5283:6;5276:4;5271:3;5267:14;5260:4;5253:5;5249:16;5227:63;:::i;:::-;5344:2;5323:15;-1:-1:-1;;5319:29:1;5310:39;;;;5351:4;5306:50;;5105:257;-1:-1:-1;;5105:257:1:o;5367:1527::-;5591:3;5629:6;5623:13;5655:4;5668:51;5712:6;5707:3;5702:2;5694:6;5690:15;5668:51;:::i;:::-;5782:13;;5741:16;;;;5804:55;5782:13;5741:16;5826:15;;;5804:55;:::i;:::-;5948:13;;5881:20;;;5921:1;;6008;6030:18;;;;6083;;;;6110:93;;6188:4;6178:8;6174:19;6162:31;;6110:93;6251:2;6241:8;6238:16;6218:18;6215:40;6212:167;;;-1:-1:-1;;;6278:33:1;;6334:4;6331:1;6324:15;6364:4;6285:3;6352:17;6212:167;6395:18;6422:110;;;;6546:1;6541:328;;;;6388:481;;6422:110;-1:-1:-1;;6457:24:1;;6443:39;;6502:20;;;;-1:-1:-1;6422:110:1;;6541:328;19176:1;19169:14;;;19213:4;19200:18;;6636:1;6650:169;6664:8;6661:1;6658:15;6650:169;;;6746:14;;6731:13;;;6724:37;6789:16;;;;6681:10;;6650:169;;;6654:3;;6850:8;6843:5;6839:20;6832:27;;6388:481;-1:-1:-1;6885:3:1;;5367:1527;-1:-1:-1;;;;;;;;;;;5367:1527:1:o;7317:488::-;-1:-1:-1;;;;;7586:15:1;;;7568:34;;7638:15;;7633:2;7618:18;;7611:43;7685:2;7670:18;;7663:34;;;7733:3;7728:2;7713:18;;7706:31;;;7511:4;;7754:45;;7779:19;;7771:6;7754:45;:::i;:::-;7746:53;7317:488;-1:-1:-1;;;;;;7317:488:1:o;8184:338::-;8326:2;8311:18;;8359:1;8348:13;;8338:144;;8404:10;8399:3;8395:20;8392:1;8385:31;8439:4;8436:1;8429:15;8467:4;8464:1;8457:15;8338:144;8491:25;;;8184:338;:::o;8527:219::-;8676:2;8665:9;8658:21;8639:4;8696:44;8736:2;8725:9;8721:18;8713:6;8696:44;:::i;9510:414::-;9712:2;9694:21;;;9751:2;9731:18;;;9724:30;9790:34;9785:2;9770:18;;9763:62;-1:-1:-1;;;9856:2:1;9841:18;;9834:48;9914:3;9899:19;;9510:414::o;16204:356::-;16406:2;16388:21;;;16425:18;;;16418:30;16484:34;16479:2;16464:18;;16457:62;16551:2;16536:18;;16204:356::o;16565:397::-;16767:2;16749:21;;;16806:2;16786:18;;;16779:30;16845:34;16840:2;16825:18;;16818:62;-1:-1:-1;;;16911:2:1;16896:18;;16889:31;16952:3;16937:19;;16565:397::o;17369:413::-;17571:2;17553:21;;;17610:2;17590:18;;;17583:30;17649:34;17644:2;17629:18;;17622:62;-1:-1:-1;;;17715:2:1;17700:18;;17693:47;17772:3;17757:19;;17369:413::o;19229:128::-;19269:3;19300:1;19296:6;19293:1;19290:13;19287:39;;;19306:18;;:::i;:::-;-1:-1:-1;19342:9:1;;19229:128::o;19362:120::-;19402:1;19428;19418:35;;19433:18;;:::i;:::-;-1:-1:-1;19467:9:1;;19362:120::o;19487:168::-;19527:7;19593:1;19589;19585:6;19581:14;19578:1;19575:21;19570:1;19563:9;19556:17;19552:45;19549:71;;;19600:18;;:::i;:::-;-1:-1:-1;19640:9:1;;19487:168::o;19660:125::-;19700:4;19728:1;19725;19722:8;19719:34;;;19733:18;;:::i;:::-;-1:-1:-1;19770:9:1;;19660:125::o;19790:258::-;19862:1;19872:113;19886:6;19883:1;19880:13;19872:113;;;19962:11;;;19956:18;19943:11;;;19936:39;19908:2;19901:10;19872:113;;;20003:6;20000:1;19997:13;19994:48;;;-1:-1:-1;;20038:1:1;20020:16;;20013:27;19790:258::o;20053:380::-;20132:1;20128:12;;;;20175;;;20196:61;;20250:4;20242:6;20238:17;20228:27;;20196:61;20303:2;20295:6;20292:14;20272:18;20269:38;20266:161;;;20349:10;20344:3;20340:20;20337:1;20330:31;20384:4;20381:1;20374:15;20412:4;20409:1;20402:15;20266:161;;20053:380;;;:::o;20438:135::-;20477:3;-1:-1:-1;;20498:17:1;;20495:43;;;20518:18;;:::i;:::-;-1:-1:-1;20565:1:1;20554:13;;20438:135::o;20578:112::-;20610:1;20636;20626:35;;20641:18;;:::i;:::-;-1:-1:-1;20675:9:1;;20578:112::o;20695:127::-;20756:10;20751:3;20747:20;20744:1;20737:31;20787:4;20784:1;20777:15;20811:4;20808:1;20801:15;20827:127;20888:10;20883:3;20879:20;20876:1;20869:31;20919:4;20916:1;20909:15;20943:4;20940:1;20933:15;20959:127;21020:10;21015:3;21011:20;21008:1;21001:31;21051:4;21048:1;21041:15;21075:4;21072:1;21065:15;21091:127;21152:10;21147:3;21143:20;21140:1;21133:31;21183:4;21180:1;21173:15;21207:4;21204:1;21197:15;21223:127;21284:10;21279:3;21275:20;21272:1;21265:31;21315:4;21312:1;21305:15;21339:4;21336:1;21329:15;21355:127;21416:10;21411:3;21407:20;21404:1;21397:31;21447:4;21444:1;21437:15;21471:4;21468:1;21461:15;21487:131;-1:-1:-1;;;;;;21561:32:1;;21551:43;;21541:71;;21608:1;21605;21598:12

Swarm Source

ipfs://db30f64f0c67864fd59b7bdf8a01ed2720222f7392f1eb2ae94df572eb804e7c

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services