Token

BirdverseNFT (BIRD)

ERC-721

Overview

Max Total Supply

1,054 BIRD

Holders

422

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x58a692e1a244299e8b4cd4760bd2c255d07a43b8

Filtered by Token Holder

0xD75BB0903549a600609260c50B78D343F4Ef65dd

Balance

1 BIRD

0xd75bb0903549a600609260c50b78d343f4ef65dd

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

BirdverseNFT

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-07-10
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/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/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`, 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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


// File: @openzeppelin/contracts/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 tokenId);

    /**
     * @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/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/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/Address.sol



pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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/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/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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

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


// File: @openzeppelin/contracts/token/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 overriden 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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_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 || getApproved(tokenId) == spender || isApprovedForAll(owner, 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);
    }

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

    /**
     * @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 of token that is not own");
        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);
    }

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

// File: @openzeppelin/contracts/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: @openzeppelin/contracts/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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree 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 Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _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++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

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

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

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

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

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

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

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

// OpenZeppelin Contracts (last updated v4.7.0) (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));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `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 Getter for the amount of payee's releasable Ether.
     */
    function releasable(address account) public view returns (uint256) {
        uint256 totalReceived = address(this).balance + totalReleased();
        return _pendingPayment(account, totalReceived, released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(IERC20 token, address account) public view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        return _pendingPayment(account, totalReceived, released(token, account));
    }

    /**
     * @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 payment = releasable(account);

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

        // _totalReleased is the sum of all values in _released.
        // If "_totalReleased += payment" does not overflow, then "_released[account] += payment" cannot overflow.
        _totalReleased += payment;
        unchecked {
            _released[account] += 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 payment = releasable(token, account);

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

        // _erc20TotalReleased[token] is the sum of all values in _erc20Released[token].
        // If "_erc20TotalReleased[token] += payment" does not overflow, then "_erc20Released[token][account] += payment"
        // cannot overflow.
        _erc20TotalReleased[token] += payment;
        unchecked {
            _erc20Released[token][account] += 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_);
    }
}

pragma solidity >=0.7.0 <0.9.0;

contract BirdverseNFT is ERC721Enumerable, Ownable, PaymentSplitter {
  using Strings for uint256;

  string baseURI;
  uint256 public cost = 0.0099 ether;
  uint256 public maxSupply = 10000;
  uint256 public maxFree = 1000;
  bool public paused;
  bytes32 public merkleRoot;
  
  enum Step {
    Before,
    WhitelistSale,
    PublicSale,
    SoldOut,
    Reveal
  }

  mapping(address => uint256) amountNFTperWalletWhitelistSale;

  uint256 private maxPerAddressDuringWhitelistMint = 1;

    uint256 private _teamLength;

    address[] private _team = [
        0x02a5ca3d79525CccD46b063bB4E95D2C1561F422
    ];

    uint256[] private _teamShares = [1000];

  Step public sellingStep;
  constructor(
    string memory _name,
    string memory _symbol,
    string memory _baseURI,
    bytes32 _merkleRoot
  ) ERC721(_name, _symbol) PaymentSplitter(_team, _teamShares) {
    baseURI = _baseURI;
    merkleRoot = _merkleRoot;
    _teamLength = _team.length;
  }

  // public
  function mint(uint256 _mintAmount) public payable {
    require(!paused);
    require(sellingStep == Step.PublicSale, "Public sale is not running");
    require(_mintAmount > 0);
    uint supply = totalSupply();
    require(supply + _mintAmount <= maxSupply);

    if (msg.sender != owner()) {
        if(supply > maxFree) {
            require(msg.value >= cost * _mintAmount);
        }
    }

    for (uint256 i = 1; i <= _mintAmount; i++) {
      _safeMint(msg.sender, supply + i);
    }
  }

  function whitelistMint(uint _mintAmount, bytes32[] calldata _proof) public payable {
    require(!paused);
    require(sellingStep == Step.WhitelistSale, "Whitelist sale is not running");
    require(isWhitelisted(msg.sender, _proof));
    require(_mintAmount > 0);
    require(
            amountNFTperWalletWhitelistSale[msg.sender] + _mintAmount <=
                maxPerAddressDuringWhitelistMint,
            "You can only get 1 NFT on the whitelist sale"
        );
    uint supply = totalSupply();
    require(supply + _mintAmount <= 1000);

    if (msg.sender != owner()) {
        if(supply > maxFree) {
            require(msg.value >= cost * _mintAmount);
        }
    }

    amountNFTperWalletWhitelistSale[msg.sender] += _mintAmount;
    for (uint256 i = 1; i <= _mintAmount; i++) {
      _safeMint(msg.sender, supply + i);
    }
  }

  function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
  {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
      tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
  }

    /**
     * @notice Get the token URI of an NFT by his ID
     *
     * @param _tokenId The ID of the NFT you want to have the URI of the metadatas
     *
     * @return string Token URI of an NFT by his ID
     */
    function tokenURI(uint256 _tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(_tokenId), "URI query for nonexistent token");

        return string(abi.encodePacked(baseURI, _tokenId.toString(), ".json"));
    }
  
  function setCost(uint256 _newCost) public onlyOwner {
    cost = _newCost;
  }

  function setMaxWhitelistMint(uint256 _maxPerAddressDuringWhitelistMint) public onlyOwner {
    maxPerAddressDuringWhitelistMint = _maxPerAddressDuringWhitelistMint;
  }

  function setBaseURI(string memory _newBaseURI) public onlyOwner {
    baseURI = _newBaseURI;
  }
  function pause(bool _state) public onlyOwner {
    paused = _state;
  }

      /**
     * @notice Change the step of the sale
     *
     * @param _step The new step of the sale
     */
    function setStep(uint256 _step) external onlyOwner {
        sellingStep = Step(_step);
    }

      /**
     * @notice Change the merkle root
     *
     * @param _merkleRoot The new merkle root
     */
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    /**
     * @notice Hash an address
     *
     * @param _account The address to be hashed
     *
     * @return bytes32 The hashed address
     */
    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 bool return true if a leaf can be proved to be a part of a merkle tree defined by root, false othewise
     */
    function _verify(bytes32 _leaf, bytes32[] memory _proof)
        internal
        view
        returns (bool)
    {
        return MerkleProof.verify(_proof, merkleRoot, _leaf);
    }

    /**
     * @notice Check if an address is whitelisted or not
     *
     * @param _account The account checked
     * @param _proof The Merkle Proof
     *
     * @return bool return true if an address is whitelisted, false otherwise
     */
    function isWhitelisted(address _account, bytes32[] calldata _proof)
        internal
        view
        returns (bool)
    {
        return _verify(leaf(_account), _proof);
    }

    function setMaxFree(uint _maxfree) external onlyOwner {
        maxFree = _maxfree;
    }

        /**
     * @notice Release the gains on every accounts
     */
    function releaseAll() external {
        for (uint256 i = 0; i < _teamLength; i++) {
            release(payable(payee(i)));
        }
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_baseURI","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":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","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":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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":[{"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":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"maxFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaseAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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 BirdverseNFT.Step","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":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxfree","type":"uint256"}],"name":"setMaxFree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxPerAddressDuringWhitelistMint","type":"uint256"}],"name":"setMaxWhitelistMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_step","type":"uint256"}],"name":"setStep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","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":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100f0a750e7900ba503f90016cd417b6ca9f37b89d95c0f91eda19e5e2c56948508000000000000000000000000000000000000000000000000000000000000000c4269726476657273654e4654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044249524400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d5770694c4e385472506546517935544132666a6b4434525a7662474a55686f344b7779695775536a6e4548532f000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): BirdverseNFT
Arg [1] : _symbol (string): BIRD
Arg [2] : _baseURI (string): https://gateway.pinata.cloud/ipfs/QmWpiLN8TrPeFQy5TA2fjkD4RZvbGJUho4KwyiWuSjnEHS/
Arg [3] : _merkleRoot (bytes32): 0xf0a750e7900ba503f90016cd417b6ca9f37b89d95c0f91eda19e5e2c56948508

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : f0a750e7900ba503f90016cd417b6ca9f37b89d95c0f91eda19e5e2c56948508
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [5] : 4269726476657273654e46540000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 4249524400000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [9] : 68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066
Arg [10] : 732f516d5770694c4e385472506546517935544132666a6b4434525a7662474a
Arg [11] : 55686f344b7779695775536a6e4548532f000000000000000000000000000000

