Token

Bongler (BNGLR)

ERC-721

Overview

Max Total Supply

401 BNGLR

Holders

336

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x2a7187337a4c1fac833b89fa2968c3e8de09c1cd

Filtered by Token Holder

0x915782DB070B286375C4B757f63fC9a81c3E93F7

nielsderuiter.eth

Balance

1 BNGLR

0x915782db070b286375c4b757f63fc9a81c3e93f7

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

BonglerNFT

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-04-20
*/

// SPDX-License-Identifier: MIT

// Sources flattened with hardhat v2.12.6 https://hardhat.org

// 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 (last updated v4.7.0) (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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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


// File @openzeppelin/contracts/utils/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 (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[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/[email protected]


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

pragma solidity ^0.8.0;

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


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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


// 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 @openzeppelin/contracts/utils/math/[email protected]


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


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


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

pragma solidity ^0.8.0;







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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

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

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

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

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

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

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

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

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {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 an {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 Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}


// File erc721a/contracts/[email protected]


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of ERC721A.
 */
interface IERC721A {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    /**
     * The `quantity` minted with ERC2309 exceeds the safety limit.
     */
    error MintERC2309QuantityExceedsLimit();

    /**
     * The `extraData` cannot be set on an unintialized ownership slot.
     */
    error OwnershipNotInitializedForExtraData();

    // =============================================================
    //                            STRUCTS
    // =============================================================

    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Stores the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
        uint24 extraData;
    }

    // =============================================================
    //                         TOKEN COUNTERS
    // =============================================================

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() external view returns (uint256);

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);

    // =============================================================
    //                            IERC721
    // =============================================================

    /**
     * @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,
        bytes calldata data
    ) external payable;

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external payable;

    /**
     * @dev Transfers `tokenId` 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 payable;

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

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

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

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

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

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

    // =============================================================
    //                           IERC2309
    // =============================================================

    /**
     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}


// File erc721a/contracts/[email protected]


// ERC721A Contracts v4.2.3
// Creator: Chiru Labs

pragma solidity ^0.8.4;

/**
 * @dev Interface of ERC721 token receiver.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

/**
 * @title ERC721A
 *
 * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
 * Non-Fungible Token Standard, including the Metadata extension.
 * Optimized for lower gas during batch mints.
 *
 * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
 * starting from `_startTokenId()`.
 *
 * Assumptions:
 *
 * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
    // Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
    struct TokenApprovalRef {
        address value;
    }

    // =============================================================
    //                           CONSTANTS
    // =============================================================

    // Mask of an entry in packed address data.
    uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;

    // The bit position of `numberMinted` in packed address data.
    uint256 private constant _BITPOS_NUMBER_MINTED = 64;

    // The bit position of `numberBurned` in packed address data.
    uint256 private constant _BITPOS_NUMBER_BURNED = 128;

    // The bit position of `aux` in packed address data.
    uint256 private constant _BITPOS_AUX = 192;

    // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
    uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;

    // The bit position of `startTimestamp` in packed ownership.
    uint256 private constant _BITPOS_START_TIMESTAMP = 160;

    // The bit mask of the `burned` bit in packed ownership.
    uint256 private constant _BITMASK_BURNED = 1 << 224;

    // The bit position of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;

    // The bit mask of the `nextInitialized` bit in packed ownership.
    uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;

    // The bit position of `extraData` in packed ownership.
    uint256 private constant _BITPOS_EXTRA_DATA = 232;

    // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
    uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;

    // The maximum `quantity` that can be minted with {_mintERC2309}.
    // This limit is to prevent overflows on the address data entries.
    // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
    // is required to cause an overflow, which is unrealistic.
    uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;

    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // =============================================================
    //                            STORAGE
    // =============================================================

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // The number of tokens burned.
    uint256 private _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 {_packedOwnershipOf} implementation for details.
    //
    // Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `startTimestamp`
    // - [224]      `burned`
    // - [225]      `nextInitialized`
    // - [232..255] `extraData`
    mapping(uint256 => uint256) private _packedOwnerships;

    // Mapping owner address to address data.
    //
    // Bits Layout:
    // - [0..63]    `balance`
    // - [64..127]  `numberMinted`
    // - [128..191] `numberBurned`
    // - [192..255] `aux`
    mapping(address => uint256) private _packedAddressData;

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

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

    // =============================================================
    //                          CONSTRUCTOR
    // =============================================================

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

    // =============================================================
    //                   TOKEN COUNTING OPERATIONS
    // =============================================================

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view virtual returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than `_currentIndex - _startTokenId()` times.
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view virtual returns (uint256) {
        // Counter underflow is impossible as `_currentIndex` does not decrement,
        // and it is initialized to `_startTokenId()`.
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev Returns the total number of tokens burned.
     */
    function _totalBurned() internal view virtual returns (uint256) {
        return _burnCounter;
    }

    // =============================================================
    //                    ADDRESS DATA OPERATIONS
    // =============================================================

    /**
     * @dev Returns the number of tokens in `owner`'s account.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
    }

    /**
     * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
    }

    /**
     * Sets the auxiliary 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 virtual {
        uint256 packed = _packedAddressData[owner];
        uint256 auxCasted;
        // Cast `aux` with assembly to avoid redundant masking.
        assembly {
            auxCasted := aux
        }
        packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
        _packedAddressData[owner] = packed;
    }

    // =============================================================
    //                            IERC165
    // =============================================================

    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        // The interface IDs are constants representing the first 4 bytes
        // of the XOR of all function selectors in the interface.
        // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
        // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
        return
            interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
    }

    // =============================================================
    //                        IERC721Metadata
    // =============================================================

    /**
     * @dev Returns the token collection name.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    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, _toString(tokenId))) : '';
    }

    /**
     * @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, it can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    // =============================================================
    //                     OWNERSHIPS OPERATIONS
    // =============================================================

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return address(uint160(_packedOwnershipOf(tokenId)));
    }

    /**
     * @dev Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around over time.
     */
    function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnershipOf(tokenId));
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct at `index`.
     */
    function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
        return _unpackedOwnership(_packedOwnerships[index]);
    }

    /**
     * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
    function _initializeOwnershipAt(uint256 index) internal virtual {
        if (_packedOwnerships[index] == 0) {
            _packedOwnerships[index] = _packedOwnershipOf(index);
        }
    }

    /**
     * Returns the packed ownership data of `tokenId`.
     */
    function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr)
                if (curr < _currentIndex) {
                    uint256 packed = _packedOwnerships[curr];
                    // If not burned.
                    if (packed & _BITMASK_BURNED == 0) {
                        // Invariant:
                        // There will always be an initialized ownership slot
                        // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
                        // before an unintialized ownership slot
                        // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
                        // Hence, `curr` will not underflow.
                        //
                        // We can directly compare the packed value.
                        // If the address is zero, packed will be zero.
                        while (packed == 0) {
                            packed = _packedOwnerships[--curr];
                        }
                        return packed;
                    }
                }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
     */
    function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
        ownership.addr = address(uint160(packed));
        ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
        ownership.burned = packed & _BITMASK_BURNED != 0;
        ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
    }

    /**
     * @dev Packs ownership data into a single uint256.
     */
    function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
            result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
        }
    }

    /**
     * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
    function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
        // For branchless setting of the `nextInitialized` flag.
        assembly {
            // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
            result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
        }
    }

    // =============================================================
    //                      APPROVAL OPERATIONS
    // =============================================================

    /**
     * @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) public payable virtual override {
        address owner = ownerOf(tokenId);

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

        _tokenApprovals[tokenId].value = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId].value;
    }

    /**
     * @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) public virtual override {
        _operatorApprovals[_msgSenderERC721A()][operator] = approved;
        emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
    }

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

    /**
     * @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. See {_mint}.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return
            _startTokenId() <= tokenId &&
            tokenId < _currentIndex && // If within bounds,
            _packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
    }

    /**
     * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
     */
    function _isSenderApprovedOrOwner(
        address approvedAddress,
        address owner,
        address msgSender
    ) private pure returns (bool result) {
        assembly {
            // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
            owner := and(owner, _BITMASK_ADDRESS)
            // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
            msgSender := and(msgSender, _BITMASK_ADDRESS)
            // `msgSender == owner || msgSender == approvedAddress`.
            result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
        }
    }

    /**
     * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
    function _getApprovedSlotAndAddress(uint256 tokenId)
        private
        view
        returns (uint256 approvedAddressSlot, address approvedAddress)
    {
        TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
        // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
        assembly {
            approvedAddressSlot := tokenApproval.slot
            approvedAddress := sload(approvedAddressSlot)
        }
    }

    // =============================================================
    //                      TRANSFER OPERATIONS
    // =============================================================

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) public payable virtual override {
        uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

        if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        // The nested ifs save around 20+ gas over a compound boolean condition.
        if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
            if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();

        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // We can directly increment and decrement the balances.
            --_packedAddressData[from]; // Updates: `balance -= 1`.
            ++_packedAddressData[to]; // Updates: `balance += 1`.

            // Updates:
            // - `address` to the next owner.
            // - `startTimestamp` to the timestamp of transfering.
            // - `burned` to `false`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                to,
                _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

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

    /**
     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public payable virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }

    /**
     * @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 memory _data
    ) public payable virtual override {
        transferFrom(from, to, tokenId);
        if (to.code.length != 0)
            if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                revert TransferToNonERC721ReceiverImplementer();
            }
    }

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

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * `from` - Previous owner of the given token ID.
     * `to` - Target address that will receive the token.
     * `tokenId` - Token ID to be transferred.
     * `_data` - Optional data to send along with the call.
     *
     * Returns whether the call correctly returned the expected magic value.
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
            bytes4 retval
        ) {
            return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    // =============================================================
    //                        MINT OPERATIONS
    // =============================================================

    /**
     * @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 for each mint.
     */
    function _mint(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // `balance` and `numberMinted` have a maximum limit of 2**64.
        // `tokenId` has a maximum limit of 2**256.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            uint256 toMasked;
            uint256 end = startTokenId + quantity;

            // Use assembly to loop and emit the `Transfer` event for gas savings.
            // The duplicated `log4` removes an extra check and reduces stack juggling.
            // The assembly, together with the surrounding Solidity code, have been
            // delicately arranged to nudge the compiler into producing optimized opcodes.
            assembly {
                // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                toMasked := and(to, _BITMASK_ADDRESS)
                // Emit the `Transfer` event.
                log4(
                    0, // Start of data (0, since no data).
                    0, // End of data (0, since no data).
                    _TRANSFER_EVENT_SIGNATURE, // Signature.
                    0, // `address(0)`.
                    toMasked, // `to`.
                    startTokenId // `tokenId`.
                )

                // The `iszero(eq(,))` check ensures that large values of `quantity`
                // that overflows uint256 will make the loop run out of gas.
                // The compiler will optimize the `iszero` away for performance.
                for {
                    let tokenId := add(startTokenId, 1)
                } iszero(eq(tokenId, end)) {
                    tokenId := add(tokenId, 1)
                } {
                    // Emit the `Transfer` event. Similar to above.
                    log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
                }
            }
            if (toMasked == 0) revert MintToZeroAddress();

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

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
    function _mintERC2309(address to, uint256 quantity) internal virtual {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();
        if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();

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

        // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
        unchecked {
            // Updates:
            // - `balance += quantity`.
            // - `numberMinted += quantity`.
            //
            // We can directly add to the `balance` and `numberMinted`.
            _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);

            // Updates:
            // - `address` to the owner.
            // - `startTimestamp` to the timestamp of minting.
            // - `burned` to `false`.
            // - `nextInitialized` to `quantity == 1`.
            _packedOwnerships[startTokenId] = _packOwnershipData(
                to,
                _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
            );

            emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);

            _currentIndex = startTokenId + quantity;
        }
        _afterTokenTransfers(address(0), to, startTokenId, 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.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal virtual {
        _mint(to, quantity);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal virtual {
        _safeMint(to, quantity, '');
    }

    // =============================================================
    //                        BURN OPERATIONS
    // =============================================================

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

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

        address from = address(uint160(prevOwnershipPacked));

        (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);

        if (approvalCheck) {
            // The nested ifs save around 20+ gas over a compound boolean condition.
            if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner.
        assembly {
            if approvedAddress {
                // This is equivalent to `delete _tokenApprovals[tokenId]`.
                sstore(approvedAddressSlot, 0)
            }
        }

        // 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 {
            // Updates:
            // - `balance -= 1`.
            // - `numberBurned += 1`.
            //
            // We can directly decrement the balance, and increment the number burned.
            // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
            _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;

            // Updates:
            // - `address` to the last owner.
            // - `startTimestamp` to the timestamp of burning.
            // - `burned` to `true`.
            // - `nextInitialized` to `true`.
            _packedOwnerships[tokenId] = _packOwnershipData(
                from,
                (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
            );

            // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
            if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                uint256 nextTokenId = tokenId + 1;
                // If the next slot's address is zero and not burned (i.e. packed value is zero).
                if (_packedOwnerships[nextTokenId] == 0) {
                    // If the next slot is within bounds.
                    if (nextTokenId != _currentIndex) {
                        // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                        _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                    }
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

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

    // =============================================================
    //                     EXTRA DATA OPERATIONS
    // =============================================================

    /**
     * @dev Directly sets the extra data for the ownership data `index`.
     */
    function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
        uint256 packed = _packedOwnerships[index];
        if (packed == 0) revert OwnershipNotInitializedForExtraData();
        uint256 extraDataCasted;
        // Cast `extraData` with assembly to avoid redundant masking.
        assembly {
            extraDataCasted := extraData
        }
        packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
        _packedOwnerships[index] = packed;
    }

    /**
     * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * 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 _extraData(
        address from,
        address to,
        uint24 previousExtraData
    ) internal view virtual returns (uint24) {}

    /**
     * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
    function _nextExtraData(
        address from,
        address to,
        uint256 prevOwnershipPacked
    ) private view returns (uint256) {
        uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
        return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
    }

    // =============================================================
    //                       OTHER OPERATIONS
    // =============================================================

    /**
     * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
    function _msgSenderERC721A() internal view virtual returns (address) {
        return msg.sender;
    }

    /**
     * @dev Converts a uint256 to its ASCII string decimal representation.
     */
    function _toString(uint256 value) internal pure virtual returns (string memory str) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
            let m := add(mload(0x40), 0xa0)
            // Update the free memory pointer to allocate.
            mstore(0x40, m)
            // Assign the `str` to the end.
            str := sub(m, 0x20)
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                str := sub(str, 1)
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                // prettier-ignore
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }
}


// File contracts/BonglerNFT.sol



pragma solidity ^0.8.17;



contract BonglerNFT is ERC721A, Ownable {
    uint256 public mintPrice = 0.042 ether;

    bool public saleIsActive = false;

    uint256 public maxPerAddressDuringMint = 5;
    string private _baseTokenURI;

    uint256 public maxSupply = 420;
    mapping(address => bool) public mintedFree;

    constructor() ERC721A("Bongler", "BNGLR") {}

    function mintReserveTokens(uint256 numberOfTokens) public onlyOwner {
        _safeMint(msg.sender, numberOfTokens);
        require(totalSupply() <= maxSupply, "Limit reached");
    }

    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }

    function setMintPrice(uint256 newPrice) public onlyOwner {
        mintPrice = newPrice;
    }

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

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

    function mint(uint256 quantity) external payable {
        require(saleIsActive, "Sale must be active to mint");
        require(quantity <= maxPerAddressDuringMint, "amount to hi");

        require(mintPrice * quantity <= msg.value, "price to hi men");

        _mint(msg.sender, quantity);
        require(totalSupply() <= maxSupply, "Limit reached");
    }

    function freeMint() external payable {
        require(saleIsActive, "Sale must be active to mint");

        require(
            isAFriend(msg.sender),
            "This wallet doesn't hold any friend NFTs"
        );
        require(
            mintedFree[msg.sender] == false,
            "You can only mint 1 for free"
        );

        mintedFree[msg.sender] = true;
        _mint(msg.sender, 1);

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

    function isAFriend(address addr) public view returns (bool) {
        address milady = 0x5Af0D9827E0c53E4799BB226655A1de152A425a5;
        address bonkler = 0xABFaE8A54e6817F57F9De7796044E9a60e61ad67;
        address remilio = 0xD3D9ddd0CF0A5F0BFB8f7fcEAe075DF687eAEBaB;
        address janklerz = 0xEB3B0Ac9E4829a92E964e723EfDa9104ce0dE5Ec;
        address weedz = 0xcD96d928Feb9ba8dd530FAF0515b49EEFfC6C815;
        address adworld = 0x62eb144FE92Ddc1B10bCAde03A0C09f6FBffBffb;

        return
            ERC721(milady).balanceOf(addr) > 0 ||
            ERC721(bonkler).balanceOf(addr) > 0 ||
            ERC721(remilio).balanceOf(addr) > 0 ||
            ERC721(janklerz).balanceOf(addr) > 0 ||
            ERC721(weedz).balanceOf(addr) > 0 ||
            ERC721(adworld).balanceOf(addr) > 0;
    }

    function hitBlunt() external onlyOwner {
        (bool success, ) = owner().call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintERC2309QuantityExceedsLimit","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"OwnershipNotInitializedForExtraData","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":"uint256","name":"fromTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"toTokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"ConsecutiveTransfer","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","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":"freeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hitBlunt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isAFriend","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"maxPerAddressDuringMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintReserveTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintedFree","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"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":"payable","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":"payable","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":"uint256","name":"newPrice","type":"uint256"}],"name":"setMintPrice","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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

106081:2866:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72976:639;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73878:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80369:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79802:408;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;107948:818;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69629:323;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;106339:42;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84008:2825;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;106442:187;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;106637:89;;;;;;;;;;;;;:::i;:::-;;86929:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;106960:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;107450:490;;;:::i;:::-;;75271:152;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;106128:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70813:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2888:103;;;;;;;;;;;;;:::i;:::-;;106216:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2240:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74054:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;107074:368;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80927:234;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;87720:407;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74264:318;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;106302:30;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;108774:170;;;;;;;;;;;;;:::i;:::-;;81318:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;106175:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3146:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;106734:96;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72976:639;73061:4;73400:10;73385:25;;:11;:25;;;;:102;;;;73477:10;73462:25;;:11;:25;;;;73385:102;:179;;;;73554:10;73539:25;;:11;:25;;;;73385:179;73365:199;;72976:639;;;:::o;73878:100::-;73932:13;73965:5;73958:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73878:100;:::o;80369:218::-;80445:7;80470:16;80478:7;80470;:16::i;:::-;80465:64;;80495:34;;;;;;;;;;;;;;80465:64;80549:15;:24;80565:7;80549:24;;;;;;;;;;;:30;;;;;;;;;;;;80542:37;;80369:218;;;:::o;79802:408::-;79891:13;79907:16;79915:7;79907;:16::i;:::-;79891:32;;79963:5;79940:28;;:19;:17;:19::i;:::-;:28;;;79936:175;;79988:44;80005:5;80012:19;:17;:19::i;:::-;79988:16;:44::i;:::-;79983:128;;80060:35;;;;;;;;;;;;;;79983:128;79936:175;80156:2;80123:15;:24;80139:7;80123:24;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;80194:7;80190:2;80174:28;;80183:5;80174:28;;;;;;;;;;;;79880:330;79802:408;;:::o;107948:818::-;108002:4;108019:14;108036:42;108019:59;;108089:15;108107:42;108089:60;;108160:15;108178:42;108160:60;;108231:16;108250:42;108231:61;;108303:13;108319:42;108303:58;;108372:15;108390:42;108372:60;;108498:1;108472:6;108465:24;;;108490:4;108465:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:34;:86;;;;108550:1;108523:7;108516:25;;;108542:4;108516:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;108465:86;:138;;;;108602:1;108575:7;108568:25;;;108594:4;108568:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;108465:138;:191;;;;108655:1;108627:8;108620:26;;;108647:4;108620:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;108465:191;:241;;;;108705:1;108680:5;108673:23;;;108697:4;108673:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33;108465:241;:293;;;;108757:1;108730:7;108723:25;;;108749:4;108723:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:35;108465:293;108445:313;;;;;;;;107948:818;;;:::o;69629:323::-;69690:7;69918:15;:13;:15::i;:::-;69903:12;;69887:13;;:28;:46;69880:53;;69629:323;:::o;106339:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;84008:2825::-;84150:27;84180;84199:7;84180:18;:27::i;:::-;84150:57;;84265:4;84224:45;;84240:19;84224:45;;;84220:86;;84278:28;;;;;;;;;;;;;;84220:86;84320:27;84349:23;84376:35;84403:7;84376:26;:35::i;:::-;84319:92;;;;84511:68;84536:15;84553:4;84559:19;:17;:19::i;:::-;84511:24;:68::i;:::-;84506:180;;84599:43;84616:4;84622:19;:17;:19::i;:::-;84599:16;:43::i;:::-;84594:92;;84651:35;;;;;;;;;;;;;;84594:92;84506:180;84717:1;84703:16;;:2;:16;;;84699:52;;84728:23;;;;;;;;;;;;;;84699:52;84764:43;84786:4;84792:2;84796:7;84805:1;84764:21;:43::i;:::-;84900:15;84897:160;;;85040:1;85019:19;85012:30;84897:160;85437:18;:24;85456:4;85437:24;;;;;;;;;;;;;;;;85435:26;;;;;;;;;;;;85506:18;:22;85525:2;85506:22;;;;;;;;;;;;;;;;85504:24;;;;;;;;;;;85828:146;85865:2;85914:45;85929:4;85935:2;85939:19;85914:14;:45::i;:::-;66028:8;85886:73;85828:18;:146::i;:::-;85799:17;:26;85817:7;85799:26;;;;;;;;;;;:175;;;;86145:1;66028:8;86094:19;:47;:52;86090:627;;86167:19;86199:1;86189:7;:11;86167:33;;86356:1;86322:17;:30;86340:11;86322:30;;;;;;;;;;;;:35;86318:384;;86460:13;;86445:11;:28;86441:242;;86640:19;86607:17;:30;86625:11;86607:30;;;;;;;;;;;:52;;;;86441:242;86318:384;86148:569;86090:627;86764:7;86760:2;86745:27;;86754:4;86745:27;;;;;;;;;;;;86783:42;86804:4;86810:2;86814:7;86823:1;86783:20;:42::i;:::-;84139:2694;;;84008:2825;;;:::o;106442:187::-;2126:13;:11;:13::i;:::-;106521:37:::1;106531:10;106543:14;106521:9;:37::i;:::-;106594:9;;106577:13;:11;:13::i;:::-;:26;;106569:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;106442:187:::0;:::o;106637:89::-;2126:13;:11;:13::i;:::-;106706:12:::1;;;;;;;;;;;106705:13;106690:12;;:28;;;;;;;;;;;;;;;;;;106637:89::o:0;86929:193::-;87075:39;87092:4;87098:2;87102:7;87075:39;;;;;;;;;;;;:16;:39::i;:::-;86929:193;;;:::o;106960:106::-;2126:13;:11;:13::i;:::-;107051:7:::1;;107035:13;:23;;;;;;;:::i;:::-;;106960:106:::0;;:::o;107450:490::-;107506:12;;;;;;;;;;;107498:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;107585:21;107595:10;107585:9;:21::i;:::-;107563:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;107733:5;107707:31;;:10;:22;107718:10;107707:22;;;;;;;;;;;;;;;;;;;;;;;;;:31;;;107685:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;107832:4;107807:10;:22;107818:10;107807:22;;;;;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;107847:20;107853:10;107865:1;107847:5;:20::i;:::-;107905:9;;107888:13;:11;:13::i;:::-;:26;;107880:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;107450:490::o;75271:152::-;75343:7;75386:27;75405:7;75386:18;:27::i;:::-;75363:52;;75271:152;;;:::o;106128:38::-;;;;:::o;70813:233::-;70885:7;70926:1;70909:19;;:5;:19;;;70905:60;;70937:28;;;;;;;;;;;;;;70905:60;64972:13;70983:18;:25;71002:5;70983:25;;;;;;;;;;;;;;;;:55;70976:62;;70813:233;;;:::o;2888:103::-;2126:13;:11;:13::i;:::-;2953:30:::1;2980:1;2953:18;:30::i;:::-;2888:103::o:0;106216:42::-;;;;:::o;2240:87::-;2286:7;2313:6;;;;;;;;;;;2306:13;;2240:87;:::o;74054:104::-;74110:13;74143:7;74136:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74054:104;:::o;107074:368::-;107142:12;;;;;;;;;;;107134:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;107217:23;;107205:8;:35;;107197:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;107302:9;107290:8;107278:9;;:20;;;;:::i;:::-;:33;;107270:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;107344:27;107350:10;107362:8;107344:5;:27::i;:::-;107407:9;;107390:13;:11;:13::i;:::-;:26;;107382:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;107074:368;:::o;80927:234::-;81074:8;81022:18;:39;81041:19;:17;:19::i;:::-;81022:39;;;;;;;;;;;;;;;:49;81062:8;81022:49;;;;;;;;;;;;;;;;:60;;;;;;;;;;;;;;;;;;81134:8;81098:55;;81113:19;:17;:19::i;:::-;81098:55;;;81144:8;81098:55;;;;;;:::i;:::-;;;;;;;;80927:234;;:::o;87720:407::-;87895:31;87908:4;87914:2;87918:7;87895:12;:31::i;:::-;87959:1;87941:2;:14;;;:19;87937:183;;87980:56;88011:4;88017:2;88021:7;88030:5;87980:30;:56::i;:::-;87975:145;;88064:40;;;;;;;;;;;;;;87975:145;87937:183;87720:407;;;;:::o;74264:318::-;74337:13;74368:16;74376:7;74368;:16::i;:::-;74363:59;;74393:29;;;;;;;;;;;;;;74363:59;74435:21;74459:10;:8;:10::i;:::-;74435:34;;74512:1;74493:7;74487:21;:26;:87;;;;;;;;;;;;;;;;;74540:7;74549:18;74559:7;74549:9;:18::i;:::-;74523:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74487:87;74480:94;;;74264:318;;;:::o;106302:30::-;;;;:::o;108774:170::-;2126:13;:11;:13::i;:::-;108825:12:::1;108843:7;:5;:7::i;:::-;:12;;108863:21;108843:46;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108824:65;;;108908:7;108900:36;;;;;;;;;;;;:::i;:::-;;;;;;;;;108813:131;108774:170::o:0;81318:164::-;81415:4;81439:18;:25;81458:5;81439:25;;;;;;;;;;;;;;;:35;81465:8;81439:35;;;;;;;;;;;;;;;;;;;;;;;;;81432:42;;81318:164;;;;:::o;106175:32::-;;;;;;;;;;;;;:::o;3146:201::-;2126:13;:11;:13::i;:::-;3255:1:::1;3235:22;;:8;:22;;::::0;3227:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;3311:28;3330:8;3311:18;:28::i;:::-;3146:201:::0;:::o;106734:96::-;2126:13;:11;:13::i;:::-;106814:8:::1;106802:9;:20;;;;106734:96:::0;:::o;81740:282::-;81805:4;81861:7;81842:15;:13;:15::i;:::-;:26;;:66;;;;;81895:13;;81885:7;:23;81842:66;:153;;;;;81994:1;65748:8;81946:17;:26;81964:7;81946:26;;;;;;;;;;;;:44;:49;81842:153;81822:173;;81740:282;;;:::o;104048:105::-;104108:7;104135:10;104128:17;;104048:105;:::o;69145:92::-;69201:7;69145:92;:::o;76426:1275::-;76493:7;76513:12;76528:7;76513:22;;76596:4;76577:15;:13;:15::i;:::-;:23;76573:1061;;76630:13;;76623:4;:20;76619:1015;;;76668:14;76685:17;:23;76703:4;76685:23;;;;;;;;;;;;76668:40;;76802:1;65748:8;76774:6;:24;:29;76770:845;;77439:113;77456:1;77446:6;:11;77439:113;;77499:17;:25;77517:6;;;;;;;77499:25;;;;;;;;;;;;77490:34;;77439:113;;;77585:6;77578:13;;;;;;76770:845;76645:989;76619:1015;76573:1061;77662:31;;;;;;;;;;;;;;76426:1275;;;;:::o;82903:485::-;83005:27;83034:23;83075:38;83116:15;:24;83132:7;83116:24;;;;;;;;;;;83075:65;;83293:18;83270:41;;83350:19;83344:26;83325:45;;83255:126;82903:485;;;:::o;82131:659::-;82280:11;82445:16;82438:5;82434:28;82425:37;;82605:16;82594:9;82590:32;82577:45;;82755:15;82744:9;82741:30;82733:5;82722:9;82719:20;82716:56;82706:66;;82131:659;;;;;:::o;88789:159::-;;;;;:::o;103357:311::-;103492:7;103512:16;66152:3;103538:19;:41;;103512:68;;66152:3;103606:31;103617:4;103623:2;103627:9;103606:10;:31::i;:::-;103598:40;;:62;;103591:69;;;103357:311;;;;;:::o;78249:450::-;78329:14;78497:16;78490:5;78486:28;78477:37;;78674:5;78660:11;78635:23;78631:41;78628:52;78621:5;78618:63;78608:73;;78249:450;;;;:::o;89613:158::-;;;;;:::o;2405:132::-;2480:12;:10;:12::i;:::-;2469:23;;:7;:5;:7::i;:::-;:23;;;2461:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2405:132::o;97880:112::-;97957:27;97967:2;97971:8;97957:27;;;;;;;;;;;;:9;:27::i;:::-;97880:112;;:::o;91389:2966::-;91462:20;91485:13;;91462:36;;91525:1;91513:8;:13;91509:44;;91535:18;;;;;;;;;;;;;;91509:44;91566:61;91596:1;91600:2;91604:12;91618:8;91566:21;:61::i;:::-;92110:1;65110:2;92080:1;:26;;92079:32;92067:8;:45;92041:18;:22;92060:2;92041:22;;;;;;;;;;;;;;;;:71;;;;;;;;;;;92389:139;92426:2;92480:33;92503:1;92507:2;92511:1;92480:14;:33::i;:::-;92447:30;92468:8;92447:20;:30::i;:::-;:66;92389:18;:139::i;:::-;92355:17;:31;92373:12;92355:31;;;;;;;;;;;:173;;;;92545:16;92576:11;92605:8;92590:12;:23;92576:37;;93126:16;93122:2;93118:25;93106:37;;93498:12;93458:8;93417:1;93355:25;93296:1;93235;93208:335;93869:1;93855:12;93851:20;93809:346;93910:3;93901:7;93898:16;93809:346;;94128:7;94118:8;94115:1;94088:25;94085:1;94082;94077:59;93963:1;93954:7;93950:15;93939:26;;93809:346;;;93813:77;94200:1;94188:8;:13;94184:45;;94210:19;;;;;;;;;;;;;;94184:45;94262:3;94246:13;:19;;;;91815:2462;;94287:60;94316:1;94320:2;94324:12;94338:8;94287:20;:60::i;:::-;91451:2904;91389:2966;;:::o;3507:191::-;3581:16;3600:6;;;;;;;;;;;3581:25;;3626:8;3617:6;;:17;;;;;;;;;;;;;;;;;;3681:8;3650:40;;3671:8;3650:40;;;;;;;;;;;;3570:128;3507:191;:::o;90211:716::-;90374:4;90420:2;90395:45;;;90441:19;:17;:19::i;:::-;90462:4;90468:7;90477:5;90395:88;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;90391:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90695:1;90678:6;:13;:18;90674:235;;90724:40;;;;;;;;;;;;;;90674:235;90867:6;90861:13;90852:6;90848:2;90844:15;90837:38;90391:529;90564:54;;;90554:64;;;:6;:64;;;;90547:71;;;90211:716;;;;;;:::o;106838:114::-;106898:13;106931;106924:20;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106838:114;:::o;104255:1745::-;104320:17;104754:4;104747;104741:11;104737:22;104846:1;104840:4;104833:15;104921:4;104918:1;104914:12;104907:19;;105003:1;104998:3;104991:14;105107:3;105346:5;105328:428;105354:1;105328:428;;;105394:1;105389:3;105385:11;105378:18;;105565:2;105559:4;105555:13;105551:2;105547:22;105542:3;105534:36;105659:2;105653:4;105649:13;105641:21;;105726:4;105328:428;105716:25;105328:428;105332:21;105795:3;105790;105786:13;105910:4;105905:3;105901:14;105894:21;;105975:6;105970:3;105963:19;104359:1634;;;104255:1745;;;:::o;103058:147::-;103195:6;103058:147;;;;;:::o;785:98::-;838:7;865:10;858:17;;785:98;:::o;97107:689::-;97238:19;97244:2;97248:8;97238:5;:19::i;:::-;97317:1;97299:2;:14;;;:19;97295:483;;97339:11;97353:13;;97339:27;;97385:13;97407:8;97401:3;:14;97385:30;;97434:233;97465:62;97504:1;97508:2;97512:7;;;;;;97521:5;97465:30;:62::i;:::-;97460:167;;97563:40;;;;;;;;;;;;;;97460:167;97662:3;97654:5;:11;97434:233;;97749:3;97732:13;;:20;97728:34;;97754:8;;;97728:34;97320:458;;97295:483;97107:689;;;:::o;78801:324::-;78871:14;79104:1;79094:8;79091:15;79065:24;79061:46;79051:56;;78801:324;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:329::-;4949:6;4998:2;4986:9;4977:7;4973:23;4969:32;4966:119;;;5004:79;;:::i;:::-;4966:119;5124:1;5149:53;5194:7;5185:6;5174:9;5170:22;5149:53;:::i;:::-;5139:63;;5095:117;4890:329;;;;:::o;5225:118::-;5312:24;5330:5;5312:24;:::i;:::-;5307:3;5300:37;5225:118;;:::o;5349:222::-;5442:4;5480:2;5469:9;5465:18;5457:26;;5493:71;5561:1;5550:9;5546:17;5537:6;5493:71;:::i;:::-;5349:222;;;;:::o;5577:619::-;5654:6;5662;5670;5719:2;5707:9;5698:7;5694:23;5690:32;5687:119;;;5725:79;;:::i;:::-;5687:119;5845:1;5870:53;5915:7;5906:6;5895:9;5891:22;5870:53;:::i;:::-;5860:63;;5816:117;5972:2;5998:53;6043:7;6034:6;6023:9;6019:22;5998:53;:::i;:::-;5988:63;;5943:118;6100:2;6126:53;6171:7;6162:6;6151:9;6147:22;6126:53;:::i;:::-;6116:63;;6071:118;5577:619;;;;;:::o;6202:117::-;6311:1;6308;6301:12;6325:117;6434:1;6431;6424:12;6448:117;6557:1;6554;6547:12;6585:553;6643:8;6653:6;6703:3;6696:4;6688:6;6684:17;6680:27;6670:122;;6711:79;;:::i;:::-;6670:122;6824:6;6811:20;6801:30;;6854:18;6846:6;6843:30;6840:117;;;6876:79;;:::i;:::-;6840:117;6990:4;6982:6;6978:17;6966:29;;7044:3;7036:4;7028:6;7024:17;7014:8;7010:32;7007:41;7004:128;;;7051:79;;:::i;:::-;7004:128;6585:553;;;;;:::o;7144:529::-;7215:6;7223;7272:2;7260:9;7251:7;7247:23;7243:32;7240:119;;;7278:79;;:::i;:::-;7240:119;7426:1;7415:9;7411:17;7398:31;7456:18;7448:6;7445:30;7442:117;;;7478:79;;:::i;:::-;7442:117;7591:65;7648:7;7639:6;7628:9;7624:22;7591:65;:::i;:::-;7573:83;;;;7369:297;7144:529;;;;;:::o;7679:116::-;7749:21;7764:5;7749:21;:::i;:::-;7742:5;7739:32;7729:60;;7785:1;7782;7775:12;7729:60;7679:116;:::o;7801:133::-;7844:5;7882:6;7869:20;7860:29;;7898:30;7922:5;7898:30;:::i;:::-;7801:133;;;;:::o;7940:468::-;8005:6;8013;8062:2;8050:9;8041:7;8037:23;8033:32;8030:119;;;8068:79;;:::i;:::-;8030:119;8188:1;8213:53;8258:7;8249:6;8238:9;8234:22;8213:53;:::i;:::-;8203:63;;8159:117;8315:2;8341:50;8383:7;8374:6;8363:9;8359:22;8341:50;:::i;:::-;8331:60;;8286:115;7940:468;;;;;:::o;8414:117::-;8523:1;8520;8513:12;8537:180;8585:77;8582:1;8575:88;8682:4;8679:1;8672:15;8706:4;8703:1;8696:15;8723:281;8806:27;8828:4;8806:27;:::i;:::-;8798:6;8794:40;8936:6;8924:10;8921:22;8900:18;8888:10;8885:34;8882:62;8879:88;;;8947:18;;:::i;:::-;8879:88;8987:10;8983:2;8976:22;8766:238;8723:281;;:::o;9010:129::-;9044:6;9071:20;;:::i;:::-;9061:30;;9100:33;9128:4;9120:6;9100:33;:::i;:::-;9010:129;;;:::o;9145:307::-;9206:4;9296:18;9288:6;9285:30;9282:56;;;9318:18;;:::i;:::-;9282:56;9356:29;9378:6;9356:29;:::i;:::-;9348:37;;9440:4;9434;9430:15;9422:23;;9145:307;;;:::o;9458:146::-;9555:6;9550:3;9545;9532:30;9596:1;9587:6;9582:3;9578:16;9571:27;9458:146;;;:::o;9610:423::-;9687:5;9712:65;9728:48;9769:6;9728:48;:::i;:::-;9712:65;:::i;:::-;9703:74;;9800:6;9793:5;9786:21;9838:4;9831:5;9827:16;9876:3;9867:6;9862:3;9858:16;9855:25;9852:112;;;9883:79;;:::i;:::-;9852:112;9973:54;10020:6;10015:3;10010;9973:54;:::i;:::-;9693:340;9610:423;;;;;:::o;10052:338::-;10107:5;10156:3;10149:4;10141:6;10137:17;10133:27;10123:122;;10164:79;;:::i;:::-;10123:122;10281:6;10268:20;10306:78;10380:3;10372:6;10365:4;10357:6;10353:17;10306:78;:::i;:::-;10297:87;;10113:277;10052:338;;;;:::o;10396:943::-;10491:6;10499;10507;10515;10564:3;10552:9;10543:7;10539:23;10535:33;10532:120;;;10571:79;;:::i;:::-;10532:120;10691:1;10716:53;10761:7;10752:6;10741:9;10737:22;10716:53;:::i;:::-;10706:63;;10662:117;10818:2;10844:53;10889:7;10880:6;10869:9;10865:22;10844:53;:::i;:::-;10834:63;;10789:118;10946:2;10972:53;11017:7;11008:6;10997:9;10993:22;10972:53;:::i;:::-;10962:63;;10917:118;11102:2;11091:9;11087:18;11074:32;11133:18;11125:6;11122:30;11119:117;;;11155:79;;:::i;:::-;11119:117;11260:62;11314:7;11305:6;11294:9;11290:22;11260:62;:::i;:::-;11250:72;;11045:287;10396:943;;;;;;;:::o;11345:474::-;11413:6;11421;11470:2;11458:9;11449:7;11445:23;11441:32;11438:119;;;11476:79;;:::i;:::-;11438:119;11596:1;11621:53;11666:7;11657:6;11646:9;11642:22;11621:53;:::i;:::-;11611:63;;11567:117;11723:2;11749:53;11794:7;11785:6;11774:9;11770:22;11749:53;:::i;:::-;11739:63;;11694:118;11345:474;;;;;:::o;11825:180::-;11873:77;11870:1;11863:88;11970:4;11967:1;11960:15;11994:4;11991:1;11984:15;12011:320;12055:6;12092:1;12086:4;12082:12;12072:22;;12139:1;12133:4;12129:12;12160:18;12150:81;;12216:4;12208:6;12204:17;12194:27;;12150:81;12278:2;12270:6;12267:14;12247:18;12244:38;12241:84;;12297:18;;:::i;:::-;12241:84;12062:269;12011:320;;;:::o;12337:143::-;12394:5;12425:6;12419:13;12410:22;;12441:33;12468:5;12441:33;:::i;:::-;12337:143;;;;:::o;12486:351::-;12556:6;12605:2;12593:9;12584:7;12580:23;12576:32;12573:119;;;12611:79;;:::i;:::-;12573:119;12731:1;12756:64;12812:7;12803:6;12792:9;12788:22;12756:64;:::i;:::-;12746:74;;12702:128;12486:351;;;;:::o;12843:163::-;12983:15;12979:1;12971:6;12967:14;12960:39;12843:163;:::o;13012:366::-;13154:3;13175:67;13239:2;13234:3;13175:67;:::i;:::-;13168:74;;13251:93;13340:3;13251:93;:::i;:::-;13369:2;13364:3;13360:12;13353:19;;13012:366;;;:::o;13384:419::-;13550:4;13588:2;13577:9;13573:18;13565:26;;13637:9;13631:4;13627:20;13623:1;13612:9;13608:17;13601:47;13665:131;13791:4;13665:131;:::i;:::-;13657:139;;13384:419;;;:::o;13809:97::-;13868:6;13896:3;13886:13;;13809:97;;;;:::o;13912:141::-;13961:4;13984:3;13976:11;;14007:3;14004:1;13997:14;14041:4;14038:1;14028:18;14020:26;;13912:141;;;:::o;14059:93::-;14096:6;14143:2;14138;14131:5;14127:14;14123:23;14113:33;;14059:93;;;:::o;14158:107::-;14202:8;14252:5;14246:4;14242:16;14221:37;;14158:107;;;;:::o;14271:393::-;14340:6;14390:1;14378:10;14374:18;14413:97;14443:66;14432:9;14413:97;:::i;:::-;14531:39;14561:8;14550:9;14531:39;:::i;:::-;14519:51;;14603:4;14599:9;14592:5;14588:21;14579:30;;14652:4;14642:8;14638:19;14631:5;14628:30;14618:40;;14347:317;;14271:393;;;;;:::o;14670:60::-;14698:3;14719:5;14712:12;;14670:60;;;:::o;14736:142::-;14786:9;14819:53;14837:34;14846:24;14864:5;14846:24;:::i;:::-;14837:34;:::i;:::-;14819:53;:::i;:::-;14806:66;;14736:142;;;:::o;14884:75::-;14927:3;14948:5;14941:12;;14884:75;;;:::o;14965:269::-;15075:39;15106:7;15075:39;:::i;:::-;15136:91;15185:41;15209:16;15185:41;:::i;:::-;15177:6;15170:4;15164:11;15136:91;:::i;:::-;15130:4;15123:105;15041:193;14965:269;;;:::o;15240:73::-;15285:3;15240:73;:::o;15319:189::-;15396:32;;:::i;:::-;15437:65;15495:6;15487;15481:4;15437:65;:::i;:::-;15372:136;15319:189;;:::o;15514:186::-;15574:120;15591:3;15584:5;15581:14;15574:120;;;15645:39;15682:1;15675:5;15645:39;:::i;:::-;15618:1;15611:5;15607:13;15598:22;;15574:120;;;15514:186;;:::o;15706:543::-;15807:2;15802:3;15799:11;15796:446;;;15841:38;15873:5;15841:38;:::i;:::-;15925:29;15943:10;15925:29;:::i;:::-;15915:8;15911:44;16108:2;16096:10;16093:18;16090:49;;;16129:8;16114:23;;16090:49;16152:80;16208:22;16226:3;16208:22;:::i;:::-;16198:8;16194:37;16181:11;16152:80;:::i;:::-;15811:431;;15796:446;15706:543;;;:::o;16255:117::-;16309:8;16359:5;16353:4;16349:16;16328:37;;16255:117;;;;:::o;16378:169::-;16422:6;16455:51;16503:1;16499:6;16491:5;16488:1;16484:13;16455:51;:::i;:::-;16451:56;16536:4;16530;16526:15;16516:25;;16429:118;16378:169;;;;:::o;16552:295::-;16628:4;16774:29;16799:3;16793:4;16774:29;:::i;:::-;16766:37;;16836:3;16833:1;16829:11;16823:4;16820:21;16812:29;;16552:295;;;;:::o;16852:1403::-;16976:44;17016:3;17011;16976:44;:::i;:::-;17085:18;17077:6;17074:30;17071:56;;;17107:18;;:::i;:::-;17071:56;17151:38;17183:4;17177:11;17151:38;:::i;:::-;17236:67;17296:6;17288;17282:4;17236:67;:::i;:::-;17330:1;17359:2;17351:6;17348:14;17376:1;17371:632;;;;18047:1;18064:6;18061:84;;;18120:9;18115:3;18111:19;18098:33;18089:42;;18061:84;18171:67;18231:6;18224:5;18171:67;:::i;:::-;18165:4;18158:81;18020:229;17341:908;;17371:632;17423:4;17419:9;17411:6;17407:22;17457:37;17489:4;17457:37;:::i;:::-;17516:1;17530:215;17544:7;17541:1;17538:14;17530:215;;;17630:9;17625:3;17621:19;17608:33;17600:6;17593:49;17681:1;17673:6;17669:14;17659:24;;17728:2;17717:9;17713:18;17700:31;;17567:4;17564:1;17560:12;17555:17;;17530:215;;;17773:6;17764:7;17761:19;17758:186;;;17838:9;17833:3;17829:19;17816:33;17881:48;17923:4;17915:6;17911:17;17900:9;17881:48;:::i;:::-;17873:6;17866:64;17781:163;17758:186;17990:1;17986;17978:6;17974:14;17970:22;17964:4;17957:36;17378:625;;;17341:908;;16951:1304;;;16852:1403;;;:::o;18261:177::-;18401:29;18397:1;18389:6;18385:14;18378:53;18261:177;:::o;18444:366::-;18586:3;18607:67;18671:2;18666:3;18607:67;:::i;:::-;18600:74;;18683:93;18772:3;18683:93;:::i;:::-;18801:2;18796:3;18792:12;18785:19;;18444:366;;;:::o;18816:419::-;18982:4;19020:2;19009:9;19005:18;18997:26;;19069:9;19063:4;19059:20;19055:1;19044:9;19040:17;19033:47;19097:131;19223:4;19097:131;:::i;:::-;19089:139;;18816:419;;;:::o;19241:227::-;19381:34;19377:1;19369:6;19365:14;19358:58;19450:10;19445:2;19437:6;19433:15;19426:35;19241:227;:::o;19474:366::-;19616:3;19637:67;19701:2;19696:3;19637:67;:::i;:::-;19630:74;;19713:93;19802:3;19713:93;:::i;:::-;19831:2;19826:3;19822:12;19815:19;;19474:366;;;:::o;19846:419::-;20012:4;20050:2;20039:9;20035:18;20027:26;;20099:9;20093:4;20089:20;20085:1;20074:9;20070:17;20063:47;20127:131;20253:4;20127:131;:::i;:::-;20119:139;;19846:419;;;:::o;20271:178::-;20411:30;20407:1;20399:6;20395:14;20388:54;20271:178;:::o;20455:366::-;20597:3;20618:67;20682:2;20677:3;20618:67;:::i;:::-;20611:74;;20694:93;20783:3;20694:93;:::i;:::-;20812:2;20807:3;20803:12;20796:19;;20455:366;;;:::o;20827:419::-;20993:4;21031:2;21020:9;21016:18;21008:26;;21080:9;21074:4;21070:20;21066:1;21055:9;21051:17;21044:47;21108:131;21234:4;21108:131;:::i;:::-;21100:139;;20827:419;;;:::o;21252:162::-;21392:14;21388:1;21380:6;21376:14;21369:38;21252:162;:::o;21420:366::-;21562:3;21583:67;21647:2;21642:3;21583:67;:::i;:::-;21576:74;;21659:93;21748:3;21659:93;:::i;:::-;21777:2;21772:3;21768:12;21761:19;;21420:366;;;:::o;21792:419::-;21958:4;21996:2;21985:9;21981:18;21973:26;;22045:9;22039:4;22035:20;22031:1;22020:9;22016:17;22009:47;22073:131;22199:4;22073:131;:::i;:::-;22065:139;;21792:419;;;:::o;22217:180::-;22265:77;22262:1;22255:88;22362:4;22359:1;22352:15;22386:4;22383:1;22376:15;22403:410;22443:7;22466:20;22484:1;22466:20;:::i;:::-;22461:25;;22500:20;22518:1;22500:20;:::i;:::-;22495:25;;22555:1;22552;22548:9;22577:30;22595:11;22577:30;:::i;:::-;22566:41;;22756:1;22747:7;22743:15;22740:1;22737:22;22717:1;22710:9;22690:83;22667:139;;22786:18;;:::i;:::-;22667:139;22451:362;22403:410;;;;:::o;22819:165::-;22959:17;22955:1;22947:6;22943:14;22936:41;22819:165;:::o;22990:366::-;23132:3;23153:67;23217:2;23212:3;23153:67;:::i;:::-;23146:74;;23229:93;23318:3;23229:93;:::i;:::-;23347:2;23342:3;23338:12;23331:19;;22990:366;;;:::o;23362:419::-;23528:4;23566:2;23555:9;23551:18;23543:26;;23615:9;23609:4;23605:20;23601:1;23590:9;23586:17;23579:47;23643:131;23769:4;23643:131;:::i;:::-;23635:139;;23362:419;;;:::o;23787:148::-;23889:11;23926:3;23911:18;;23787:148;;;;:::o;23941:390::-;24047:3;24075:39;24108:5;24075:39;:::i;:::-;24130:89;24212:6;24207:3;24130:89;:::i;:::-;24123:96;;24228:65;24286:6;24281:3;24274:4;24267:5;24263:16;24228:65;:::i;:::-;24318:6;24313:3;24309:16;24302:23;;24051:280;23941:390;;;;:::o;24337:435::-;24517:3;24539:95;24630:3;24621:6;24539:95;:::i;:::-;24532:102;;24651:95;24742:3;24733:6;24651:95;:::i;:::-;24644:102;;24763:3;24756:10;;24337:435;;;;;:::o;24778:147::-;24879:11;24916:3;24901:18;;24778:147;;;;:::o;24931:114::-;;:::o;25051:398::-;25210:3;25231:83;25312:1;25307:3;25231:83;:::i;:::-;25224:90;;25323:93;25412:3;25323:93;:::i;:::-;25441:1;25436:3;25432:11;25425:18;;25051:398;;;:::o;25455:379::-;25639:3;25661:147;25804:3;25661:147;:::i;:::-;25654:154;;25825:3;25818:10;;25455:379;;;:::o;25840:166::-;25980:18;25976:1;25968:6;25964:14;25957:42;25840:166;:::o;26012:366::-;26154:3;26175:67;26239:2;26234:3;26175:67;:::i;:::-;26168:74;;26251:93;26340:3;26251:93;:::i;:::-;26369:2;26364:3;26360:12;26353:19;;26012:366;;;:::o;26384:419::-;26550:4;26588:2;26577:9;26573:18;26565:26;;26637:9;26631:4;26627:20;26623:1;26612:9;26608:17;26601:47;26665:131;26791:4;26665:131;:::i;:::-;26657:139;;26384:419;;;:::o;26809:225::-;26949:34;26945:1;26937:6;26933:14;26926:58;27018:8;27013:2;27005:6;27001:15;26994:33;26809:225;:::o;27040:366::-;27182:3;27203:67;27267:2;27262:3;27203:67;:::i;:::-;27196:74;;27279:93;27368:3;27279:93;:::i;:::-;27397:2;27392:3;27388:12;27381:19;;27040:366;;;:::o;27412:419::-;27578:4;27616:2;27605:9;27601:18;27593:26;;27665:9;27659:4;27655:20;27651:1;27640:9;27636:17;27629:47;27693:131;27819:4;27693:131;:::i;:::-;27685:139;;27412:419;;;:::o;27837:182::-;27977:34;27973:1;27965:6;27961:14;27954:58;27837:182;:::o;28025:366::-;28167:3;28188:67;28252:2;28247:3;28188:67;:::i;:::-;28181:74;;28264:93;28353:3;28264:93;:::i;:::-;28382:2;28377:3;28373:12;28366:19;;28025:366;;;:::o;28397:419::-;28563:4;28601:2;28590:9;28586:18;28578:26;;28650:9;28644:4;28640:20;28636:1;28625:9;28621:17;28614:47;28678:131;28804:4;28678:131;:::i;:::-;28670:139;;28397:419;;;:::o;28822:98::-;28873:6;28907:5;28901:12;28891:22;;28822:98;;;:::o;28926:168::-;29009:11;29043:6;29038:3;29031:19;29083:4;29078:3;29074:14;29059:29;;28926:168;;;;:::o;29100:373::-;29186:3;29214:38;29246:5;29214:38;:::i;:::-;29268:70;29331:6;29326:3;29268:70;:::i;:::-;29261:77;;29347:65;29405:6;29400:3;29393:4;29386:5;29382:16;29347:65;:::i;:::-;29437:29;29459:6;29437:29;:::i;:::-;29432:3;29428:39;29421:46;;29190:283;29100:373;;;;:::o;29479:640::-;29674:4;29712:3;29701:9;29697:19;29689:27;;29726:71;29794:1;29783:9;29779:17;29770:6;29726:71;:::i;:::-;29807:72;29875:2;29864:9;29860:18;29851:6;29807:72;:::i;:::-;29889;29957:2;29946:9;29942:18;29933:6;29889:72;:::i;:::-;30008:9;30002:4;29998:20;29993:2;29982:9;29978:18;29971:48;30036:76;30107:4;30098:6;30036:76;:::i;:::-;30028:84;;29479:640;;;;;;;:::o;30125:141::-;30181:5;30212:6;30206:13;30197:22;;30228:32;30254:5;30228:32;:::i;:::-;30125:141;;;;:::o;30272:349::-;30341:6;30390:2;30378:9;30369:7;30365:23;30361:32;30358:119;;;30396:79;;:::i;:::-;30358:119;30516:1;30541:63;30596:7;30587:6;30576:9;30572:22;30541:63;:::i;:::-;30531:73;;30487:127;30272:349;;;;:::o

Swarm Source

ipfs://a794acea5462c4621751806551c749ad9d435698b837a5ab666cf53cda37e3ff

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