Token

AdWorld Season 1 (ADW01)

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

ERC-721

NFT

Overview

Max Total Supply

3,333 ADW01

Holders

1,423

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x62eb144fe92ddc1b10bcade03a0c09f6fbffbffb

Filtered by Token Holder

0x0A24C7547dd14BE2F502D354afD224B226d177E4

Balance

22 ADW01

0x0a24c7547dd14be2f502d354afd224b226d177e4

OVERVIEW

AdWorld is a collection of 3333 Samskara that grant you access to AdCitizen Character Creator.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ADW

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-03-23
*/

// Sources flattened with hardhat v2.8.2 https://hardhat.org
// SPDX-License-Identifier: MIT

// File @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

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

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


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/security/[email protected]


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

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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


// File @openzeppelin/contracts/utils/introspection/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts v4.4.1 (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/[email protected]


// OpenZeppelin Contracts v4.4.1 (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/token/ERC721/extensions/[email protected]


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

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (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/[email protected]


// OpenZeppelin Contracts v4.4.1 (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/utils/[email protected]

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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]

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

pragma solidity ^0.8.0;

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


// File contracts/ERC721A.sol

// Creator: Chiru Labs

pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used). 
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex times
        unchecked {
            return _currentIndex - _burnCounter;    
        }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant: 
                    // There will always be an ownership that has an address and is not burned 
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return ownershipOf(tokenId).addr;
    }

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        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 override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();

        _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 {
        _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 {
        _transfer(from, to, tokenId);
        if (!_checkOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe && !_checkOnERC721Received(address(0), to, updatedIndex, _data)) {
                    revert TransferToNonERC721ReceiverImplementer();
                }
                updatedIndex++;
            }

            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @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 {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked { 
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, 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(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert TransferToNonERC721ReceiverImplementer();
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * 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, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}


// File contracts/MerkleProof.sol

// OpenZeppelin Contracts v4.4.1 (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash;
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/[email protected]

// OpenZeppelin Contracts v4.4.1 (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 {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || 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 Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

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


// File contracts/ADW.sol


pragma solidity ^0.8.0;






contract ADW is Ownable, ERC721A, ReentrancyGuard {
    using SafeMath for uint256;

    uint256 public immutable maxPerAddressDuringMint;
    uint256 public immutable MAX_AMOUNT;
    bytes32 public merkleRoot;

    mapping(address => uint8) public mintedWhitelist;
    mapping(address => bool) public mintedSharedToken;

    uint256 public constant NFTPrice = 0.088 ether;

    bool public saleIsActive = false;
    bool public isWhitelistActive = false;
    bool public isSharedHolderSaleActive = false;

    uint8 public availableTokensPerWhitelist = 2;

    address public SAN_WALLET = 0x503FB544782414D47b913a47a44d8385152fB8f2;
    address devWallet = 0x38c0245C7C67576d1E73f3A11c6af76fE8d11dEA;
    address potOfGold = 0xCE811655776fcADC3d341B63090fd78a92F915A1;
    address artWallet = 0x1779B02A06DbFD6Aaead120136F1AB34eCc8f27D;
    address mktWallet = 0xC4f574cDB4cE0a7d80191A7f18c95D18e42bd2dC;
    address musicWallet = 0x823291ecb3f4258122035b9E642599D7cf6e15f1;
    address jeremyWallet = 0xDDD10aa3F06cc45a2b8d9F91FA74EDeb72aB8f8A;
    address copyWallet = 0x101d40C4A9242Bebb07Bb0F34deDa6F2b764450B;

    constructor(
        bytes32 merkleRoot_
    ) ERC721A("AdWorld Season 1", "ADW01") {
        MAX_AMOUNT = 3333;
        maxPerAddressDuringMint = 10;
        merkleRoot = merkleRoot_;
    }

    function mintSan() public onlyOwner {
        require(!_exists(0), "Token #0 has already been minted.");
        _safeMint(SAN_WALLET, 1);
    }

    function mintReserveTokens(uint256 numberOfTokens) public onlyOwner {
        require(_exists(0), "Mint San's token first");
        _safeMint(msg.sender, numberOfTokens);
        require(totalSupply() <= MAX_AMOUNT, "Limit reached");

    }

    function whitelistMint(
        bytes32[] calldata _merkleProof,
        uint8 numberOfTokens
    ) external payable {
        require(isWhitelistActive, "Whitelist is not active");
        require(
            NFTPrice.mul(numberOfTokens) <= msg.value,
            "Ether value sent is not correct"
        );

        uint8 mintedSoFar = mintedWhitelist[msg.sender] + numberOfTokens;
        require(mintedSoFar <= availableTokensPerWhitelist, "You can't mint that many");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(
            MerkleProof.verify(_merkleProof, merkleRoot, leaf) == true,
            "Incorrect Merkle Proof"
        );

        mintedWhitelist[msg.sender] = mintedSoFar;

        _safeMint(msg.sender, numberOfTokens);
        
        require(totalSupply() <= MAX_AMOUNT, "Limit reached");
    }

    function mintNFTAsSharedOwner() public payable {
        require(isSharedHolderSaleActive, "Sale must be active to mint a samskara");
        require(NFTPrice <= msg.value, "Ether value sent is not correct");
        require(
            isSharedOwner(msg.sender),
            "This wallet does not contain the right NFTs."
        );

        require(mintedSharedToken[msg.sender] == false, "You can't mint that many");
        mintedSharedToken[msg.sender] = true;

        _safeMint(msg.sender, 1);

        require(totalSupply() <= MAX_AMOUNT, "Limit reached");
    }

    function mintNFT(uint256 numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint a samskara");
        require(
            numberOfTokens <= maxPerAddressDuringMint,
            "You can't mint that many at once"
        );
        require(
            NFTPrice.mul(numberOfTokens) <= msg.value,
            "Ether value sent is not correct"
        );

        _safeMint(msg.sender, numberOfTokens);

        require(totalSupply() <= MAX_AMOUNT, "Limit reached");
    }

    function flipSaleState() public onlyOwner {
        require(_exists(0), "Mint San's token first");
        saleIsActive = !saleIsActive;
    }
    function flipWhitelistState() public onlyOwner {
        require(_exists(0), "Mint San's token first");
        isWhitelistActive = !isWhitelistActive;
    }
    function flipSharedHolderState() public onlyOwner {
        require(_exists(0), "Mint San's token first");
        isSharedHolderSaleActive = !isSharedHolderSaleActive;
    }

    function isSharedOwner(address addr) public view returns (bool) {
        address milady = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
        address creature = 0xc92cedDfb8dd984A89fb494c376f9A48b999aAFc;
        address corruptions = 0x5BDf397bB2912859Dbd8011F320a222f79A28d2E;
        address azuki = 0xED5AF388653567Af2F388E6224dC7C4b3241C544;
        address arpeggi = 0xD614E3b775B94794ea16a7843F31a56c36EDCb09;
        address tubby = 0xCa7cA7BcC765F77339bE2d648BA53ce9c8a262bD;
        address pixelmon = 0x32973908FaeE0Bf825A343000fE412ebE56F802A;
        address seals = 0x364C828eE171616a39897688A831c2499aD972ec;
        return
            ERC721(milady).balanceOf(addr) > 0 ||
            ERC721(creature).balanceOf(addr) > 0 ||
            ERC721(corruptions).balanceOf(addr) > 0 ||
            ERC721(azuki).balanceOf(addr) > 0 ||
            ERC721(arpeggi).balanceOf(addr) > 0 ||
            ERC721(milady).balanceOf(addr) > 0 ||
            ERC721(tubby).balanceOf(addr) > 0 || 
            ERC721(pixelmon).balanceOf(addr) > 0 || 
            ERC721(seals).balanceOf(addr) > 0;
    }

    // // metadata URI
    string private _baseTokenURI;

    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

    function setBaseURI(string calldata baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function setMerkleRoot(bytes32 merkleRoot_) external onlyOwner {
        merkleRoot = merkleRoot_;
    }

    function withdrawMoney() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }

    function numberMinted(address owner) public view returns (uint256) {
        return _numberMinted(owner);
    }

    function getOwnershipData(uint256 tokenId)
        external
        view
        returns (TokenOwnership memory)
    {
        return ownershipOf(tokenId);
    }

    function withdrawAll() public payable onlyOwner {
        uint256 gold = (address(this).balance * 10000) / 100000; 
        uint256 san = (address(this).balance * 17000) / 100000; 
        uint256 dev = (address(this).balance * 16640) / 100000; 
        uint256 art = (address(this).balance * 14400) / 100000; 
        uint256 music = (address(this).balance * 11400) / 100000; 
        uint256 jer = (address(this).balance *  8000) / 100000; 
        uint256 copy = (address(this).balance *  2500) / 100000; 
        uint256 mktAndTreasury = (address(this).balance * 20060) / 100000; 
        
        // 10000 + 17000 + 16640 + 14400 + 11400 + 8000 + 2500 + 20060

        require(payable(potOfGold).send(gold));
        require(payable(SAN_WALLET).send(san));
        require(payable(devWallet).send(dev));
        require(payable(artWallet).send(art));
        require(payable(musicWallet).send(music));
        require(payable(jeremyWallet).send(jer));
        require(payable(copyWallet).send(copy));
        require(payable(mktWallet).send(mktAndTreasury));
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"MintedQueryForZeroAddress","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NFTPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SAN_WALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"availableTokensPerWhitelist","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSharedHolderState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipWhitelistState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getOwnershipData","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct ERC721A.TokenOwnership","name":"","type":"tuple"}],"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":"isSharedHolderSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isSharedOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isWhitelistActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerAddressDuringMint","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":"numberOfTokens","type":"uint256"}],"name":"mintNFT","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintNFTAsSharedOwner","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintReserveTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintSan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedSharedToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedWhitelist","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"merkleRoot_","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"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":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"uint8","name":"numberOfTokens","type":"uint8"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawMoney","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

80fda547d7f7ef7387da9e6b888ef67440d111991366efbebc7415018a08f5f6

-----Decoded View---------------
Arg [0] : merkleRoot_ (bytes32): 0x80fda547d7f7ef7387da9e6b888ef67440d111991366efbebc7415018a08f5f6

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 80fda547d7f7ef7387da9e6b888ef67440d111991366efbebc7415018a08f5f6

Deployed Bytecode Sourcemap

70332:7398:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30055:305;;;;;;;;;;-1:-1:-1;30055:305:0;;;;;:::i;:::-;;:::i;:::-;;;7742:14:1;;7735:22;7717:41;;7705:2;7690:18;30055:305:0;;;;;;;;72093:878;;;;;;:::i;:::-;;:::i;:::-;;70912:70;;;;;;;;;;-1:-1:-1;70912:70:0;;;;;;;-1:-1:-1;;;;;70912:70:0;;;;;;-1:-1:-1;;;;;7040:32:1;;;7022:51;;7010:2;6995:18;70912:70:0;6977:102:1;70806:44:0;;;;;;;;;;-1:-1:-1;70806:44:0;;;;;;;;;;;33415:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;34918:204::-;;;;;;;;;;-1:-1:-1;34918:204:0;;;;;:::i;:::-;;:::i;34481:371::-;;;;;;;;;;-1:-1:-1;34481:371:0;;;;;:::i;:::-;;:::i;71684:147::-;;;;;;;;;;;;;:::i;29712:271::-;;;;;;;;;;-1:-1:-1;29948:12:0;;29932:13;;:28;29712:271;;;7915:25:1;;;7903:2;7888:18;29712:271:0;7870:76:1;72979:585:0;;;:::i;35775:170::-;;;;;;;;;;-1:-1:-1;35775:170:0;;;;;:::i;:::-;;:::i;71839:246::-;;;;;;;;;;-1:-1:-1;71839:246:0;;;;;:::i;:::-;;:::i;70521:25::-;;;;;;;;;;;;;;;;74101:145;;;;;;;;;;;;;:::i;36016:185::-;;;;;;;;;;-1:-1:-1;36016:185:0;;;;;:::i;:::-;;:::i;70762:37::-;;;;;;;;;;-1:-1:-1;70762:37:0;;;;;;;;;;;75915:106;;;;;;;;;;-1:-1:-1;75915:106:0;;;;;:::i;:::-;;:::i;33224:124::-;;;;;;;;;;-1:-1:-1;33224:124:0;;;;;:::i;:::-;;:::i;30424:206::-;;;;;;;;;;-1:-1:-1;30424:206:0;;;;;:::i;:::-;;:::i;2715:103::-;;;;;;;;;;;;;:::i;74603:1121::-;;;;;;;;;;-1:-1:-1;74603:1121:0;;;;;:::i;:::-;;:::i;76029:106::-;;;;;;;;;;-1:-1:-1;76029:106:0;;;;;:::i;:::-;;:::i;76638:1089::-;;;:::i;70424:48::-;;;;;;;;;;;;;;;2064:87;;;;;;;;;;-1:-1:-1;2110:7:0;2137:6;-1:-1:-1;;;;;2137:6:0;2064:87;;76463:167;;;;;;;;;;-1:-1:-1;76463:167:0;;;;;:::i;:::-;;:::i;:::-;;;;13570:13:1;;-1:-1:-1;;;;;13566:39:1;13548:58;;13666:4;13654:17;;;13648:24;13674:18;13644:49;13622:20;;;13615:79;13752:17;;;13746:24;13739:32;13732:40;13710:20;;;13703:70;13536:2;13521:18;76463:167:0;13503:276:1;73572:521:0;;;;;;:::i;:::-;;:::i;33584:104::-;;;;;;;;;;;;;:::i;35194:279::-;;;;;;;;;;-1:-1:-1;35194:279:0;;;;;:::i;:::-;;:::i;70668:46::-;;;;;;;;;;;;70703:11;70668:46;;76143:191;;;;;;;;;;;;;:::i;36272:342::-;;;;;;;;;;-1:-1:-1;36272:342:0;;;;;:::i;:::-;;:::i;70859:44::-;;;;;;;;;;-1:-1:-1;70859:44:0;;;;;;;;;;;;;;14138:4:1;14126:17;;;14108:36;;14096:2;14081:18;70859:44:0;14063:87:1;70555:48:0;;;;;;;;;;-1:-1:-1;70555:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;74418:177;;;;;;;;;;;;;:::i;33759:318::-;;;;;;;;;;-1:-1:-1;33759:318:0;;;;;:::i;:::-;;:::i;70479:35::-;;;;;;;;;;;;;;;76342:113;;;;;;;;;;-1:-1:-1;76342:113:0;;;;;:::i;:::-;;:::i;70610:49::-;;;;;;;;;;-1:-1:-1;70610:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;35544:164;;;;;;;;;;-1:-1:-1;35544:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;35665:25:0;;;35641:4;35665:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;35544:164;70723:32;;;;;;;;;;-1:-1:-1;70723:32:0;;;;;;;;2973:201;;;;;;;;;;-1:-1:-1;2973:201:0;;;;;:::i;:::-;;:::i;74252:160::-;;;;;;;;;;;;;:::i;30055:305::-;30157:4;-1:-1:-1;;;;;;30194:40:0;;-1:-1:-1;;;30194:40:0;;:105;;-1:-1:-1;;;;;;;30251:48:0;;-1:-1:-1;;;30251:48:0;30194:105;:158;;;-1:-1:-1;;;;;;;;;;26296:40:0;;;30316:36;30174:178;30055:305;-1:-1:-1;;30055:305:0:o;72093:878::-;72232:17;;;;;;;72224:53;;;;-1:-1:-1;;;72224:53:0;;8377:2:1;72224:53:0;;;8359:21:1;8416:2;8396:18;;;8389:30;8455:25;8435:18;;;8428:53;8498:18;;72224:53:0;;;;;;;;;72342:9;72310:28;70703:11;72310:28;;;:12;:28::i;:::-;:41;;72288:122;;;;-1:-1:-1;;;72288:122:0;;;;;;;:::i;:::-;72459:10;72423:17;72443:27;;;:15;:27;;;;;;:44;;72473:14;;72443:27;;:44;:::i;:::-;72521:27;;72423:64;;-1:-1:-1;72521:27:0;;;;;;;72506:42;;;;;72498:79;;;;-1:-1:-1;;;72498:79:0;;11365:2:1;72498:79:0;;;11347:21:1;11404:2;11384:18;;;11377:30;-1:-1:-1;;;11423:18:1;;;11416:54;11487:18;;72498:79:0;11337:174:1;72498:79:0;72615:28;;-1:-1:-1;;72632:10:0;5854:2:1;5850:15;5846:53;72615:28:0;;;5834:66:1;72590:12:0;;5916::1;;72615:28:0;;;;;;;;;;;;72605:39;;;;;;72590:54;;72677:50;72696:12;;72677:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;72710:10:0;;;-1:-1:-1;72722:4:0;;-1:-1:-1;72677:18:0;:50::i;:::-;:58;;72731:4;72677:58;72655:130;;;;-1:-1:-1;;;72655:130:0;;12079:2:1;72655:130:0;;;12061:21:1;12118:2;12098:18;;;12091:30;-1:-1:-1;;;12137:18:1;;;12130:52;12199:18;;72655:130:0;12051:172:1;72655:130:0;72814:10;72798:27;;;;:15;:27;;;;;:41;;-1:-1:-1;;72798:41:0;;;;;;;;;;;;72852:37;;72814:10;72852:37;;:9;:37::i;:::-;72935:10;72918:13;29948:12;;29932:13;;:28;;29712:271;72918:13;:27;;72910:53;;;;-1:-1:-1;;;72910:53:0;;;;;;;:::i;:::-;72093:878;;;;;:::o;33415:100::-;33469:13;33502:5;33495:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33415:100;:::o;34918:204::-;34986:7;35011:16;35019:7;35011;:16::i;:::-;35006:64;;35036:34;;-1:-1:-1;;;35036:34:0;;;;;;;;;;;35006:64;-1:-1:-1;35090:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;35090:24:0;;34918:204::o;34481:371::-;34554:13;34570:24;34586:7;34570:15;:24::i;:::-;34554:40;;34615:5;-1:-1:-1;;;;;34609:11:0;:2;-1:-1:-1;;;;;34609:11:0;;34605:48;;;34629:24;;-1:-1:-1;;;34629:24:0;;;;;;;;;;;34605:48;862:10;-1:-1:-1;;;;;34670:21:0;;;;;;:63;;-1:-1:-1;34696:37:0;34713:5;862:10;35544:164;:::i;34696:37::-;34695:38;34670:63;34666:138;;;34757:35;;-1:-1:-1;;;34757:35:0;;;;;;;;;;;34666:138;34816:28;34825:2;34829:7;34838:5;34816:8;:28::i;:::-;34481:371;;;:::o;71684:147::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;71740:10:::1;71748:1;71740:7;:10::i;:::-;71739:11;71731:57;;;::::0;-1:-1:-1;;;71731:57:0;;10963:2:1;71731:57:0::1;::::0;::::1;10945:21:1::0;11002:2;10982:18;;;10975:30;11041:34;11021:18;;;11014:62;-1:-1:-1;;;11092:18:1;;;11085:31;11133:19;;71731:57:0::1;10935:223:1::0;71731:57:0::1;71809:10;::::0;71799:24:::1;::::0;71809:10;;::::1;-1:-1:-1::0;;;;;71809:10:0::1;71821:1;71799:9;:24::i;:::-;71684:147::o:0;72979:585::-;73045:24;;;;;;;73037:75;;;;-1:-1:-1;;;73037:75:0;;;;;;;:::i;:::-;73143:9;70703:11;73131:21;;73123:65;;;;-1:-1:-1;;;73123:65:0;;;;;;;:::i;:::-;73221:25;73235:10;73221:13;:25::i;:::-;73199:119;;;;-1:-1:-1;;;73199:119:0;;9497:2:1;73199:119:0;;;9479:21:1;9536:2;9516:18;;;9509:30;9575:34;9555:18;;;9548:62;-1:-1:-1;;;9626:18:1;;;9619:42;9678:19;;73199:119:0;9469:234:1;73199:119:0;73357:10;73339:29;;;;:17;:29;;;;;;;;:38;73331:75;;;;-1:-1:-1;;;73331:75:0;;11365:2:1;73331:75:0;;;11347:21:1;11404:2;11384:18;;;11377:30;-1:-1:-1;;;11423:18:1;;;11416:54;11487:18;;73331:75:0;11337:174:1;73331:75:0;73435:10;73417:29;;;;:17;:29;;;;;:36;;-1:-1:-1;;73417:36:0;73449:4;73417:36;;;;;;73466:24;;73435:10;73466:9;:24::i;:::-;73528:10;73511:13;29948:12;;29932:13;;:28;;29712:271;73511:13;:27;;73503:53;;;;-1:-1:-1;;;73503:53:0;;;;;;;:::i;35775:170::-;35909:28;35919:4;35925:2;35929:7;35909:9;:28::i;71839:246::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;71926:10:::1;71934:1;71926:7;:10::i;:::-;71918:45;;;;-1:-1:-1::0;;;71918:45:0::1;;;;;;;:::i;:::-;71974:37;71984:10;71996:14;71974:9;:37::i;:::-;72047:10;72030:13;29948:12:::0;;29932:13;;:28;;29712:271;72030:13:::1;:27;;72022:53;;;;-1:-1:-1::0;;;72022:53:0::1;;;;;;;:::i;:::-;71839:246:::0;:::o;74101:145::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;74162:10:::1;74170:1;74162:7;:10::i;:::-;74154:45;;;;-1:-1:-1::0;;;74154:45:0::1;;;;;;;:::i;:::-;74226:12;::::0;;-1:-1:-1;;74210:28:0;::::1;74226:12;::::0;;::::1;74225:13;74210:28;::::0;;74101:145::o;36016:185::-;36154:39;36171:4;36177:2;36181:7;36154:39;;;;;;;;;;;;:16;:39::i;75915:106::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;75990:23:::1;:13;76006:7:::0;;75990:23:::1;:::i;33224:124::-:0;33288:7;33315:20;33327:7;33315:11;:20::i;:::-;:25;;33224:124;-1:-1:-1;;33224:124:0:o;30424:206::-;30488:7;-1:-1:-1;;;;;30512:19:0;;30508:60;;30540:28;;-1:-1:-1;;;30540:28:0;;;;;;;;;;;30508:60;-1:-1:-1;;;;;;30594:19:0;;;;;:12;:19;;;;;:27;;;;30424:206::o;2715:103::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;2780:30:::1;2807:1;2780:18;:30::i;74603:1121::-:0;75265:30;;-1:-1:-1;;;75265:30:0;;-1:-1:-1;;;;;7040:32:1;;75265:30:0;;;7022:51:1;74661:4:0;;74695:42;;74767;;74842;;74911;;74982;;75051;;75123;;75192;;74661:4;;74695:42;;75265:24;;6995:18:1;;75265:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;:87;;;-1:-1:-1;75316:32:0;;-1:-1:-1;;;75316:32:0;;-1:-1:-1;;;;;7040:32:1;;;75316::0;;;7022:51:1;75351:1:0;;75316:26;;;;;;6995:18:1;;75316:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;75265:87;:143;;;-1:-1:-1;75369:35:0;;-1:-1:-1;;;75369:35:0;;-1:-1:-1;;;;;7040:32:1;;;75369:35:0;;;7022:51:1;75407:1:0;;75369:29;;;;;;6995:18:1;;75369:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;75265:143;:193;;;-1:-1:-1;75425:29:0;;-1:-1:-1;;;75425:29:0;;-1:-1:-1;;;;;7040:32:1;;;75425:29:0;;;7022:51:1;75457:1:0;;75425:23;;;;;;6995:18:1;;75425:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;75265:193;:245;;;-1:-1:-1;75475:31:0;;-1:-1:-1;;;75475:31:0;;-1:-1:-1;;;;;7040:32:1;;;75475:31:0;;;7022:51:1;75509:1:0;;75475:25;;;;;;6995:18:1;;75475:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;75265:245;:296;;;-1:-1:-1;75527:30:0;;-1:-1:-1;;;75527:30:0;;-1:-1:-1;;;;;7040:32:1;;;75527:30:0;;;7022:51:1;75560:1:0;;75527:24;;;;;;6995:18:1;;75527:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;75265:296;:346;;;-1:-1:-1;75578:29:0;;-1:-1:-1;;;75578:29:0;;-1:-1:-1;;;;;7040:32:1;;;75578:29:0;;;7022:51:1;75610:1:0;;75578:23;;;;;;6995:18:1;;75578:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;75265:346;:400;;;-1:-1:-1;75629:32:0;;-1:-1:-1;;;75629:32:0;;-1:-1:-1;;;;;7040:32:1;;;75629::0;;;7022:51:1;75664:1:0;;75629:26;;;;;;6995:18:1;;75629:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;75265:400;:451;;;-1:-1:-1;75683:29:0;;-1:-1:-1;;;75683:29:0;;-1:-1:-1;;;;;7040:32:1;;;75683:29:0;;;7022:51:1;75715:1:0;;75683:23;;;;;;6995:18:1;;75683:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;75265:451;75245:471;74603:1121;-1:-1:-1;;;;;;;;;;74603:1121:0:o;76029:106::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;76103:10:::1;:24:::0;76029:106::o;76638:1089::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;76697:12:::1;76746:6;76713:29;:21;76737:5;76713:29;:::i;:::-;76712:40;;;;:::i;:::-;76697:55:::0;-1:-1:-1;76764:11:0::1;76812:6;76779:29;:21;76803:5;76779:29;:::i;:::-;76778:40;;;;:::i;:::-;76764:54:::0;-1:-1:-1;76830:11:0::1;76878:6;76845:29;:21;76869:5;76845:29;:::i;:::-;76844:40;;;;:::i;:::-;76830:54:::0;-1:-1:-1;76896:11:0::1;76944:6;76911:29;:21;76935:5;76911:29;:::i;:::-;76910:40;;;;:::i;:::-;76896:54:::0;-1:-1:-1;76962:13:0::1;77012:6;76979:29;:21;77003:5;76979:29;:::i;:::-;76978:40;;;;:::i;:::-;76962:56:::0;-1:-1:-1;77030:11:0::1;77078:6;77045:29;:21;77070:4;77045:29;:::i;:::-;77044:40;;;;:::i;:::-;77030:54:::0;-1:-1:-1;77096:12:0::1;77145:6;77112:29;:21;77137:4;77112:29;:::i;:::-;77111:40;;;;:::i;:::-;77096:55:::0;-1:-1:-1;77163:22:0::1;77222:6;77189:29;:21;77213:5;77189:29;:::i;:::-;77188:40;;;;:::i;:::-;77340:9;::::0;77332:29:::1;::::0;77163:65;;-1:-1:-1;;;;;;77340:9:0::1;::::0;77332:29;::::1;;;::::0;77356:4;;77340:9:::1;77332:29:::0;77340:9;77332:29;77356:4;77340:9;77332:29;::::1;;;;;;77324:38;;;::::0;::::1;;77389:10;::::0;77381:29:::1;::::0;77389:10;;;::::1;-1:-1:-1::0;;;;;77389:10:0::1;::::0;77381:29:::1;::::0;::::1;;::::0;;;::::1;::::0;;;;77389:10;77381:29;::::1;;;;;;77373:38;;;::::0;::::1;;77438:9;::::0;77430:28:::1;::::0;-1:-1:-1;;;;;77438:9:0;;::::1;::::0;77430:28;::::1;;;::::0;77454:3;;77438:9:::1;77430:28:::0;77438:9;77430:28;77454:3;77438:9;77430:28;::::1;;;;;;77422:37;;;::::0;::::1;;77486:9;::::0;77478:28:::1;::::0;-1:-1:-1;;;;;77486:9:0;;::::1;::::0;77478:28;::::1;;;::::0;77502:3;;77486:9:::1;77478:28:::0;77486:9;77478:28;77502:3;77486:9;77478:28;::::1;;;;;;77470:37;;;::::0;::::1;;77534:11;::::0;77526:32:::1;::::0;-1:-1:-1;;;;;77534:11:0;;::::1;::::0;77526:32;::::1;;;::::0;77552:5;;77534:11:::1;77526:32:::0;77534:11;77526:32;77552:5;77534:11;77526:32;::::1;;;;;;77518:41;;;::::0;::::1;;77586:12;::::0;77578:31:::1;::::0;-1:-1:-1;;;;;77586:12:0;;::::1;::::0;77578:31;::::1;;;::::0;77605:3;;77586:12:::1;77578:31:::0;77586:12;77578:31;77605:3;77586:12;77578:31;::::1;;;;;;77570:40;;;::::0;::::1;;77637:10;::::0;77629:30:::1;::::0;-1:-1:-1;;;;;77637:10:0;;::::1;::::0;77629:30;::::1;;;::::0;77654:4;;77637:10:::1;77629:30:::0;77637:10;77629:30;77654:4;77637:10;77629:30;::::1;;;;;;77621:39;;;::::0;::::1;;77687:9;::::0;77679:39:::1;::::0;-1:-1:-1;;;;;77687:9:0;;::::1;::::0;77679:39;::::1;;;::::0;77703:14;;77687:9:::1;77679:39:::0;77687:9;77679:39;77703:14;77687:9;77679:39;::::1;;;;;;77671:48;;;::::0;::::1;;2355:1;;;;;;;;76638:1089::o:0;76463:167::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;76602:20:0;76614:7;76602:11;:20::i;73572:521::-;73647:12;;;;73639:63;;;;-1:-1:-1;;;73639:63:0;;;;;;;:::i;:::-;73753:23;73735:14;:41;;73713:123;;;;-1:-1:-1;;;73713:123:0;;8729:2:1;73713:123:0;;;8711:21:1;;;8748:18;;;8741:30;8807:34;8787:18;;;8780:62;8859:18;;73713:123:0;8701:182:1;73713:123:0;73901:9;73869:28;70703:11;73882:14;73869:12;:28::i;:::-;:41;;73847:122;;;;-1:-1:-1;;;73847:122:0;;;;;;;:::i;33584:104::-;33640:13;33673:7;33666:14;;;;;:::i;35194:279::-;-1:-1:-1;;;;;35285:24:0;;862:10;35285:24;35281:54;;;35318:17;;-1:-1:-1;;;35318:17:0;;;;;;;;;;;35281:54;862:10;35348:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;35348:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;35348:53:0;;;;;;;;;;35417:48;;7717:41:1;;;35348:42:0;;862:10;35417:48;;7690:18:1;35417:48:0;;;;;;;35194:279;;:::o;76143:191::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;5352:1:::1;5950:7;;:19;;5942:63;;;::::0;-1:-1:-1;;;5942:63:0;;13182:2:1;5942:63:0::1;::::0;::::1;13164:21:1::0;13221:2;13201:18;;;13194:30;13260:33;13240:18;;;13233:61;13311:18;;5942:63:0::1;13154:181:1::0;5942:63:0::1;5352:1;6083:7;:18:::0;76230:49:::2;::::0;76212:12:::2;::::0;76230:10:::2;::::0;76253:21:::2;::::0;76212:12;76230:49;76212:12;76230:49;76253:21;76230:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76211:68;;;76298:7;76290:36;;;::::0;-1:-1:-1;;;76290:36:0;;12430:2:1;76290:36:0::2;::::0;::::2;12412:21:1::0;12469:2;12449:18;;;12442:30;-1:-1:-1;;;12488:18:1;;;12481:46;12544:18;;76290:36:0::2;12402:166:1::0;76290:36:0::2;-1:-1:-1::0;5308:1:0::1;6262:7;:22:::0;76143:191::o;36272:342::-;36439:28;36449:4;36455:2;36459:7;36439:9;:28::i;:::-;36483:48;36506:4;36512:2;36516:7;36525:5;36483:22;:48::i;:::-;36478:129;;36555:40;;-1:-1:-1;;;36555:40:0;;;;;;;;;;;36478:129;36272:342;;;;:::o;74418:177::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;74487:10:::1;74495:1;74487:7;:10::i;:::-;74479:45;;;;-1:-1:-1::0;;;74479:45:0::1;;;;;;;:::i;:::-;74563:24;::::0;;-1:-1:-1;;74535:52:0;::::1;74563:24:::0;;;;::::1;;;74562:25;74535:52:::0;;::::1;;::::0;;74418:177::o;33759:318::-;33832:13;33863:16;33871:7;33863;:16::i;:::-;33858:59;;33888:29;;-1:-1:-1;;;33888:29:0;;;;;;;;;;;33858:59;33930:21;33954:10;:8;:10::i;:::-;33930:34;;33988:7;33982:21;34007:1;33982:26;;:87;;;;;;;;;;;;;;;;;34035:7;34044:18;:7;:16;:18::i;:::-;34018:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;33982:87;33975:94;33759:318;-1:-1:-1;;;33759:318:0:o;76342:113::-;76400:7;76427:20;76441:5;76427:13;:20::i;2973:201::-;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3062:22:0;::::1;3054:73;;;::::0;-1:-1:-1;;;3054:73:0;;9090:2:1;3054:73:0::1;::::0;::::1;9072:21:1::0;9129:2;9109:18;;;9102:30;9168:34;9148:18;;;9141:62;-1:-1:-1;;;9219:18:1;;;9212:36;9265:19;;3054:73:0::1;9062:228:1::0;3054:73:0::1;3138:28;3157:8;3138:18;:28::i;74252:160::-:0;2110:7;2137:6;-1:-1:-1;;;;;2137:6:0;862:10;2284:23;2276:68;;;;-1:-1:-1;;;2276:68:0;;;;;;;:::i;:::-;74318:10:::1;74326:1;74318:7;:10::i;:::-;74310:45;;;;-1:-1:-1::0;;;74310:45:0::1;;;;;;;:::i;:::-;74387:17;::::0;;-1:-1:-1;;74366:38:0;::::1;74387:17;::::0;;;::::1;;;74386:18;74366:38:::0;;::::1;;::::0;;74252:160::o;52999:98::-;53057:7;53084:5;53088:1;53084;:5;:::i;48131:190::-;48256:4;48309;48280:25;48293:5;48300:4;48280:12;:25::i;:::-;:33;;48131:190;-1:-1:-1;;;;48131:190:0:o;37021:104::-;37090:27;37100:2;37104:8;37090:27;;;;;;;;;;;;:9;:27::i;:::-;37021:104;;:::o;36869:144::-;36926:4;36960:13;;36950:7;:23;:55;;;;-1:-1:-1;;36978:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;36978:27:0;;;;36977:28;;36869:144::o;44075:196::-;44190:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;44190:29:0;-1:-1:-1;;;;;44190:29:0;;;;;;;;;44235:28;;44190:24;;44235:28;;;;;;;44075:196;;;:::o;39576:2112::-;39691:35;39729:20;39741:7;39729:11;:20::i;:::-;39804:18;;39691:58;;-1:-1:-1;39762:22:0;;-1:-1:-1;;;;;39788:34:0;862:10;-1:-1:-1;;;;;39788:34:0;;:101;;;-1:-1:-1;39856:18:0;;39839:50;;862:10;35544:164;:::i;39839:50::-;39788:154;;;-1:-1:-1;862:10:0;39906:20;39918:7;39906:11;:20::i;:::-;-1:-1:-1;;;;;39906:36:0;;39788:154;39762:181;;39961:17;39956:66;;39987:35;;-1:-1:-1;;;39987:35:0;;;;;;;;;;;39956:66;40059:4;-1:-1:-1;;;;;40037:26:0;:13;:18;;;-1:-1:-1;;;;;40037:26:0;;40033:67;;40072:28;;-1:-1:-1;;;40072:28:0;;;;;;;;;;;40033:67;-1:-1:-1;;;;;40115:16:0;;40111:52;;40140:23;;-1:-1:-1;;;40140:23:0;;;;;;;;;;;40111:52;40284:49;40301:1;40305:7;40314:13;:18;;;40284:8;:49::i;:::-;-1:-1:-1;;;;;40629:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;40629:31:0;;;;;;;-1:-1:-1;;40629:31:0;;;;;;;40675:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;40675:29:0;;;;;;;;;;;40721:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;40766:61:0;;;;-1:-1:-1;;;40811:15:0;40766:61;;;;;;;;;;;41101:11;;;41131:24;;;;;:29;41101:11;;41131:29;41127:445;;41356:13;;41342:11;:27;41338:219;;;41426:18;;;41394:24;;;:11;:24;;;;;;;;:50;;41509:28;;;;41467:70;;-1:-1:-1;;;41467:70:0;-1:-1:-1;;;;;;41467:70:0;;;-1:-1:-1;;;;;41394:50:0;;;41467:70;;;;;;;41338:219;39576:2112;41619:7;41615:2;-1:-1:-1;;;;;41600:27:0;41609:4;-1:-1:-1;;;;;41600:27:0;;;;;;;;;;;41638:42;36272:342;32079:1083;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;32245:13:0;;32189:7;;32238:20;;32234:861;;;32279:31;32313:17;;;:11;:17;;;;;;;;;32279:51;;;;;;;;;-1:-1:-1;;;;;32279:51:0;;;;-1:-1:-1;;;32279:51:0;;;;;;;;;;;-1:-1:-1;;;32279:51:0;;;;;;;;;;;;;;32349:731;;32399:14;;-1:-1:-1;;;;;32399:28:0;;32395:101;;32463:9;32079:1083;-1:-1:-1;;;32079:1083:0:o;32395:101::-;-1:-1:-1;;;32840:6:0;32885:17;;;;:11;:17;;;;;;;;;32873:29;;;;;;;;;-1:-1:-1;;;;;32873:29:0;;;;;-1:-1:-1;;;32873:29:0;;;;;;;;;;;-1:-1:-1;;;32873:29:0;;;;;;;;;;;;;32933:28;32929:109;;33001:9;32079:1083;-1:-1:-1;;;32079:1083:0:o;32929:109::-;32800:261;;;32234:861;;33123:31;;-1:-1:-1;;;33123:31:0;;;;;;;;;;;3334:191;3408:16;3427:6;;-1:-1:-1;;;;;3444:17:0;;;-1:-1:-1;;;;;;3444:17:0;;;;;;3477:40;;3427:6;;;;;;;3477:40;;3408:16;3477:40;3334:191;;:::o;44836:790::-;44991:4;-1:-1:-1;;;;;45012:13:0;;16180:20;16228:8;45008:611;;45048:72;;-1:-1:-1;;;45048:72:0;;-1:-1:-1;;;;;45048:36:0;;;;;:72;;862:10;;45099:4;;45105:7;;45114:5;;45048:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45048:72:0;;;;;;;;-1:-1:-1;;45048:72:0;;;;;;;;;;;;:::i;:::-;;;45044:520;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45294:13:0;;45290:259;;45344:40;;-1:-1:-1;;;45344:40:0;;;;;;;;;;;45290:259;45499:6;45493:13;45484:6;45480:2;45476:15;45469:38;45044:520;-1:-1:-1;;;;;;45171:55:0;-1:-1:-1;;;45171:55:0;;-1:-1:-1;45164:62:0;;45008:611;-1:-1:-1;45603:4:0;45008:611;44836:790;;;;;;:::o;75793:114::-;75853:13;75886;75879:20;;;;;:::i;23559:723::-;23615:13;23836:10;23832:53;;-1:-1:-1;;23863:10:0;;;;;;;;;;;;-1:-1:-1;;;23863:10:0;;;;;23559:723::o;23832:53::-;23910:5;23895:12;23951:78;23958:9;;23951:78;;23984:8;;;;:::i;:::-;;-1:-1:-1;24007:10:0;;-1:-1:-1;24015:2:0;24007:10;;:::i;:::-;;;23951:78;;;24039:19;24071:6;24061:17;;;;;;-1:-1:-1;;;24061:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24061:17:0;;24039:39;;24089:154;24096:10;;24089:154;;24123:11;24133:1;24123:11;;:::i;:::-;;-1:-1:-1;24192:10:0;24200:2;24192:5;:10;:::i;:::-;24179:24;;:2;:24;:::i;:::-;24166:39;;24149:6;24156;24149:14;;;;;;-1:-1:-1;;;24149:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;24149:56:0;;;;;;;;-1:-1:-1;24220:11:0;24229:2;24220:11;;:::i;:::-;;;24089:154;;30712:207;30773:7;-1:-1:-1;;;;;30797:19:0;;30793:59;;30825:27;;-1:-1:-1;;;30825:27:0;;;;;;;;;;;30793:59;-1:-1:-1;;;;;;30878:19:0;;;;;:12;:19;;;;;:32;-1:-1:-1;;;30878:32:0;;;;;30712:207::o;48683:701::-;48766:7;48809:4;48766:7;48824:523;48848:5;:12;48844:1;:16;48824:523;;;48882:20;48905:5;48911:1;48905:8;;;;;;-1:-1:-1;;;48905:8:0;;;;;;;;;;;;;;;48882:31;;48948:12;48932;:28;48928:408;;49085:44;;;;;;6096:19:1;;;6131:12;;;6124:28;;;6168:12;;49085:44:0;;;;;;;;;;;;49075:55;;;;;;49060:70;;48928:408;;;49275:44;;;;;;6096:19:1;;;6131:12;;;6124:28;;;6168:12;;49275:44:0;;;;;;;;;;;;49265:55;;;;;;49250:70;;48928:408;-1:-1:-1;48862:3:0;;;;:::i;:::-;;;;48824:523;;;-1:-1:-1;49364:12:0;48683:701;-1:-1:-1;;;48683:701:0:o;37488:163::-;37611:32;37617:2;37621:8;37631:5;37638:4;38072:13;;-1:-1:-1;;;;;38100:16:0;;38096:48;;38125:19;;-1:-1:-1;;;38125:19:0;;;;;;;;;;;38096:48;38159:13;38155:44;;38181:18;;-1:-1:-1;;;38181:18:0;;;;;;;;;;;38155:44;-1:-1:-1;;;;;38550:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;38609:49:0;;38550:44;;;;;;;;38609:49;;;-1:-1:-1;;;;;38550:44:0;;;;;;38609:49;;;;;;;;;;;;;;;;38675:25;;;:11;:25;;;;;:35;;-1:-1:-1;;;;;;38725:66:0;;;;-1:-1:-1;;;38775:15:0;38725:66;;;;;;;;;;;38675:25;;38860:328;38880:8;38876:1;:12;38860:328;;;38919:38;;38944:12;;-1:-1:-1;;;;;38919:38:0;;;38936:1;;38919:38;;38936:1;;38919:38;38980:4;:68;;;;;38989:59;39020:1;39024:2;39028:12;39042:5;38989:22;:59::i;:::-;38988:60;38980:68;38976:164;;;39080:40;;-1:-1:-1;;;39080:40:0;;;;;;;;;;;38976:164;39158:14;;;;;38890:3;38860:328;;;-1:-1:-1;39204:13:0;:28;39254:60;36272:342;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:196::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;393:270::-;461:6;469;522:2;510:9;501:7;497:23;493:32;490:2;;;543:6;535;528:22;490:2;571:29;590:9;571:29;:::i;:::-;561:39;;619:38;653:2;642:9;638:18;619:38;:::i;:::-;609:48;;480:183;;;;;:::o;668:338::-;745:6;753;761;814:2;802:9;793:7;789:23;785:32;782:2;;;835:6;827;820:22;782:2;863:29;882:9;863:29;:::i;:::-;853:39;;911:38;945:2;934:9;930:18;911:38;:::i;:::-;901:48;;996:2;985:9;981:18;968:32;958:42;;772:234;;;;;:::o;1011:1183::-;1106:6;1114;1122;1130;1183:3;1171:9;1162:7;1158:23;1154:33;1151:2;;;1205:6;1197;1190:22;1151:2;1233:29;1252:9;1233:29;:::i;:::-;1223:39;;1281:38;1315:2;1304:9;1300:18;1281:38;:::i;:::-;1271:48;;1366:2;1355:9;1351:18;1338:32;1328:42;;1421:2;1410:9;1406:18;1393:32;1444:18;1485:2;1477:6;1474:14;1471:2;;;1506:6;1498;1491:22;1471:2;1549:6;1538:9;1534:22;1524:32;;1594:7;1587:4;1583:2;1579:13;1575:27;1565:2;;1621:6;1613;1606:22;1565:2;1662;1649:16;1684:2;1680;1677:10;1674:2;;;1690:18;;:::i;:::-;1765:2;1759:9;1733:2;1819:13;;-1:-1:-1;;1815:22:1;;;1839:2;1811:31;1807:40;1795:53;;;1863:18;;;1883:22;;;1860:46;1857:2;;;1909:18;;:::i;:::-;1949:10;1945:2;1938:22;1984:2;1976:6;1969:18;2024:7;2019:2;2014;2010;2006:11;2002:20;1999:33;1996:2;;;2050:6;2042;2035:22;1996:2;2111;2106;2102;2098:11;2093:2;2085:6;2081:15;2068:46;2134:15;;;2151:2;2130:24;2123:40;;;;1141:1053;;;;-1:-1:-1;1141:1053:1;;-1:-1:-1;;;;1141:1053:1:o;2199:367::-;2264:6;2272;2325:2;2313:9;2304:7;2300:23;2296:32;2293:2;;;2346:6;2338;2331:22;2293:2;2374:29;2393:9;2374:29;:::i;:::-;2364:39;;2453:2;2442:9;2438:18;2425:32;2500:5;2493:13;2486:21;2479:5;2476:32;2466:2;;2527:6;2519;2512:22;2466:2;2555:5;2545:15;;;2283:283;;;;;:::o;2571:264::-;2639:6;2647;2700:2;2688:9;2679:7;2675:23;2671:32;2668:2;;;2721:6;2713;2706:22;2668:2;2749:29;2768:9;2749:29;:::i;:::-;2739:39;2825:2;2810:18;;;;2797:32;;-1:-1:-1;;;2658:177:1:o;2840:838::-;2933:6;2941;2949;3002:2;2990:9;2981:7;2977:23;2973:32;2970:2;;;3023:6;3015;3008:22;2970:2;3068:9;3055:23;3097:18;3138:2;3130:6;3127:14;3124:2;;;3159:6;3151;3144:22;3124:2;3202:6;3191:9;3187:22;3177:32;;3247:7;3240:4;3236:2;3232:13;3228:27;3218:2;;3274:6;3266;3259:22;3218:2;3319;3306:16;3345:2;3337:6;3334:14;3331:2;;;3366:6;3358;3351:22;3331:2;3426:7;3419:4;3409:6;3406:1;3402:14;3398:2;3394:23;3390:34;3387:47;3384:2;;;3452:6;3444;3437:22;3384:2;3488:4;3480:13;;;;-1:-1:-1;3512:6:1;-1:-1:-1;;3553:20:1;;3540:34;3614:4;3603:16;;3593:27;;3583:2;;3639:6;3631;3624:22;3583:2;3667:5;3657:15;;;2960:718;;;;;:::o;3683:190::-;3742:6;3795:2;3783:9;3774:7;3770:23;3766:32;3763:2;;;3816:6;3808;3801:22;3763:2;-1:-1:-1;3844:23:1;;3753:120;-1:-1:-1;3753:120:1:o;3878:255::-;3936:6;3989:2;3977:9;3968:7;3964:23;3960:32;3957:2;;;4010:6;4002;3995:22;3957:2;4054:9;4041:23;4073:30;4097:5;4073:30;:::i;4138:259::-;4207:6;4260:2;4248:9;4239:7;4235:23;4231:32;4228:2;;;4281:6;4273;4266:22;4228:2;4318:9;4312:16;4337:30;4361:5;4337:30;:::i;4402:642::-;4473:6;4481;4534:2;4522:9;4513:7;4509:23;4505:32;4502:2;;;4555:6;4547;4540:22;4502:2;4600:9;4587:23;4629:18;4670:2;4662:6;4659:14;4656:2;;;4691:6;4683;4676:22;4656:2;4734:6;4723:9;4719:22;4709:32;;4779:7;4772:4;4768:2;4764:13;4760:27;4750:2;;4806:6;4798;4791:22;4750:2;4851;4838:16;4877:2;4869:6;4866:14;4863:2;;;4898:6;4890;4883:22;4863:2;4948:7;4943:2;4934:6;4930:2;4926:15;4922:24;4919:37;4916:2;;;4974:6;4966;4959:22;4916:2;5010;5002:11;;;;;5032:6;;-1:-1:-1;4492:552:1;;-1:-1:-1;;;;4492:552:1:o;5244:194::-;5314:6;5367:2;5355:9;5346:7;5342:23;5338:32;5335:2;;;5388:6;5380;5373:22;5335:2;-1:-1:-1;5416:16:1;;5325:113;-1:-1:-1;5325:113:1:o;5443:257::-;5484:3;5522:5;5516:12;5549:6;5544:3;5537:19;5565:63;5621:6;5614:4;5609:3;5605:14;5598:4;5591:5;5587:16;5565:63;:::i;:::-;5682:2;5661:15;-1:-1:-1;;5657:29:1;5648:39;;;;5689:4;5644:50;;5492:208;-1:-1:-1;;5492:208:1:o;6191:470::-;6370:3;6408:6;6402:13;6424:53;6470:6;6465:3;6458:4;6450:6;6446:17;6424:53;:::i;:::-;6540:13;;6499:16;;;;6562:57;6540:13;6499:16;6596:4;6584:17;;6562:57;:::i;:::-;6635:20;;6378:283;-1:-1:-1;;;;6378:283:1:o;7084:488::-;-1:-1:-1;;;;;7353:15:1;;;7335:34;;7405:15;;7400:2;7385:18;;7378:43;7452:2;7437:18;;7430:34;;;7500:3;7495:2;7480:18;;7473:31;;;7278:4;;7521:45;;7546:19;;7538:6;7521:45;:::i;:::-;7513:53;7287:285;-1:-1:-1;;;;;;7287:285:1:o;7951:219::-;8100:2;8089:9;8082:21;8063:4;8120:44;8160:2;8149:9;8145:18;8137:6;8120:44;:::i;9708:346::-;9910:2;9892:21;;;9949:2;9929:18;;;9922:30;-1:-1:-1;;;9983:2:1;9968:18;;9961:52;10045:2;10030:18;;9882:172::o;10059:337::-;10261:2;10243:21;;;10300:2;10280:18;;;10273:30;-1:-1:-1;;;10334:2:1;10319:18;;10312:43;10387:2;10372:18;;10233:163::o;10401:355::-;10603:2;10585:21;;;10642:2;10622:18;;;10615:30;10681:33;10676:2;10661:18;;10654:61;10747:2;10732:18;;10575:181::o;11516:356::-;11718:2;11700:21;;;11737:18;;;11730:30;11796:34;11791:2;11776:18;;11769:62;11863:2;11848:18;;11690:182::o;12573:402::-;12775:2;12757:21;;;12814:2;12794:18;;;12787:30;12853:34;12848:2;12833:18;;12826:62;-1:-1:-1;;;12919:2:1;12904:18;;12897:36;12965:3;12950:19;;12747:228::o;14155:128::-;14195:3;14226:1;14222:6;14219:1;14216:13;14213:2;;;14232:18;;:::i;:::-;-1:-1:-1;14268:9:1;;14203:80::o;14288:204::-;14326:3;14362:4;14359:1;14355:12;14394:4;14391:1;14387:12;14429:3;14423:4;14419:14;14414:3;14411:23;14408:2;;;14437:18;;:::i;:::-;14473:13;;14334:158;-1:-1:-1;;;14334:158:1:o;14497:120::-;14537:1;14563;14553:2;;14568:18;;:::i;:::-;-1:-1:-1;14602:9:1;;14543:74::o;14622:168::-;14662:7;14728:1;14724;14720:6;14716:14;14713:1;14710:21;14705:1;14698:9;14691:17;14687:45;14684:2;;;14735:18;;:::i;:::-;-1:-1:-1;14775:9:1;;14674:116::o;14795:125::-;14835:4;14863:1;14860;14857:8;14854:2;;;14868:18;;:::i;:::-;-1:-1:-1;14905:9:1;;14844:76::o;14925:258::-;14997:1;15007:113;15021:6;15018:1;15015:13;15007:113;;;15097:11;;;15091:18;15078:11;;;15071:39;15043:2;15036:10;15007:113;;;15138:6;15135:1;15132:13;15129:2;;;-1:-1:-1;;15173:1:1;15155:16;;15148:27;14978:205::o;15188:380::-;15267:1;15263:12;;;;15310;;;15331:2;;15385:4;15377:6;15373:17;15363:27;;15331:2;15438;15430:6;15427:14;15407:18;15404:38;15401:2;;;15484:10;15479:3;15475:20;15472:1;15465:31;15519:4;15516:1;15509:15;15547:4;15544:1;15537:15;15401:2;;15243:325;;;:::o;15573:135::-;15612:3;-1:-1:-1;;15633:17:1;;15630:2;;;15653:18;;:::i;:::-;-1:-1:-1;15700:1:1;15689:13;;15620:88::o;15713:112::-;15745:1;15771;15761:2;;15776:18;;:::i;:::-;-1:-1:-1;15810:9:1;;15751:74::o;15830:127::-;15891:10;15886:3;15882:20;15879:1;15872:31;15922:4;15919:1;15912:15;15946:4;15943:1;15936:15;15962:127;16023:10;16018:3;16014:20;16011:1;16004:31;16054:4;16051:1;16044:15;16078:4;16075:1;16068:15;16094:127;16155:10;16150:3;16146:20;16143:1;16136:31;16186:4;16183:1;16176:15;16210:4;16207:1;16200:15;16226:131;-1:-1:-1;;;;;;16300:32:1;;16290:43;;16280:2;;16347:1;16344;16337:12

Swarm Source

ipfs://e37999c159323418cf4376f1881b2c965dd7ff737ff22c3466d200cb438754e7

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