Deployed Bytecode Sourcemap

69762:5776:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64377:40;20163:10;64377:40;;;-1:-1:-1;;;;;9915:32:1;;;9897:51;;64407:9:0;9979:2:1;9964:18;;9957:34;9870:18;64377:40:0;;;;;;;69762:5776;;;;;34662:224;;;;;;;;;;-1:-1:-1;34662:224:0;;;;;:::i;:::-;;:::i;:::-;;;11587:14:1;;11580:22;11562:41;;11550:2;11535:18;34662:224:0;;;;;;;;73429:73;;;;;;;;;;-1:-1:-1;73429:73:0;;;;;:::i;:::-;;:::i;:::-;;22554:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;24113:221::-;;;;;;;;;;-1:-1:-1;24113:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9671:32:1;;;9653:51;;9641:2;9626:18;24113:221:0;9507:203:1;23636:411:0;;;;;;;;;;-1:-1:-1;23636:411:0;;;;;:::i;:::-;;:::i;69886:34::-;;;;;;;;;;;;;;;;;;;11760:25:1;;;11748:2;11733:18;69886:34:0;11614:177:1;35302:113:0;;;;;;;;;;-1:-1:-1;35390:10:0;:17;35302:113;;66898:671;;;;;;;;;;-1:-1:-1;66898:671:0;;;;;:::i;:::-;;:::i;25003:339::-;;;;;;;;;;-1:-1:-1;25003:339:0;;;;;:::i;:::-;;:::i;70019:25::-;;;;;;;;;;;;;;;;34970:256;;;;;;;;;;-1:-1:-1;34970:256:0;;;;;:::i;:::-;;:::i;64508:91::-;;;;;;;;;;-1:-1:-1;64579:12:0;;64508:91;;65637:135;;;;;;;;;;-1:-1:-1;65637:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;65734:21:0;;;65707:7;65734:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;65637:135;25413:185;;;;;;;;;;-1:-1:-1;25413:185:0;;;;;:::i;:::-;;:::i;72174:348::-;;;;;;;;;;-1:-1:-1;72174:348:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;73065:80::-;;;;;;;;;;-1:-1:-1;73065:80:0;;;;;:::i;:::-;;:::i;69962:29::-;;;;;;;;;;;;;;;;67837:792;;;;;;;;;;-1:-1:-1;67837:792:0;;;;;:::i;:::-;;:::i;35492:233::-;;;;;;;;;;-1:-1:-1;35492:233:0;;;;;:::i;:::-;;:::i;73327:98::-;;;;;;;;;;-1:-1:-1;73327:98:0;;;;;:::i;:::-;;:::i;75391:144::-;;;;;;;;;;;;;:::i;69996:18::-;;;;;;;;;;-1:-1:-1;69996:18:0;;;;;;;;22248:239;;;;;;;;;;-1:-1:-1;22248:239:0;;;;;:::i;:::-;;:::i;21978:208::-;;;;;;;;;;-1:-1:-1;21978:208:0;;;;;:::i;:::-;;:::i;42451:94::-;;;;;;;;;;;;;:::i;73151:170::-;;;;;;;;;;-1:-1:-1;73151:170:0;;;;;:::i;:::-;;:::i;73845:106::-;;;;;;;;;;-1:-1:-1;73845:106:0;;;;;:::i;:::-;;:::i;65863:100::-;;;;;;;;;;-1:-1:-1;65863:100:0;;;;;:::i;:::-;;:::i;41800:87::-;;;;;;;;;;-1:-1:-1;41873:6:0;;-1:-1:-1;;;;;41873:6:0;41800:87;;22723:104;;;;;;;;;;;;;:::i;65359:109::-;;;;;;;;;;-1:-1:-1;65359:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;65442:18:0;65415:7;65442:18;;;:9;:18;;;;;;;65359:109;70781:511;;;;;;:::i;:::-;;:::i;24406:295::-;;;;;;;;;;-1:-1:-1;24406:295:0;;;;;:::i;:::-;;:::i;66053:225::-;;;;;;;;;;-1:-1:-1;66053:225:0;;;;;:::i;:::-;;:::i;25669:328::-;;;;;;;;;;-1:-1:-1;25669:328:0;;;;;:::i;:::-;;:::i;66438:260::-;;;;;;;;;;-1:-1:-1;66438:260:0;;;;;:::i;:::-;;:::i;72755:302::-;;;;;;;;;;-1:-1:-1;72755:302:0;;;;;:::i;:::-;;:::i;70454:23::-;;;;;;;;;;-1:-1:-1;70454:23:0;;;;;;;;;;;;;;;:::i;65155:105::-;;;;;;;;;;-1:-1:-1;65155:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;65236:16:0;65209:7;65236:16;;;:7;:16;;;;;;;65155:105;71298:870;;;;;;:::i;:::-;;:::i;69925:32::-;;;;;;;;;;;;;;;;75218:91;;;;;;;;;;-1:-1:-1;75218:91:0;;;;;:::i;:::-;;:::i;64945:119::-;;;;;;;;;;-1:-1:-1;64945:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;65030:26:0;65003:7;65030:26;;;:19;:26;;;;;;;64945:119;64693:95;;;;;;;;;;-1:-1:-1;64766:14:0;;64693:95;;24772:164;;;;;;;;;;-1:-1:-1;24772:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;24893:25:0;;;24869:4;24893:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24772:164;42700:192;;;;;;;;;;-1:-1:-1;42700:192:0;;;;;:::i;:::-;;:::i;73628:95::-;;;;;;;;;;-1:-1:-1;73628:95:0;;;;;:::i;:::-;;:::i;34662:224::-;34764:4;-1:-1:-1;;;;;;34788:50:0;;-1:-1:-1;;;34788:50:0;;:90;;;34842:36;34866:11;34842:23;:36::i;:::-;34781:97;34662:224;-1:-1:-1;;34662:224:0:o;73429:73::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;;;;;;;;;73481:6:::1;:15:::0;;-1:-1:-1;;73481:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;73429:73::o;22554:100::-;22608:13;22641:5;22634:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22554:100;:::o;24113:221::-;24189:7;27596:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27596:16:0;24209:73;;;;-1:-1:-1;;;24209:73:0;;20091:2:1;24209:73:0;;;20073:21:1;20130:2;20110:18;;;20103:30;20169:34;20149:18;;;20142:62;-1:-1:-1;;;20220:18:1;;;20213:42;20272:19;;24209:73:0;19889:408:1;24209:73:0;-1:-1:-1;24302:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24302:24:0;;24113:221::o;23636:411::-;23717:13;23733:23;23748:7;23733:14;:23::i;:::-;23717:39;;23781:5;-1:-1:-1;;;;;23775:11:0;:2;-1:-1:-1;;;;;23775:11:0;;;23767:57;;;;-1:-1:-1;;;23767:57:0;;21275:2:1;23767:57:0;;;21257:21:1;21314:2;21294:18;;;21287:30;21353:34;21333:18;;;21326:62;-1:-1:-1;;;21404:18:1;;;21397:31;21445:19;;23767:57:0;21073:397:1;23767:57:0;20163:10;-1:-1:-1;;;;;23859:21:0;;;;:62;;-1:-1:-1;23884:37:0;23901:5;20163:10;24772:164;:::i;23884:37::-;23837:168;;;;-1:-1:-1;;;23837:168:0;;18484:2:1;23837:168:0;;;18466:21:1;18523:2;18503:18;;;18496:30;18562:34;18542:18;;;18535:62;18633:26;18613:18;;;18606:54;18677:19;;23837:168:0;18282:420:1;23837:168:0;24018:21;24027:2;24031:7;24018:8;:21::i;:::-;23706:341;23636:411;;:::o;66898:671::-;-1:-1:-1;;;;;66974:16:0;;66993:1;66974:16;;;:7;:16;;;;;;66966:71;;;;-1:-1:-1;;;66966:71:0;;;;;;;:::i;:::-;67050:15;67068:19;67079:7;67068:10;:19::i;:::-;67050:37;-1:-1:-1;67108:12:0;67100:68;;;;-1:-1:-1;;;67100:68:0;;;;;;;:::i;:::-;67381:7;67363:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;67424:18:0;;;;;;:9;:18;;;;;:29;;;;;;67477:35;67434:7;67446;67477:17;:35::i;:::-;67528:33;;;-1:-1:-1;;;;;9915:32:1;;9897:51;;9979:2;9964:18;;9957:34;;;67528:33:0;;9870:18:1;67528:33:0;;;;;;;66955:614;66898:671;:::o;25003:339::-;25198:41;20163:10;25231:7;25198:18;:41::i;:::-;25190:103;;;;-1:-1:-1;;;25190:103:0;;;;;;;:::i;:::-;25306:28;25316:4;25322:2;25326:7;25306:9;:28::i;34970:256::-;35067:7;35103:23;35120:5;35103:16;:23::i;:::-;35095:5;:31;35087:87;;;;-1:-1:-1;;;35087:87:0;;12935:2:1;35087:87:0;;;12917:21:1;12974:2;12954:18;;;12947:30;13013:34;12993:18;;;12986:62;-1:-1:-1;;;13064:18:1;;;13057:41;13115:19;;35087:87:0;12733:407:1;35087:87:0;-1:-1:-1;;;;;;35192:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;34970:256::o;25413:185::-;25551:39;25568:4;25574:2;25578:7;25551:39;;;;;;;;;;;;:16;:39::i;72174:348::-;72249:16;72277:23;72303:17;72313:6;72303:9;:17::i;:::-;72277:43;;72327:25;72369:15;72355:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72355:30:0;;72327:58;;72397:9;72392:103;72412:15;72408:1;:19;72392:103;;;72457:30;72477:6;72485:1;72457:19;:30::i;:::-;72443:8;72452:1;72443:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;72429:3;;;;:::i;:::-;;;;72392:103;;;-1:-1:-1;72508:8:0;72174:348;-1:-1:-1;;;72174:348:0:o;73065:80::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;73124:4:::1;:15:::0;73065:80::o;67837:792::-;-1:-1:-1;;;;;67919:16:0;;67938:1;67919:16;;;:7;:16;;;;;;67911:71;;;;-1:-1:-1;;;67911:71:0;;;;;;;:::i;:::-;67995:15;68013:26;68024:5;68031:7;68013:10;:26::i;:::-;67995:44;-1:-1:-1;68060:12:0;68052:68;;;;-1:-1:-1;;;68052:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68375:26:0;;;;;;:19;:26;;;;;:37;;68405:7;;68375:26;:37;;68405:7;;68375:37;:::i;:::-;;;;-1:-1:-1;;;;;;;68448:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;:41;;;;;;68513:47;68463:5;68470:7;68482;68513:22;:47::i;:::-;68576:45;;;-1:-1:-1;;;;;9915:32:1;;;9897:51;;9979:2;9964:18;;9957:34;;;68576:45:0;;;;;9870:18:1;68576:45:0;;;;;;;67900:729;67837:792;;:::o;35492:233::-;35567:7;35603:30;35390:10;:17;;35302:113;35603:30;35595:5;:38;35587:95;;;;-1:-1:-1;;;35587:95:0;;22808:2:1;35587:95:0;;;22790:21:1;22847:2;22827:18;;;22820:30;22886:34;22866:18;;;22859:62;-1:-1:-1;;;22937:18:1;;;22930:42;22989:19;;35587:95:0;22606:408:1;35587:95:0;35700:10;35711:5;35700:17;;;;;;;;:::i;:::-;;;;;;;;;35693:24;;35492:233;;;:::o;73327:98::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;73398:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;:::-;;73327:98:::0;:::o;75391:144::-;75438:9;75433:95;75457:11;;75453:1;:15;75433:95;;;75490:26;75506:8;75512:1;75506:5;:8::i;75490:26::-;75470:3;;;;:::i;:::-;;;;75433:95;;;;75391:144::o;22248:239::-;22320:7;22356:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22356:16:0;22391:19;22383:73;;;;-1:-1:-1;;;22383:73:0;;19320:2:1;22383:73:0;;;19302:21:1;19359:2;19339:18;;;19332:30;19398:34;19378:18;;;19371:62;-1:-1:-1;;;19449:18:1;;;19442:39;19498:19;;22383:73:0;19118:405:1;21978:208:0;22050:7;-1:-1:-1;;;;;22078:19:0;;22070:74;;;;-1:-1:-1;;;22070:74:0;;18909:2:1;22070:74:0;;;18891:21:1;18948:2;18928:18;;;18921:30;18987:34;18967:18;;;18960:62;-1:-1:-1;;;19038:18:1;;;19031:40;19088:19;;22070:74:0;18707:406:1;22070:74:0;-1:-1:-1;;;;;;22162:16:0;;;;;:9;:16;;;;;;;21978:208::o;42451:94::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;42516:21:::1;42534:1;42516:9;:21::i;:::-;42451:94::o:0;73151:170::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;73247:32:::1;:68:::0;73151:170::o;73845:106::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;73919:10:::1;:24:::0;73845:106::o;65863:100::-;65914:7;65941;65949:5;65941:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;65941:14:0;;65863:100;-1:-1:-1;;65863:100:0:o;22723:104::-;22779:13;22812:7;22805:14;;;;;:::i;70781:511::-;70847:6;;;;70846:7;70838:16;;;;;;70884:15;70869:11;;;;:30;;;;;;;;:::i;:::-;;70861:69;;;;-1:-1:-1;;;70861:69:0;;21677:2:1;70861:69:0;;;21659:21:1;21716:2;21696:18;;;21689:30;21755:28;21735:18;;;21728:56;21801:18;;70861:69:0;21475:350:1;70861:69:0;70959:1;70945:11;:15;70937:24;;;;;;70968:11;70982:13;35390:10;:17;;35302:113;70982:13;71034:9;;70968:27;;-1:-1:-1;71010:20:0;71019:11;70968:27;71010:20;:::i;:::-;:33;;71002:42;;;;;;41873:6;;-1:-1:-1;;;;;41873:6:0;71057:10;:21;71053:133;;71103:7;;71094:6;:16;71091:88;;;71155:11;71148:4;;:18;;;;:::i;:::-;71135:9;:31;;71127:40;;;;;;71211:1;71194:93;71219:11;71214:1;:16;71194:93;;71246:33;71256:10;71268;71277:1;71268:6;:10;:::i;:::-;71246:9;:33::i;:::-;71232:3;;;;:::i;:::-;;;;71194:93;;24406:295;-1:-1:-1;;;;;24509:24:0;;20163:10;24509:24;;24501:62;;;;-1:-1:-1;;;24501:62:0;;16113:2:1;24501:62:0;;;16095:21:1;16152:2;16132:18;;;16125:30;16191:27;16171:18;;;16164:55;16236:18;;24501:62:0;15911:349:1;24501:62:0;20163:10;24576:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;24576:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;24576:53:0;;;;;;;;;;24645:48;;11562:41:1;;;24576:42:0;;20163:10;24645:48;;11535:18:1;24645:48:0;;;;;;;24406:295;;:::o;66053:225::-;66111:7;66131:21;66179:15;64766:14;;;64693:95;66179:15;66155:39;;:21;:39;:::i;:::-;66131:63;;66212:58;66228:7;66237:13;66252:17;66261:7;-1:-1:-1;;;;;65442:18:0;65415:7;65442:18;;;:9;:18;;;;;;;65359:109;66252:17;66212:15;:58::i;:::-;66205:65;66053:225;-1:-1:-1;;;66053:225:0:o;25669:328::-;25844:41;20163:10;25877:7;25844:18;:41::i;:::-;25836:103;;;;-1:-1:-1;;;25836:103:0;;;;;;;:::i;:::-;25950:39;25964:4;25970:2;25974:7;25983:5;25950:13;:39::i;:::-;25669:328;;;;:::o;66438:260::-;-1:-1:-1;;;;;65030:26:0;;66510:7;65030:26;;;:19;:26;;;;;;66510:7;;66554:30;;-1:-1:-1;;;66554:30:0;;66578:4;66554:30;;;9653:51:1;-1:-1:-1;;;;;66554:15:0;;;;;9626:18:1;;66554:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;-1:-1:-1;;;;;65734:21:0;;;65707:7;65734:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;66530:77;;-1:-1:-1;66625:65:0;;66641:7;;66530:77;;66212:15;:58::i;66625:65::-;66618:72;66438:260;-1:-1:-1;;;;66438:260:0:o;72755:302::-;27572:4;27596:16;;;:7;:16;;;;;;72874:13;;-1:-1:-1;;;;;27596:16:0;72905:61;;;;-1:-1:-1;;;72905:61:0;;12575:2:1;72905:61:0;;;12557:21:1;12614:2;12594:18;;;12587:30;12653:33;12633:18;;;12626:61;12704:18;;72905:61:0;12373:355:1;72905:61:0;73010:7;73019:19;:8;:17;:19::i;:::-;72993:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;72979:70;;72755:302;;;:::o;71298:870::-;71397:6;;;;71396:7;71388:16;;;;;;71434:18;71419:11;;;;:33;;;;;;;;:::i;:::-;;71411:75;;;;-1:-1:-1;;;71411:75:0;;14530:2:1;71411:75:0;;;14512:21:1;14569:2;14549:18;;;14542:30;14608:31;14588:18;;;14581:59;14657:18;;71411:75:0;14328:353:1;71411:75:0;71501:33;71515:10;71527:6;;71501:13;:33::i;:::-;71493:42;;;;;;71564:1;71550:11;:15;71542:24;;;;;;71673:32;;71627:10;71595:43;;;;:31;:43;;;;;;:57;;71641:11;;71595:57;:::i;:::-;:110;;71573:204;;;;-1:-1:-1;;;71573:204:0;;14888:2:1;71573:204:0;;;14870:21:1;14927:2;14907:18;;;14900:30;14966:34;14946:18;;;14939:62;-1:-1:-1;;;15017:18:1;;;15010:42;15069:19;;71573:204:0;14686:408:1;71573:204:0;71784:11;71798:13;35390:10;:17;;35302:113;71798:13;71784:27;-1:-1:-1;71850:4:0;71826:20;71835:11;71784:27;71826:20;:::i;:::-;:28;;71818:37;;;;;;41873:6;;-1:-1:-1;;;;;41873:6:0;71868:10;:21;71864:133;;71914:7;;71905:6;:16;71902:88;;;71966:11;71959:4;;:18;;;;:::i;:::-;71946:9;:31;;71938:40;;;;;;72037:10;72005:43;;;;:31;:43;;;;;:58;;72052:11;;72005:43;:58;;72052:11;;72005:58;:::i;:::-;;;;-1:-1:-1;72087:1:0;;-1:-1:-1;72070:93:0;72095:11;72090:1;:16;72070:93;;72122:33;72132:10;72144;72153:1;72144:6;:10;:::i;72122:33::-;72108:3;;;;:::i;:::-;;;;72070:93;;;;71381:787;71298:870;;;:::o;75218:91::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;75283:7:::1;:18:::0;75218:91::o;42700:192::-;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;42789:22:0;::::1;42781:73;;;::::0;-1:-1:-1;;;42781:73:0;;13766:2:1;42781:73:0::1;::::0;::::1;13748:21:1::0;13805:2;13785:18;;;13778:30;13844:34;13824:18;;;13817:62;-1:-1:-1;;;13895:18:1;;;13888:36;13941:19;;42781:73:0::1;13564:402:1::0;42781:73:0::1;42865:19;42875:8;42865:9;:19::i;73628:95::-:0;41873:6;;-1:-1:-1;;;;;41873:6:0;20163:10;42020:23;42012:68;;;;-1:-1:-1;;;42012:68:0;;;;;;;:::i;:::-;73709:5:::1;73704:11;;;;;;;;:::i;:::-;73690;:25:::0;;-1:-1:-1;;73690:25:0::1;::::0;;::::1;::::0;::::1;;;;;;:::i;:::-;;;;;;73628:95:::0;:::o;21609:305::-;21711:4;-1:-1:-1;;;;;;21748:40:0;;-1:-1:-1;;;21748:40:0;;:105;;-1:-1:-1;;;;;;;21805:48:0;;-1:-1:-1;;;21805:48:0;21748:105;:158;;;-1:-1:-1;;;;;;;;;;7549:40:0;;;21870:36;7440:157;31489:174;31564:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;31564:29:0;-1:-1:-1;;;;;31564:29:0;;;;;;;;:24;;31618:23;31564:24;31618:14;:23::i;:::-;-1:-1:-1;;;;;31609:46:0;;;;;;;;;;;31489:174;;:::o;11762:317::-;11877:6;11852:21;:31;;11844:73;;;;-1:-1:-1;;;11844:73:0;;16894:2:1;11844:73:0;;;16876:21:1;16933:2;16913:18;;;16906:30;16972:31;16952:18;;;16945:59;17021:18;;11844:73:0;16692:353:1;11844:73:0;11931:12;11949:9;-1:-1:-1;;;;;11949:14:0;11971:6;11949:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11930:52;;;12001:7;11993:78;;;;-1:-1:-1;;;11993:78:0;;16467:2:1;11993:78:0;;;16449:21:1;16506:2;16486:18;;;16479:30;16545:34;16525:18;;;16518:62;16616:28;16596:18;;;16589:56;16662:19;;11993:78:0;16265:422:1;27801:348:0;27894:4;27596:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27596:16:0;27911:73;;;;-1:-1:-1;;;27911:73:0;;17659:2:1;27911:73:0;;;17641:21:1;17698:2;17678:18;;;17671:30;17737:34;17717:18;;;17710:62;-1:-1:-1;;;17788:18:1;;;17781:42;17840:19;;27911:73:0;17457:408:1;27911:73:0;27995:13;28011:23;28026:7;28011:14;:23::i;:::-;27995:39;;28064:5;-1:-1:-1;;;;;28053:16:0;:7;-1:-1:-1;;;;;28053:16:0;;:51;;;;28097:7;-1:-1:-1;;;;;28073:31:0;:20;28085:7;28073:11;:20::i;:::-;-1:-1:-1;;;;;28073:31:0;;28053:51;:87;;;-1:-1:-1;;;;;;24893:25:0;;;24869:4;24893:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;28108:32;24772:164;30793:578;30952:4;-1:-1:-1;;;;;30925:31:0;:23;30940:7;30925:14;:23::i;:::-;-1:-1:-1;;;;;30925:31:0;;30917:85;;;;-1:-1:-1;;;30917:85:0;;20865:2:1;30917:85:0;;;20847:21:1;20904:2;20884:18;;;20877:30;20943:34;20923:18;;;20916:62;-1:-1:-1;;;20994:18:1;;;20987:39;21043:19;;30917:85:0;20663:405:1;30917:85:0;-1:-1:-1;;;;;31021:16:0;;31013:65;;;;-1:-1:-1;;;31013:65:0;;15708:2:1;31013:65:0;;;15690:21:1;15747:2;15727:18;;;15720:30;15786:34;15766:18;;;15759:62;-1:-1:-1;;;15837:18:1;;;15830:34;15881:19;;31013:65:0;15506:400:1;31013:65:0;31091:39;31112:4;31118:2;31122:7;31091:20;:39::i;:::-;31195:29;31212:1;31216:7;31195:8;:29::i;:::-;-1:-1:-1;;;;;31237:15:0;;;;;;:9;:15;;;;;:20;;31256:1;;31237:15;:20;;31256:1;;31237:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31268:13:0;;;;;;:9;:13;;;;;:18;;31285:1;;31268:13;:18;;31285:1;;31268:18;:::i;:::-;;;;-1:-1:-1;;31297:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31297:21:0;-1:-1:-1;;;;;31297:21:0;;;;;;;;;31336:27;;31297:16;;31336:27;;;;;;;30793:578;;;:::o;57377:211::-;57521:58;;;-1:-1:-1;;;;;9915:32:1;;57521:58:0;;;9897:51:1;9964:18;;;;9957:34;;;57521:58:0;;;;;;;;;;9870:18:1;;;;57521:58:0;;;;;;;;-1:-1:-1;;;;;57521:58:0;-1:-1:-1;;;57521:58:0;;;57494:86;;57514:5;;57494:19;:86::i;42900:173::-;42975:6;;;-1:-1:-1;;;;;42992:17:0;;;-1:-1:-1;;;;;;42992:17:0;;;;;;;43025:40;;42975:6;;;42992:17;42975:6;;43025:40;;42956:16;;43025:40;42945:128;42900:173;:::o;28491:110::-;28567:26;28577:2;28581:7;28567:26;;;;;;;;;;;;:9;:26::i;68807:248::-;69017:12;;-1:-1:-1;;;;;68997:16:0;;68953:7;68997:16;;;:7;:16;;;;;;68953:7;;69032:15;;68981:32;;:13;:32;:::i;:::-;68980:49;;;;:::i;:::-;:67;;;;:::i;26879:315::-;27036:28;27046:4;27052:2;27056:7;27036:9;:28::i;:::-;27083:48;27106:4;27112:2;27116:7;27125:5;27083:22;:48::i;:::-;27075:111;;;;-1:-1:-1;;;27075:111:0;;;;;;;:::i;7915:723::-;7971:13;8192:10;8188:53;;-1:-1:-1;;8219:10:0;;;;;;;;;;;;-1:-1:-1;;;8219:10:0;;;;;7915:723::o;8188:53::-;8266:5;8251:12;8307:78;8314:9;;8307:78;;8340:8;;;;:::i;:::-;;-1:-1:-1;8363:10:0;;-1:-1:-1;8371:2:0;8363:10;;:::i;:::-;;;8307:78;;;8395:19;8427:6;8417:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8417:17:0;;8395:39;;8445:154;8452:10;;8445:154;;8479:11;8489:1;8479:11;;:::i;:::-;;-1:-1:-1;8548:10:0;8556:2;8548:5;:10;:::i;:::-;8535:24;;:2;:24;:::i;:::-;8522:39;;8505:6;8512;8505:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;8505:56:0;;;;;;;;-1:-1:-1;8576:11:0;8585:2;8576:11;;:::i;:::-;;;8445:154;;75024:186;75142:4;75171:31;75179:14;75184:8;74209:26;;-1:-1:-1;;7628:2:1;7624:15;;;7620:53;74209:26:0;;;7608:66:1;74172:7:0;;7690:12:1;;74209:26:0;;;;;;;;;;;;74199:37;;;;;;74192:44;;74117:127;;;;75179:14;75195:6;;75171:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75171:7:0;;-1:-1:-1;;;75171:31:0:i;36338:589::-;-1:-1:-1;;;;;36544:18:0;;36540:187;;36579:40;36611:7;37754:10;:17;;37727:24;;;;:15;:24;;;;;:44;;;37782:24;;;;;;;;;;;;37650:164;36579:40;36540:187;;;36649:2;-1:-1:-1;;;;;36641:10:0;:4;-1:-1:-1;;;;;36641:10:0;;36637:90;;36668:47;36701:4;36707:7;36668:32;:47::i;:::-;-1:-1:-1;;;;;36741:16:0;;36737:183;;36774:45;36811:7;36774:36;:45::i;36737:183::-;36847:4;-1:-1:-1;;;;;36841:10:0;:2;-1:-1:-1;;;;;36841:10:0;;36837:83;;36868:40;36896:2;36900:7;36868:27;:40::i;60444:716::-;60868:23;60894:69;60922:4;60894:69;;;;;;;;;;;;;;;;;60902:5;-1:-1:-1;;;;;60894:27:0;;;:69;;;;;:::i;:::-;60978:17;;60868:95;;-1:-1:-1;60978:21:0;60974:179;;61075:10;61064:30;;;;;;;;;;;;:::i;:::-;61056:85;;;;-1:-1:-1;;;61056:85:0;;23221:2:1;61056:85:0;;;23203:21:1;23260:2;23240:18;;;23233:30;23299:34;23279:18;;;23272:62;-1:-1:-1;;;23350:18:1;;;23343:40;23400:19;;61056:85:0;23019:406:1;28828:321:0;28958:18;28964:2;28968:7;28958:5;:18::i;:::-;29009:54;29040:1;29044:2;29048:7;29057:5;29009:22;:54::i;:::-;28987:154;;;;-1:-1:-1;;;28987:154:0;;;;;;;:::i;32228:799::-;32383:4;-1:-1:-1;;;;;32404:13:0;;10763:20;10811:8;32400:620;;32440:72;;-1:-1:-1;;;32440:72:0;;-1:-1:-1;;;;;32440:36:0;;;;;:72;;20163:10;;32491:4;;32497:7;;32506:5;;32440:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32440:72:0;;;;;;;;-1:-1:-1;;32440:72:0;;;;;;;;;;;;:::i;:::-;;;32436:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32682:13:0;;32678:272;;32725:60;;-1:-1:-1;;;32725:60:0;;;;;;;:::i;32678:272::-;32900:6;32894:13;32885:6;32881:2;32877:15;32870:38;32436:529;-1:-1:-1;;;;;;32563:51:0;-1:-1:-1;;;32563:51:0;;-1:-1:-1;32556:58:0;;32400:620;-1:-1:-1;33004:4:0;32228:799;;;;;;:::o;74573:189::-;74680:4;74709:45;74728:6;74736:10;;74748:5;74709:18;:45::i;38441:988::-;38707:22;38757:1;38732:22;38749:4;38732:16;:22::i;:::-;:26;;;;:::i;:::-;38769:18;38790:26;;;:17;:26;;;;;;38707:51;;-1:-1:-1;38923:28:0;;;38919:328;;-1:-1:-1;;;;;38990:18:0;;38968:19;38990:18;;;:12;:18;;;;;;;;:34;;;;;;;;;39041:30;;;;;;:44;;;39158:30;;:17;:30;;;;;:43;;;38919:328;-1:-1:-1;39343:26:0;;;;:17;:26;;;;;;;;39336:33;;;-1:-1:-1;;;;;39387:18:0;;;;;:12;:18;;;;;:34;;;;;;;39380:41;38441:988::o;39724:1079::-;40002:10;:17;39977:22;;40002:21;;40022:1;;40002:21;:::i;:::-;40034:18;40055:24;;;:15;:24;;;;;;40428:10;:26;;39977:46;;-1:-1:-1;40055:24:0;;39977:46;;40428:26;;;;;;:::i;:::-;;;;;;;;;40406:48;;40492:11;40467:10;40478;40467:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;40572:28;;;:15;:28;;;;;;;:41;;;40744:24;;;;;40737:31;40779:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;39795:1008;;;39724:1079;:::o;37228:221::-;37313:14;37330:20;37347:2;37330:16;:20::i;:::-;-1:-1:-1;;;;;37361:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;37406:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;37228:221:0:o;13246:229::-;13383:12;13415:52;13437:6;13445:4;13451:1;13454:12;13415:21;:52::i;29485:382::-;-1:-1:-1;;;;;29565:16:0;;29557:61;;;;-1:-1:-1;;;29557:61:0;;19730:2:1;29557:61:0;;;19712:21:1;;;19749:18;;;19742:30;19808:34;19788:18;;;19781:62;19860:18;;29557:61:0;19528:356:1;29557:61:0;27572:4;27596:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27596:16:0;:30;29629:58;;;;-1:-1:-1;;;29629:58:0;;14173:2:1;29629:58:0;;;14155:21:1;14212:2;14192:18;;;14185:30;14251;14231:18;;;14224:58;14299:18;;29629:58:0;13971:352:1;29629:58:0;29700:45;29729:1;29733:2;29737:7;29700:20;:45::i;:::-;-1:-1:-1;;;;;29758:13:0;;;;;;:9;:13;;;;;:18;;29775:1;;29758:13;:18;;29775:1;;29758:18;:::i;:::-;;;;-1:-1:-1;;29787:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29787:21:0;-1:-1:-1;;;;;29787:21:0;;;;;;;;29826:33;;29787:16;;;29826:33;;29787:16;;29826:33;29485:382;;:::o;44138:190::-;44263:4;44316;44287:25;44300:5;44307:4;44287:12;:25::i;:::-;:33;;44138:190;-1:-1:-1;;;;44138:190:0:o;14366:510::-;14536:12;14594:5;14569:21;:30;;14561:81;;;;-1:-1:-1;;;14561:81:0;;17252:2:1;14561:81:0;;;17234:21:1;17291:2;17271:18;;;17264:30;17330:34;17310:18;;;17303:62;-1:-1:-1;;;17381:18:1;;;17374:36;17427:19;;14561:81:0;17050:402:1;14561:81:0;10763:20;;14653:60;;;;-1:-1:-1;;;14653:60:0;;22450:2:1;14653:60:0;;;22432:21:1;22489:2;22469:18;;;22462:30;22528:31;22508:18;;;22501:59;22577:18;;14653:60:0;22248:353:1;14653:60:0;14727:12;14741:23;14768:6;-1:-1:-1;;;;;14768:11:0;14787:5;14794:4;14768:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14726:73;;;;14817:51;14834:7;14843:10;14855:12;14817:16;:51::i;:::-;14810:58;14366:510;-1:-1:-1;;;;;;;14366:510:0:o;45005:296::-;45088:7;45131:4;45088:7;45146:118;45170:5;:12;45166:1;:16;45146:118;;;45219:33;45229:12;45243:5;45249:1;45243:8;;;;;;;;:::i;:::-;;;;;;;45219:9;:33::i;:::-;45204:48;-1:-1:-1;45184:3:0;;;;:::i;:::-;;;;45146:118;;17052:712;17202:12;17231:7;17227:530;;;-1:-1:-1;17262:10:0;17255:17;;17227:530;17376:17;;:21;17372:374;;17574:10;17568:17;17635:15;17622:10;17618:2;17614:19;17607:44;17372:374;17717:12;17710:20;;-1:-1:-1;;;17710:20:0;;;;;;;;:::i;51212:149::-;51275:7;51306:1;51302;:5;:51;;51437:13;51531:15;;;51567:4;51560:15;;;51614:4;51598:21;;51302:51;;;51437:13;51531:15;;;51567:4;51560:15;;;51614:4;51598:21;;51310:20;51369:268;-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:247::-;709:6;762:2;750:9;741:7;737:23;733:32;730:52;;;778:1;775;768:12;730:52;817:9;804:23;836:31;861:5;836:31;:::i;1162:388::-;1230:6;1238;1291:2;1279:9;1270:7;1266:23;1262:32;1259:52;;;1307:1;1304;1297:12;1259:52;1346:9;1333:23;1365:31;1390:5;1365:31;:::i;:::-;1415:5;-1:-1:-1;1472:2:1;1457:18;;1444:32;1485:33;1444:32;1485:33;:::i;:::-;1537:7;1527:17;;;1162:388;;;;;:::o;1555:456::-;1632:6;1640;1648;1701:2;1689:9;1680:7;1676:23;1672:32;1669:52;;;1717:1;1714;1707:12;1669:52;1756:9;1743:23;1775:31;1800:5;1775:31;:::i;:::-;1825:5;-1:-1:-1;1882:2:1;1867:18;;1854:32;1895:33;1854:32;1895:33;:::i;:::-;1555:456;;1947:7;;-1:-1:-1;;;2001:2:1;1986:18;;;;1973:32;;1555:456::o;2016:794::-;2111:6;2119;2127;2135;2188:3;2176:9;2167:7;2163:23;2159:33;2156:53;;;2205:1;2202;2195:12;2156:53;2244:9;2231:23;2263:31;2288:5;2263:31;:::i;:::-;2313:5;-1:-1:-1;2370:2:1;2355:18;;2342:32;2383:33;2342:32;2383:33;:::i;:::-;2435:7;-1:-1:-1;2489:2:1;2474:18;;2461:32;;-1:-1:-1;2544:2:1;2529:18;;2516:32;2571:18;2560:30;;2557:50;;;2603:1;2600;2593:12;2557:50;2626:22;;2679:4;2671:13;;2667:27;-1:-1:-1;2657:55:1;;2708:1;2705;2698:12;2657:55;2731:73;2796:7;2791:2;2778:16;2773:2;2769;2765:11;2731:73;:::i;:::-;2721:83;;;2016:794;;;;;;;:::o;2815:382::-;2880:6;2888;2941:2;2929:9;2920:7;2916:23;2912:32;2909:52;;;2957:1;2954;2947:12;2909:52;2996:9;2983:23;3015:31;3040:5;3015:31;:::i;:::-;3065:5;-1:-1:-1;3122:2:1;3107:18;;3094:32;3135:30;3094:32;3135:30;:::i;3202:315::-;3270:6;3278;3331:2;3319:9;3310:7;3306:23;3302:32;3299:52;;;3347:1;3344;3337:12;3299:52;3386:9;3373:23;3405:31;3430:5;3405:31;:::i;:::-;3455:5;3507:2;3492:18;;;;3479:32;;-1:-1:-1;;;3202:315:1:o;3522:241::-;3578:6;3631:2;3619:9;3610:7;3606:23;3602:32;3599:52;;;3647:1;3644;3637:12;3599:52;3686:9;3673:23;3705:28;3727:5;3705:28;:::i;3768:245::-;3835:6;3888:2;3876:9;3867:7;3863:23;3859:32;3856:52;;;3904:1;3901;3894:12;3856:52;3936:9;3930:16;3955:28;3977:5;3955:28;:::i;4018:180::-;4077:6;4130:2;4118:9;4109:7;4105:23;4101:32;4098:52;;;4146:1;4143;4136:12;4098:52;-1:-1:-1;4169:23:1;;4018:180;-1:-1:-1;4018:180:1:o;4203:245::-;4261:6;4314:2;4302:9;4293:7;4289:23;4285:32;4282:52;;;4330:1;4327;4320:12;4282:52;4369:9;4356:23;4388:30;4412:5;4388:30;:::i;4453:249::-;4522:6;4575:2;4563:9;4554:7;4550:23;4546:32;4543:52;;;4591:1;4588;4581:12;4543:52;4623:9;4617:16;4642:30;4666:5;4642:30;:::i;5382:450::-;5451:6;5504:2;5492:9;5483:7;5479:23;5475:32;5472:52;;;5520:1;5517;5510:12;5472:52;5560:9;5547:23;5593:18;5585:6;5582:30;5579:50;;;5625:1;5622;5615:12;5579:50;5648:22;;5701:4;5693:13;;5689:27;-1:-1:-1;5679:55:1;;5730:1;5727;5720:12;5679:55;5753:73;5818:7;5813:2;5800:16;5795:2;5791;5787:11;5753:73;:::i;6022:184::-;6092:6;6145:2;6133:9;6124:7;6120:23;6116:32;6113:52;;;6161:1;6158;6151:12;6113:52;-1:-1:-1;6184:16:1;;6022:184;-1:-1:-1;6022:184:1:o;6211:683::-;6306:6;6314;6322;6375:2;6363:9;6354:7;6350:23;6346:32;6343:52;;;6391:1;6388;6381:12;6343:52;6427:9;6414:23;6404:33;;6488:2;6477:9;6473:18;6460:32;6511:18;6552:2;6544:6;6541:14;6538:34;;;6568:1;6565;6558:12;6538:34;6606:6;6595:9;6591:22;6581:32;;6651:7;6644:4;6640:2;6636:13;6632:27;6622:55;;6673:1;6670;6663:12;6622:55;6713:2;6700:16;6739:2;6731:6;6728:14;6725:34;;;6755:1;6752;6745:12;6725:34;6808:7;6803:2;6793:6;6790:1;6786:14;6782:2;6778:23;6774:32;6771:45;6768:65;;;6829:1;6826;6819:12;6768:65;6860:2;6856;6852:11;6842:21;;6882:6;6872:16;;;;;6211:683;;;;;:::o;6899:268::-;6951:3;6989:5;6983:12;7016:6;7011:3;7004:19;7032:63;7088:6;7081:4;7076:3;7072:14;7065:4;7058:5;7054:16;7032:63;:::i;:::-;7149:2;7128:15;-1:-1:-1;;7124:29:1;7115:39;;;;7156:4;7111:50;;6899:268;-1:-1:-1;;6899:268:1:o;7172:184::-;7213:3;7251:5;7245:12;7266:52;7311:6;7306:3;7299:4;7292:5;7288:16;7266:52;:::i;:::-;7334:16;;;;;7172:184;-1:-1:-1;;7172:184:1:o;7713:274::-;7842:3;7880:6;7874:13;7896:53;7942:6;7937:3;7930:4;7922:6;7918:17;7896:53;:::i;:::-;7965:16;;;;;7713:274;-1:-1:-1;;7713:274:1:o;7992:1300::-;8269:3;8298:1;8331:6;8325:13;8361:3;8383:1;8411:9;8407:2;8403:18;8393:28;;8471:2;8460:9;8456:18;8493;8483:61;;8537:4;8529:6;8525:17;8515:27;;8483:61;8563:2;8611;8603:6;8600:14;8580:18;8577:38;8574:165;;;-1:-1:-1;;;8638:33:1;;8694:4;8691:1;8684:15;8724:4;8645:3;8712:17;8574:165;8755:18;8782:104;;;;8900:1;8895:320;;;;8748:467;;8782:104;-1:-1:-1;;8815:24:1;;8803:37;;8860:16;;;;-1:-1:-1;8782:104:1;;8895:320;23685:1;23678:14;;;23722:4;23709:18;;8990:1;9004:165;9018:6;9015:1;9012:13;9004:165;;;9096:14;;9083:11;;;9076:35;9139:16;;;;9033:10;;9004:165;;;9008:3;;9198:6;9193:3;9189:16;9182:23;;8748:467;;;;;;;9231:55;9256:29;9281:3;9273:6;9256:29;:::i;:::-;-1:-1:-1;;;7421:20:1;;7466:1;7457:11;;7361:113;9231:55;9224:62;7992:1300;-1:-1:-1;;;;;7992:1300:1:o;10002:499::-;-1:-1:-1;;;;;10271:15:1;;;10253:34;;10323:15;;10318:2;10303:18;;10296:43;10370:2;10355:18;;10348:34;;;10418:3;10413:2;10398:18;;10391:31;;;10196:4;;10439:56;;10475:19;;10467:6;10439:56;:::i;:::-;10431:64;10002:499;-1:-1:-1;;;;;;10002:499:1:o;10785:632::-;10956:2;11008:21;;;11078:13;;10981:18;;;11100:22;;;10927:4;;10956:2;11179:15;;;;11153:2;11138:18;;;10927:4;11222:169;11236:6;11233:1;11230:13;11222:169;;;11297:13;;11285:26;;11366:15;;;;11331:12;;;;11258:1;11251:9;11222:169;;;-1:-1:-1;11408:3:1;;10785:632;-1:-1:-1;;;;;;10785:632:1:o;11796:337::-;11937:2;11922:18;;11970:1;11959:13;;11949:144;;12015:10;12010:3;12006:20;12003:1;11996:31;12050:4;12047:1;12040:15;12078:4;12075:1;12068:15;11949:144;12102:25;;;11796:337;:::o;12138:230::-;12287:2;12276:9;12269:21;12250:4;12307:55;12358:2;12347:9;12343:18;12335:6;12307:55;:::i;13145:414::-;13347:2;13329:21;;;13386:2;13366:18;;;13359:30;13425:34;13420:2;13405:18;;13398:62;-1:-1:-1;;;13491:2:1;13476:18;;13469:48;13549:3;13534:19;;13145:414::o;15099:402::-;15301:2;15283:21;;;15340:2;15320:18;;;15313:30;15379:34;15374:2;15359:18;;15352:62;-1:-1:-1;;;15445:2:1;15430:18;;15423:36;15491:3;15476:19;;15099:402::o;17870:407::-;18072:2;18054:21;;;18111:2;18091:18;;;18084:30;18150:34;18145:2;18130:18;;18123:62;-1:-1:-1;;;18216:2:1;18201:18;;18194:41;18267:3;18252:19;;17870:407::o;20302:356::-;20504:2;20486:21;;;20523:18;;;20516:30;20582:34;20577:2;20562:18;;20555:62;20649:2;20634:18;;20302:356::o;21830:413::-;22032:2;22014:21;;;22071:2;22051:18;;;22044:30;22110:34;22105:2;22090:18;;22083:62;-1:-1:-1;;;22176:2:1;22161:18;;22154:47;22233:3;22218:19;;21830:413::o;23738:128::-;23778:3;23809:1;23805:6;23802:1;23799:13;23796:39;;;23815:18;;:::i;:::-;-1:-1:-1;23851:9:1;;23738:128::o;23871:120::-;23911:1;23937;23927:35;;23942:18;;:::i;:::-;-1:-1:-1;23976:9:1;;23871:120::o;23996:168::-;24036:7;24102:1;24098;24094:6;24090:14;24087:1;24084:21;24079:1;24072:9;24065:17;24061:45;24058:71;;;24109:18;;:::i;:::-;-1:-1:-1;24149:9:1;;23996:168::o;24169:125::-;24209:4;24237:1;24234;24231:8;24228:34;;;24242:18;;:::i;:::-;-1:-1:-1;24279:9:1;;24169:125::o;24299:258::-;24371:1;24381:113;24395:6;24392:1;24389:13;24381:113;;;24471:11;;;24465:18;24452:11;;;24445:39;24417:2;24410:10;24381:113;;;24512:6;24509:1;24506:13;24503:48;;;-1:-1:-1;;24547:1:1;24529:16;;24522:27;24299:258::o;24562:380::-;24641:1;24637:12;;;;24684;;;24705:61;;24759:4;24751:6;24747:17;24737:27;;24705:61;24812:2;24804:6;24801:14;24781:18;24778:38;24775:161;;;24858:10;24853:3;24849:20;24846:1;24839:31;24893:4;24890:1;24883:15;24921:4;24918:1;24911:15;24775:161;;24562:380;;;:::o;24947:135::-;24986:3;-1:-1:-1;;25007:17:1;;25004:43;;;25027:18;;:::i;:::-;-1:-1:-1;25074:1:1;25063:13;;24947:135::o;25087:112::-;25119:1;25145;25135:35;;25150:18;;:::i;:::-;-1:-1:-1;25184:9:1;;25087:112::o;25204:127::-;25265:10;25260:3;25256:20;25253:1;25246:31;25296:4;25293:1;25286:15;25320:4;25317:1;25310:15;25336:127;25397:10;25392:3;25388:20;25385:1;25378:31;25428:4;25425:1;25418:15;25452:4;25449:1;25442:15;25468:127;25529:10;25524:3;25520:20;25517:1;25510:31;25560:4;25557:1;25550:15;25584:4;25581:1;25574:15;25600:127;25661:10;25656:3;25652:20;25649:1;25642:31;25692:4;25689:1;25682:15;25716:4;25713:1;25706:15;25732:127;25793:10;25788:3;25784:20;25781:1;25774:31;25824:4;25821:1;25814:15;25848:4;25845:1;25838:15;25864:127;25925:10;25920:3;25916:20;25913:1;25906:31;25956:4;25953:1;25946:15;25980:4;25977:1;25970:15;25996:131;-1:-1:-1;;;;;26071:31:1;;26061:42;;26051:70;;26117:1;26114;26107:12;26132:118;26218:5;26211:13;26204:21;26197:5;26194:32;26184:60;;26240:1;26237;26230:12;26255:131;-1:-1:-1;;;;;;26329:32:1;;26319:43;;26309:71;;26376:1;26373;26366:12

Swarm Source

ipfs://4562519d1d02b32bff071ea70839e65f5c1bed1c7870f4b62b785f2c77b8036a

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