Token

HootyOwlsNFT (HOP)

ERC-721

Overview

Max Total Supply

867 HOP

Holders

165

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x4637089eeff01587d1f298fb472a2e72bccffe9a

Filtered by Token Holder

0x59C7602dFf791B5eC0348Cc0F6bDB73066De34E7

cellebridade.eth

Balance

1 HOP

0x59c7602dff791b5ec0348cc0f6bdb73066de34e7

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

HootyOwlsNFT

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-11-21
*/

// SPDX-License-Identifier: MIT
// File contracts/OperatorFilter/IOperatorFilterRegistry.sol
pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}

// File contracts/OperatorFilter/OperatorFilterer.sol
pragma solidity ^0.8.13;

abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry constant operatorFilterRegistry =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (subscribe) {
                operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    operatorFilterRegistry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(operatorFilterRegistry).code.length > 0) {
            // Allow spending tokens from addresses with balance
            // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
            // from an EOA.
            if (from == msg.sender) {
                _;
                return;
            }
            if (
                !(
                    operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)
                        && operatorFilterRegistry.isOperatorAllowed(address(this), from)
                )
            ) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }
}

// File contracts/OperatorFilter/DefaultOperatorFilterer.sol
pragma solidity ^0.8.13;

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

pragma solidity >=0.8.9 <0.9.0;

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

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

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


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

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

// OpenZeppelin Contracts (last updated v4.7.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://consensys.net/diligence/blog/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);
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

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

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

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

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

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

        _approve(to, tokenId, owner);
    }

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

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

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

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

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

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

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

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

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

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

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

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

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

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

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice) external view 
        returns (address receiver, uint256 royaltyAmount);
}

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

// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
// --@-----@---@@@@----@@@@---@@@@@@@---@-------@------@@@@----@-------@---@------@@@@@@@----
// --@-----@--@----@--@----@-----@-------@-----@------@----@---@-------@---@------@----------
// --@@@@@@@--@----@--@----@-----@--------@---@-------@----@---@---@---@---@------@@@@@@@----
// --@-----@--@----@--@----@-----@----------@---------@----@---@--@-@--@---@------------@----
// --@-----@---@@@@----@@@@------@----------@----------@@@@----@-@---@-@---@@@@@--@@@@@@@----
// ------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------
contract HootyOwlsNFT is ERC721A, Ownable, ReentrancyGuard, ERC2981, OperatorFilterer {

  using Strings for uint256;

  bytes32 public merkleRootFreeMint;
  bytes32 public merkleRootWL;
  mapping(address => uint256) public numberOfMintsOnAddress;
  mapping(address => uint256) public numberOfFreeMintsOnAddress;

  string public baseURI = '';
  string public uriSuffix = '.json';
  string public preRevealBaseURI;
  
  uint256 public standardCost;
  uint256 public freeMintAddonCost;
  uint256 public whitelistCost;
  uint256 public maxSupply;
  uint256 public freeMintCuttoffSupply;
  uint256 public maxMintQuantityPerTx;
  uint256 public maxFreeMintQuantityPerTx;
  uint256 public maxMintQuantityPerAddress;
  uint256 public maxFreeMintQuantityPerAddress;

  bool public paused = true;
  bool public promoPaused = true;
  bool public promoWLPaused = true;
  bool public whitelistPaused = true;
  bool public revealed = false;

  //bundles for mint
  uint256 public zSmallQty;
  uint256 public zSmallCost;
  uint256 public zMediumQty;
  uint256 public zMediumCost;
  uint256 public zLargeQty;
  uint256 public zLargeCost;
  uint256 public zXLargeQty;
  uint256 public zXLargeCost;
  uint256 public zXXLargeQty;
  uint256 public zXXLargeCost;
  
  constructor(
    string memory _tokenName,
    string memory _tokenSymbol,
    uint256 _standardCost,
    uint256 _freeMintAddonCost,
    uint256 _maxSupply,
    uint256 _freeMintCuttoffSupply,
    uint256 _maxFreeMintQuantityPerTx,
    uint256 _maxFreeMintQuantityPerAddress,
    uint96 _royaltyAmount,
    string memory _preRevealBaseURI 
  ) ERC721A(_tokenName, _tokenSymbol) OperatorFilterer(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6, true) {
    setCosts(_standardCost, _freeMintAddonCost, _standardCost);
    setMaxSupply(_maxSupply);
    setFreeMintCuttoffSupply(_freeMintCuttoffSupply);
    setmaxMintQuantitiesPerTx(_maxFreeMintQuantityPerTx, 25);
    setmaxMintQuantitiesPerAddress(_maxFreeMintQuantityPerAddress, 200);
    setPreRevealBaseURI(_preRevealBaseURI);
    _setDefaultRoyalty(0x19b66AA8334F467970f040ACbCfB8464042aBE09, _royaltyAmount);
  }

  modifier mintQuantityCheck(uint256 _mintQuantity) {
    require(_mintQuantity > 0 && _mintQuantity <= maxMintQuantityPerTx, 'Invalid mint quantity!');
    require(totalSupply() + _mintQuantity <= maxSupply, 'Max supply exceeded!');
    require(numberOfMintsOnAddress[msg.sender] + _mintQuantity <= maxMintQuantityPerAddress, 'Sender is trying to mint more than allowed');
    _;
  }

  function freeMintQuantityCheck(uint256 _freeMintQuantity) private view {
    if(_freeMintQuantity > 0){
        require(totalSupply() < freeMintCuttoffSupply, 'Freemints are no longer available');
        require(_freeMintQuantity <= maxFreeMintQuantityPerTx, 'Sender trying to avail too much free mints in transation!');
        require(numberOfFreeMintsOnAddress[msg.sender] + _freeMintQuantity <= maxFreeMintQuantityPerAddress, "Sender cannot avail more than allowed free mints!");
    }
  }

  modifier mintPriceCheck(uint256 _mintQuantity) {
    if(_mintQuantity==zSmallQty || _mintQuantity==zMediumQty || _mintQuantity==zLargeQty || _mintQuantity==zXLargeQty){
        if(_mintQuantity == zSmallQty){
            require(msg.value >= zSmallCost, 'Insufficient funds for bundle!');
        }
        if(_mintQuantity == zMediumQty){
            require(msg.value >= zMediumCost, 'Insufficient funds for bundle!');
        }
        if(_mintQuantity == zLargeQty){
            require(msg.value >= zLargeCost, 'Insufficient funds for bundle!');
        }
        if(_mintQuantity == zXLargeQty){
            require(msg.value >= zXLargeCost, 'Insufficient funds for bundle!');
        }
        if(_mintQuantity == zXXLargeQty){
            require(msg.value >= zXXLargeCost, 'Insufficient funds for bundle!');
        }
    }
    else{
        require(msg.value >= standardCost * _mintQuantity, 'Insufficient funds!');
    }
    _;
  }

  modifier mintPaused(){
    require(!paused, 'The contract is paused!');
    _;
  }

  function mint(uint256 _mintQuantity) public payable mintPaused mintQuantityCheck(_mintQuantity) mintPriceCheck(_mintQuantity) nonReentrant {
    numberOfMintsOnAddress[msg.sender] += _mintQuantity;
    _safeMint(_msgSender(), _mintQuantity);
  }

  function promoMint(uint256 _mintQuantity) public payable mintQuantityCheck(_mintQuantity) nonReentrant {
    require(!promoPaused, 'The promotion mints are paused!');
    uint256 freeMintQuantity;
    uint256 freeMintAddonQuantity;

    //get free mint quantity from cost
    if(msg.value == 0) freeMintQuantity = _mintQuantity;
    if(msg.value > 0) {
        freeMintAddonQuantity =  msg.value / freeMintAddonCost;
        freeMintQuantity = _mintQuantity - freeMintAddonQuantity;
    }

    freeMintQuantityCheck(freeMintQuantity);
    require(msg.value >= freeMintAddonCost * freeMintAddonQuantity, 'Insufficient funds!');

    numberOfMintsOnAddress[msg.sender] += _mintQuantity;
    numberOfFreeMintsOnAddress[msg.sender] += freeMintQuantity;
    _safeMint(_msgSender(), _mintQuantity);
  }

  function promoMintWL(uint256 _mintQuantity, bytes32[] calldata _merkleProofFreeMint) public payable mintQuantityCheck(_mintQuantity) nonReentrant {
    require(!promoWLPaused, 'The promotion WL mints are paused!');
    uint256 freeMintQuantity;
    uint256 freeMintAddonQuantity;

    //get free mint quantity from cost
    if(msg.value == 0) freeMintQuantity = _mintQuantity;
    if(msg.value > 0) {
        freeMintAddonQuantity =  msg.value / freeMintAddonCost;
        freeMintQuantity = _mintQuantity - freeMintAddonQuantity;
    }

    freeMintQuantityCheck(freeMintQuantity);
    require(msg.value >= freeMintAddonCost * freeMintAddonQuantity, 'Insufficient funds!');

    //merkle check
    bytes32 leafFreeMint = keccak256(abi.encodePacked(_msgSender()));
    require(MerkleProof.verify(_merkleProofFreeMint, merkleRootFreeMint, leafFreeMint), 'Invalid proof!');

    numberOfMintsOnAddress[msg.sender] += _mintQuantity;
    numberOfFreeMintsOnAddress[msg.sender] += freeMintQuantity;
    _safeMint(_msgSender(), _mintQuantity);
  }

  function whitelistMint(uint256 _mintQuantity, bytes32[] calldata _merkleProofWL) public payable mintQuantityCheck(_mintQuantity) nonReentrant {
    require(!whitelistPaused, 'The whitelist mints are paused!');
    require(msg.value >= whitelistCost * _mintQuantity, 'Insufficient funds!');

    bytes32 leafWL = keccak256(abi.encodePacked(_msgSender()));
    require(MerkleProof.verify(_merkleProofWL, merkleRootWL, leafWL), 'Invalid proof!');

    numberOfMintsOnAddress[msg.sender] += _mintQuantity;
    _safeMint(_msgSender(), _mintQuantity);
  }

  function mintForAddress(uint256 _mintQuantity, address _receiver) public onlyOwner {
    numberOfMintsOnAddress[_receiver] += _mintQuantity;
    _safeMint(_receiver, _mintQuantity);
  }

  function teamMint(uint256 _mintQuantity, address _receiver) public onlyOwner {
    numberOfMintsOnAddress[_receiver] += _mintQuantity;
    _safeMint(_receiver, _mintQuantity);
  }

  function getWalletTokens(address _owner) public view returns (uint256[] memory) {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
    uint256 currentTokenId = 0;
    uint256 ownedTokenIndex = 0;
    address latestOwnerAddress;

    while (ownedTokenIndex < ownerTokenCount && currentTokenId <= maxSupply) {
      TokenOwnership memory ownership = _ownerships[currentTokenId];

      if (!ownership.burned && ownership.addr != address(0)) {
        latestOwnerAddress = ownership.addr;
      }

      if (latestOwnerAddress == _owner) {
        ownedTokenIds[ownedTokenIndex] = currentTokenId;

        ownedTokenIndex++;
      }

      currentTokenId++;
    }

    return ownedTokenIds;
  }

  function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
    require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');

    if (revealed == false) {
      return string(abi.encodePacked(preRevealBaseURI, _tokenId.toString(), uriSuffix));
    }

    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), uriSuffix))
        : '';
  }

  function setRevealed(bool _state) public onlyOwner {
    revealed = _state;
  }

  function setRoyaltyInfo(address receiver, uint96 feeBasisPoints) external onlyOwner {
    _setDefaultRoyalty(receiver, feeBasisPoints);
  }

  function setCosts(uint256 _standardCost, uint256 _freeMintAddonCost, uint256 _whitelistCost) public onlyOwner {
    standardCost = _standardCost;
    freeMintAddonCost = _freeMintAddonCost;
    whitelistCost = _whitelistCost;
  }

  function setmaxMintQuantitiesPerTx(uint256 _maxFreeMintQuantityPerTx, uint256 _maxMintQuantityPerTx) public onlyOwner {
    maxFreeMintQuantityPerTx = _maxFreeMintQuantityPerTx;
    maxMintQuantityPerTx = _maxMintQuantityPerTx;
  }

  function setmaxMintQuantitiesPerAddress(uint256 _maxFreeMintQuantityPerAddress, uint256 _maxMintQuantityPerAddress) public onlyOwner {
    maxFreeMintQuantityPerAddress = _maxFreeMintQuantityPerAddress;
    maxMintQuantityPerAddress = _maxMintQuantityPerAddress;
  }

  function setPreRevealBaseURI(string memory _preRevealBaseURI) public onlyOwner {
    preRevealBaseURI = _preRevealBaseURI;
  }

  function setBaseURI(string memory __baseURI) public onlyOwner {
    baseURI = __baseURI;
  }

  function setUriSuffix(string memory _uriSuffix) public onlyOwner {
    uriSuffix = _uriSuffix;
  }

  function setPaused(bool _state, bool _promoState, bool _promoWLState, bool _whitelistState) public onlyOwner {
    paused = _state;
    promoPaused = _promoState;
    promoWLPaused = _promoWLState;
    whitelistPaused = _whitelistState;
  }

  function setMerkleRoot(bytes32 _merkleRootFreeMint, bytes32 _merkleRootWL) public onlyOwner {
    merkleRootFreeMint = _merkleRootFreeMint;
    merkleRootWL = _merkleRootWL;
  }

  function setMaxSupply(uint256 _maxSupply) public onlyOwner {
    maxSupply = _maxSupply;
  }

  function setFreeMintCuttoffSupply(uint256 _freeMintCuttoffSupply) public onlyOwner {
    freeMintCuttoffSupply = _freeMintCuttoffSupply;
  }

  function withdraw() public onlyOwner nonReentrant {
    (bool os, ) = payable(owner()).call{value: address(this).balance}('');
    require(os);
  }

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

  function supportsInterface(bytes4 interfaceId) public view override(ERC721A, ERC2981) returns (bool) {
    return super.supportsInterface(interfaceId);
  }

  function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
    super.transferFrom(from, to, tokenId);
  }

  function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
    super.safeTransferFrom(from, to, tokenId);
  }

  function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) {
    super.safeTransferFrom(from, to, tokenId, data);
  }

  function setMintBundles(uint256 _zSmallQty,uint256 _zSmallCost,uint256 _zMediumQty,uint256 _zMediumCost,uint256 _zLargeQty,uint256 _zLargeCost,uint256 _zXLargeQty,uint256 _zXLargeCost,uint256 _zXXLargeQty,uint256 _zXXLargeCost) public onlyOwner {
    zSmallQty = _zSmallQty;
    zSmallCost = _zSmallCost;
    zMediumQty = _zMediumQty;
    zMediumCost = _zMediumCost;
    zLargeQty = _zLargeQty;
    zLargeCost = _zLargeCost;
    zXLargeQty = _zXLargeQty;
    zXLargeCost = _zXLargeCost;
    zXXLargeQty = _zXXLargeQty;
    zXXLargeCost = _zXXLargeCost;
  }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_tokenName","type":"string"},{"internalType":"string","name":"_tokenSymbol","type":"string"},{"internalType":"uint256","name":"_standardCost","type":"uint256"},{"internalType":"uint256","name":"_freeMintAddonCost","type":"uint256"},{"internalType":"uint256","name":"_maxSupply","type":"uint256"},{"internalType":"uint256","name":"_freeMintCuttoffSupply","type":"uint256"},{"internalType":"uint256","name":"_maxFreeMintQuantityPerTx","type":"uint256"},{"internalType":"uint256","name":"_maxFreeMintQuantityPerAddress","type":"uint256"},{"internalType":"uint96","name":"_royaltyAmount","type":"uint96"},{"internalType":"string","name":"_preRevealBaseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMintAddonCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeMintCuttoffSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getWalletTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"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":"maxFreeMintQuantityPerAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFreeMintQuantityPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintQuantityPerAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintQuantityPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRootFreeMint","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRootWL","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mintForAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numberOfFreeMintsOnAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numberOfMintsOnAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preRevealBaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"}],"name":"promoMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProofFreeMint","type":"bytes32[]"}],"name":"promoMintWL","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"promoPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"promoWLPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"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":"_standardCost","type":"uint256"},{"internalType":"uint256","name":"_freeMintAddonCost","type":"uint256"},{"internalType":"uint256","name":"_whitelistCost","type":"uint256"}],"name":"setCosts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_freeMintCuttoffSupply","type":"uint256"}],"name":"setFreeMintCuttoffSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRootFreeMint","type":"bytes32"},{"internalType":"bytes32","name":"_merkleRootWL","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_zSmallQty","type":"uint256"},{"internalType":"uint256","name":"_zSmallCost","type":"uint256"},{"internalType":"uint256","name":"_zMediumQty","type":"uint256"},{"internalType":"uint256","name":"_zMediumCost","type":"uint256"},{"internalType":"uint256","name":"_zLargeQty","type":"uint256"},{"internalType":"uint256","name":"_zLargeCost","type":"uint256"},{"internalType":"uint256","name":"_zXLargeQty","type":"uint256"},{"internalType":"uint256","name":"_zXLargeCost","type":"uint256"},{"internalType":"uint256","name":"_zXXLargeQty","type":"uint256"},{"internalType":"uint256","name":"_zXXLargeCost","type":"uint256"}],"name":"setMintBundles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"},{"internalType":"bool","name":"_promoState","type":"bool"},{"internalType":"bool","name":"_promoWLState","type":"bool"},{"internalType":"bool","name":"_whitelistState","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_preRevealBaseURI","type":"string"}],"name":"setPreRevealBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeBasisPoints","type":"uint96"}],"name":"setRoyaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriSuffix","type":"string"}],"name":"setUriSuffix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxFreeMintQuantityPerAddress","type":"uint256"},{"internalType":"uint256","name":"_maxMintQuantityPerAddress","type":"uint256"}],"name":"setmaxMintQuantitiesPerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxFreeMintQuantityPerTx","type":"uint256"},{"internalType":"uint256","name":"_maxMintQuantityPerTx","type":"uint256"}],"name":"setmaxMintQuantitiesPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"standardCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"teamMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uriSuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintQuantity","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProofWL","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"whitelistPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"zLargeCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zLargeQty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zMediumCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zMediumQty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zSmallCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zSmallQty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zXLargeCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zXLargeQty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zXXLargeCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"zXXLargeQty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x6080604052600436106104055760003560e01c80638b1cb4cb11610213578063cbfbb28811610123578063e7b99ec7116100ab578063f0d572181161007a578063f0d5721814610b33578063f2fde38b14610b49578063f38ade9b14610b69578063f883602b14610b89578063fabc38be14610ba957600080fd5b8063e7b99ec714610ae8578063e985e9c514610afe578063eb6ac8e114610b1e578063efbd73f4146109c157600080fd5b8063d5abeb01116100f2578063d5abeb0114610a73578063d6492d8114610a89578063d7748d1f14610a9f578063e0a8085314610ab2578063e3d74c8014610ad257600080fd5b8063cbfbb28814610a17578063d04228be14610a2a578063d12da55214610a4a578063d2cab05614610a6057600080fd5b8063ab3984ff116101a6578063bd0ec15011610175578063bd0ec1501461097e578063bd5589c814610994578063bfa457bc146109c1578063c87b56dd146109e1578063cb56b23914610a0157600080fd5b8063ab3984ff14610905578063b014e41714610932578063b231db8c14610948578063b88d4fde1461095e57600080fd5b806395d89b41116101e257806395d89b41146108a7578063a0712d68146108bc578063a22cb465146108cf578063a31657e3146108ef57600080fd5b80638b1cb4cb146108335780638cb0594b146108535780638da5cb5b1461086957806393e87ddd1461088757600080fd5b80635503a0e8116103195780636c0cfbfe116102a1578063715018a611610270578063715018a6146107b257806375edcbe0146107c757806379cd719f146107e75780637f820c0b146107fd57806380ef02381461081d57600080fd5b80636c0cfbfe1461073c5780636f8b44b01461075257806370a082311461077257806370b295341461079257600080fd5b80635c975abb116102e85780635c975abb146106b657806361e61a25146106d05780636352211e146106f15780636992ee24146107115780636c0360eb1461072757600080fd5b80635503a0e81461065557806355bb53501461066a57806355f804b3146106805780635b2818cd146106a057600080fd5b80631bb994a01161039c5780633ccfd60b1161036b5780633ccfd60b146105c85780633f86a6dc146105dd57806342842e0e146105f35780635183022714610613578063539fd1bd1461063557600080fd5b80631bb994a0146105345780631d953e1e1461055357806323b872dd146105695780632a55205a1461058957600080fd5b8063095ea7b3116103d8578063095ea7b3146104bb57806316ba10e0146104db57806318160ddd146104fb578063195f2f141461051e57600080fd5b806301ffc9a71461040a57806302fa7c471461043f57806306fdde0314610461578063081812fc14610483575b600080fd5b34801561041657600080fd5b5061042a610425366004612ed1565b610bd6565b60405190151581526020015b60405180910390f35b34801561044b57600080fd5b5061045f61045a366004612f0a565b610be7565b005b34801561046d57600080fd5b50610476610bfd565b6040516104369190612f9d565b34801561048f57600080fd5b506104a361049e366004612fb0565b610c8f565b6040516001600160a01b039091168152602001610436565b3480156104c757600080fd5b5061045f6104d6366004612fc9565b610cd3565b3480156104e757600080fd5b5061045f6104f636600461307e565b610d60565b34801561050757600080fd5b50600154600054035b604051908152602001610436565b34801561052a57600080fd5b50610510600c5481565b34801561054057600080fd5b50601c5461042a90610100900460ff1681565b34801561055f57600080fd5b5061051060225481565b34801561057557600080fd5b5061045f6105843660046130c6565b610d74565b34801561059557600080fd5b506105a96105a4366004613102565b610ed5565b604080516001600160a01b039093168352602083019190915201610436565b3480156105d457600080fd5b5061045f610f81565b3480156105e957600080fd5b5061051060195481565b3480156105ff57600080fd5b5061045f61060e3660046130c6565b61100f565b34801561061f57600080fd5b50601c5461042a90640100000000900460ff1681565b34801561064157600080fd5b5061045f610650366004613132565b611160565b34801561066157600080fd5b506104766111b6565b34801561067657600080fd5b5061051060205481565b34801561068c57600080fd5b5061045f61069b36600461307e565b611244565b3480156106ac57600080fd5b5061051060185481565b3480156106c257600080fd5b50601c5461042a9060ff1681565b3480156106dc57600080fd5b50601c5461042a906301000000900460ff1681565b3480156106fd57600080fd5b506104a361070c366004612fb0565b611258565b34801561071d57600080fd5b5061051060175481565b34801561073357600080fd5b5061047661126a565b34801561074857600080fd5b50610510601e5481565b34801561075e57600080fd5b5061045f61076d366004612fb0565b611277565b34801561077e57600080fd5b5061051061078d36600461318e565b611284565b34801561079e57600080fd5b5061045f6107ad366004613102565b6112d2565b3480156107be57600080fd5b5061045f6112e5565b3480156107d357600080fd5b5061045f6107e2366004613102565b6112f7565b3480156107f357600080fd5b50610510601b5481565b34801561080957600080fd5b50601c5461042a9062010000900460ff1681565b34801561082957600080fd5b5061051060145481565b34801561083f57600080fd5b5061045f61084e3660046131a9565b61130a565b34801561085f57600080fd5b5061051060255481565b34801561087557600080fd5b506008546001600160a01b03166104a3565b34801561089357600080fd5b5061045f6108a23660046131d5565b611320565b3480156108b357600080fd5b50610476611357565b61045f6108ca366004612fb0565b611366565b3480156108db57600080fd5b5061045f6108ea36600461323d565b6115d6565b3480156108fb57600080fd5b5061051060235481565b34801561091157600080fd5b5061051061092036600461318e565b600f6020526000908152604090205481565b34801561093e57600080fd5b50610510601f5481565b34801561095457600080fd5b5061051060245481565b34801561096a57600080fd5b5061045f610979366004613269565b61166b565b34801561098a57600080fd5b5061051060265481565b3480156109a057600080fd5b506105106109af36600461318e565b600e6020526000908152604090205481565b3480156109cd57600080fd5b5061045f6109dc3660046132e4565b6117ca565b3480156109ed57600080fd5b506104766109fc366004612fb0565b61180a565b348015610a0d57600080fd5b5061051060215481565b61045f610a25366004612fb0565b611924565b348015610a3657600080fd5b5061045f610a45366004613102565b611aee565b348015610a5657600080fd5b5061051060135481565b61045f610a6e366004613310565b611b01565b348015610a7f57600080fd5b5061051060165481565b348015610a9557600080fd5b50610510600d5481565b61045f610aad366004613310565b611d25565b348015610abe57600080fd5b5061045f610acd36600461338e565b611fb3565b348015610ade57600080fd5b50610510601a5481565b348015610af457600080fd5b5061051060155481565b348015610b0a57600080fd5b5061042a610b193660046133ab565b611fdb565b348015610b2a57600080fd5b50610476612009565b348015610b3f57600080fd5b50610510601d5481565b348015610b5557600080fd5b5061045f610b6436600461318e565b612016565b348015610b7557600080fd5b5061045f610b8436600461307e565b61208f565b348015610b9557600080fd5b5061045f610ba4366004612fb0565b6120a3565b348015610bb557600080fd5b50610bc9610bc436600461318e565b6120b0565b60405161043691906133d5565b6000610be1826121f6565b92915050565b610bef61221b565b610bf98282612275565b5050565b606060028054610c0c90613419565b80601f0160208091040260200160405190810160405280929190818152602001828054610c3890613419565b8015610c855780601f10610c5a57610100808354040283529160200191610c85565b820191906000526020600020905b815481529060010190602001808311610c6857829003601f168201915b5050505050905090565b6000610c9a82612372565b610cb7576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b6000610cde82611258565b9050806001600160a01b0316836001600160a01b031603610d125760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b03821614801590610d325750610d308133611fdb565b155b15610d50576040516367d9dca160e11b815260040160405180910390fd5b610d5b83838361239d565b505050565b610d6861221b565b6011610bf982826134a1565b826daaeb6d7670e522a718067333cd4e3b15610ec457336001600160a01b03821603610daa57610da58484846123f9565b610ecf565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015610df9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e1d9190613560565b8015610ea05750604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015610e7c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ea09190613560565b610ec457604051633b79c77360e21b81523360048201526024015b60405180910390fd5b610ecf8484846123f9565b50505050565b6000828152600b602090815260408083208151808301909252546001600160a01b038116808352600160a01b9091046001600160601b0316928201929092528291610f4a575060408051808201909152600a546001600160a01b0381168252600160a01b90046001600160601b031660208201525b602081015160009061271090610f69906001600160601b031687613593565b610f7391906135aa565b915196919550909350505050565b610f8961221b565b610f91612404565b6000610fa56008546001600160a01b031690565b6001600160a01b03164760405160006040518083038185875af1925050503d8060008114610fef576040519150601f19603f3d011682016040523d82523d6000602084013e610ff4565b606091505b505090508061100257600080fd5b5061100d6001600955565b565b826daaeb6d7670e522a718067333cd4e3b1561115557336001600160a01b0382160361104057610da584848461245d565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa15801561108f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110b39190613560565b80156111365750604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015611112573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111369190613560565b61115557604051633b79c77360e21b8152336004820152602401610ebb565b610ecf84848461245d565b61116861221b565b601c805461ffff191694151561ff00191694909417610100931515939093029290921763ffff00001916620100009115159190910263ff000000191617630100000091151591909102179055565b601180546111c390613419565b80601f01602080910402602001604051908101604052809291908181526020018280546111ef90613419565b801561123c5780601f106112115761010080835404028352916020019161123c565b820191906000526020600020905b81548152906001019060200180831161121f57829003601f168201915b505050505081565b61124c61221b565b6010610bf982826134a1565b600061126382612478565b5192915050565b601080546111c390613419565b61127f61221b565b601655565b60006001600160a01b0382166112ad576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b6112da61221b565b601991909155601855565b6112ed61221b565b61100d6000612592565b6112ff61221b565b600c91909155600d55565b61131261221b565b601392909255601455601555565b61132861221b565b601d99909955601e97909755601f95909555602093909355602191909155602255602355602455602555602655565b606060038054610c0c90613419565b601c5460ff16156113b95760405162461bcd60e51b815260206004820152601760248201527f54686520636f6e747261637420697320706175736564210000000000000000006044820152606401610ebb565b806000811180156113cc57506018548111155b6113e85760405162461bcd60e51b8152600401610ebb906135cc565b601654816113f96001546000540390565b61140391906135fc565b11156114215760405162461bcd60e51b8152600401610ebb9061360f565b601a54336000908152600e602052604090205461143f9083906135fc565b111561145d5760405162461bcd60e51b8152600401610ebb9061363d565b81601d5481148061146f5750601f5481145b8061147b575060215481145b80611487575060235481145b1561156857601d5481036114b757601e543410156114b75760405162461bcd60e51b8152600401610ebb90613687565b601f5481036114e2576020543410156114e25760405162461bcd60e51b8152600401610ebb90613687565b602154810361150d5760225434101561150d5760405162461bcd60e51b8152600401610ebb90613687565b6023548103611538576024543410156115385760405162461bcd60e51b8152600401610ebb90613687565b6025548103611563576026543410156115635760405162461bcd60e51b8152600401610ebb90613687565b611595565b806013546115769190613593565b3410156115955760405162461bcd60e51b8152600401610ebb906136be565b61159d612404565b336000908152600e6020526040812080548592906115bc9084906135fc565b909155506115cc905033846125e4565b610d5b6001600955565b336001600160a01b038316036115ff5760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b836daaeb6d7670e522a718067333cd4e3b156117b757336001600160a01b038216036116a25761169d858585856125fe565b6117c3565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa1580156116f1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117159190613560565b80156117985750604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015611774573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117989190613560565b6117b757604051633b79c77360e21b8152336004820152602401610ebb565b6117c3858585856125fe565b5050505050565b6117d261221b565b6001600160a01b0381166000908152600e6020526040812080548492906117fa9084906135fc565b90915550610bf9905081836125e4565b606061181582612372565b6118795760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610ebb565b601c54640100000000900460ff1615156000036118c557601261189b83612649565b60116040516020016118af9392919061375e565b6040516020818303038152906040529050919050565b60006118cf6126db565b905060008151116118ef576040518060200160405280600081525061191d565b806118f984612649565b601160405160200161190d93929190613791565b6040516020818303038152906040525b9392505050565b8060008111801561193757506018548111155b6119535760405162461bcd60e51b8152600401610ebb906135cc565b601654816119646001546000540390565b61196e91906135fc565b111561198c5760405162461bcd60e51b8152600401610ebb9061360f565b601a54336000908152600e60205260409020546119aa9083906135fc565b11156119c85760405162461bcd60e51b8152600401610ebb9061363d565b6119d0612404565b601c54610100900460ff1615611a285760405162461bcd60e51b815260206004820152601f60248201527f5468652070726f6d6f74696f6e206d696e7473206172652070617573656421006044820152606401610ebb565b60008034600003611a37578391505b3415611a5957601454611a4a90346135aa565b9050611a5681856137b7565b91505b611a62826126ea565b80601454611a709190613593565b341015611a8f5760405162461bcd60e51b8152600401610ebb906136be565b336000908152600e602052604081208054869290611aae9084906135fc565b9091555050336000908152600f602052604081208054849290611ad29084906135fc565b90915550611ae2905033856125e4565b5050610bf96001600955565b611af661221b565b601b91909155601a55565b82600081118015611b1457506018548111155b611b305760405162461bcd60e51b8152600401610ebb906135cc565b60165481611b416001546000540390565b611b4b91906135fc565b1115611b695760405162461bcd60e51b8152600401610ebb9061360f565b601a54336000908152600e6020526040902054611b879083906135fc565b1115611ba55760405162461bcd60e51b8152600401610ebb9061363d565b611bad612404565b601c546301000000900460ff1615611c075760405162461bcd60e51b815260206004820152601f60248201527f5468652077686974656c697374206d696e7473206172652070617573656421006044820152606401610ebb565b83601554611c159190613593565b341015611c345760405162461bcd60e51b8152600401610ebb906136be565b6040516bffffffffffffffffffffffff193360601b166020820152600090603401604051602081830303815290604052805190602001209050611cae84848080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600d54915084905061284f565b611ceb5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c69642070726f6f662160901b6044820152606401610ebb565b336000908152600e602052604081208054879290611d0a9084906135fc565b90915550611d1a905033866125e4565b50610ecf6001600955565b82600081118015611d3857506018548111155b611d545760405162461bcd60e51b8152600401610ebb906135cc565b60165481611d656001546000540390565b611d6f91906135fc565b1115611d8d5760405162461bcd60e51b8152600401610ebb9061360f565b601a54336000908152600e6020526040902054611dab9083906135fc565b1115611dc95760405162461bcd60e51b8152600401610ebb9061363d565b611dd1612404565b601c5462010000900460ff1615611e355760405162461bcd60e51b815260206004820152602260248201527f5468652070726f6d6f74696f6e20574c206d696e747320617265207061757365604482015261642160f01b6064820152608401610ebb565b60008034600003611e44578591505b3415611e6657601454611e5790346135aa565b9050611e6381876137b7565b91505b611e6f826126ea565b80601454611e7d9190613593565b341015611e9c5760405162461bcd60e51b8152600401610ebb906136be565b6040516bffffffffffffffffffffffff193360601b166020820152600090603401604051602081830303815290604052805190602001209050611f1686868080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600c54915084905061284f565b611f535760405162461bcd60e51b815260206004820152600e60248201526d496e76616c69642070726f6f662160901b6044820152606401610ebb565b336000908152600e602052604081208054899290611f729084906135fc565b9091555050336000908152600f602052604081208054859290611f969084906135fc565b90915550611fa6905033886125e4565b505050610ecf6001600955565b611fbb61221b565b601c80549115156401000000000264ff0000000019909216919091179055565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b601280546111c390613419565b61201e61221b565b6001600160a01b0381166120835760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610ebb565b61208c81612592565b50565b61209761221b565b6012610bf982826134a1565b6120ab61221b565b601755565b606060006120bd83611284565b90506000816001600160401b038111156120d9576120d9612ff3565b604051908082528060200260200182016040528015612102578160200160208202803683370190505b50905060008060005b848210801561211c57506016548311155b156121eb57600083815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff161580159282018390529091612189575080516001600160a01b031615155b1561219357805191505b876001600160a01b0316826001600160a01b0316036121d857838584815181106121bf576121bf6137ca565b6020908102919091010152826121d4816137e0565b9350505b836121e2816137e0565b9450505061210b565b509195945050505050565b60006001600160e01b0319821663152a902d60e11b1480610be15750610be182612865565b6008546001600160a01b0316331461100d5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610ebb565b6127106001600160601b03821611156122e35760405162461bcd60e51b815260206004820152602a60248201527f455243323938313a20726f79616c7479206665652077696c6c206578636565646044820152692073616c65507269636560b01b6064820152608401610ebb565b6001600160a01b0382166123395760405162461bcd60e51b815260206004820152601960248201527f455243323938313a20696e76616c6964207265636569766572000000000000006044820152606401610ebb565b604080518082019091526001600160a01b039092168083526001600160601b039091166020909201829052600160a01b90910217600a55565b6000805482108015610be1575050600090815260046020526040902054600160e01b900460ff161590565b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b610d5b8383836128b5565b6002600954036124565760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610ebb565b6002600955565b610d5b8383836040518060200160405280600081525061166b565b60408051606081018252600080825260208201819052918101919091528160005481101561257957600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff161515918101829052906125775780516001600160a01b03161561250e579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff1615159281019290925215612572579392505050565b61250e565b505b604051636f96cda160e11b815260040160405180910390fd5b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610bf9828260405180602001604052806000815250612aa0565b6126098484846128b5565b6001600160a01b0383163b1515801561262b575061262984848484612aad565b155b15610ecf576040516368d2bf6b60e11b815260040160405180910390fd5b6060600061265683612b99565b60010190506000816001600160401b0381111561267557612675612ff3565b6040519080825280601f01601f19166020018201604052801561269f576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a85049450846126a957509392505050565b606060108054610c0c90613419565b801561208c5760175460015460005403106127515760405162461bcd60e51b815260206004820152602160248201527f467265656d696e747320617265206e6f206c6f6e67657220617661696c61626c6044820152606560f81b6064820152608401610ebb565b6019548111156127c95760405162461bcd60e51b815260206004820152603960248201527f53656e64657220747279696e6720746f20617661696c20746f6f206d7563682060448201527f66726565206d696e747320696e207472616e736174696f6e21000000000000006064820152608401610ebb565b601b54336000908152600f60205260409020546127e79083906135fc565b111561208c5760405162461bcd60e51b815260206004820152603160248201527f53656e6465722063616e6e6f7420617661696c206d6f7265207468616e20616c6044820152706c6f7765642066726565206d696e74732160781b6064820152608401610ebb565b60008261285c8584612c71565b14949350505050565b60006001600160e01b031982166380ac58cd60e01b148061289657506001600160e01b03198216635b5e139f60e01b145b80610be157506301ffc9a760e01b6001600160e01b0319831614610be1565b60006128c082612478565b9050836001600160a01b031681600001516001600160a01b0316146128f75760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b038616148061291557506129158533611fdb565b8061293057503361292584610c8f565b6001600160a01b0316145b90508061295057604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b03841661297757604051633a954ecd60e21b815260040160405180910390fd5b6129836000848761239d565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b42909216919091021783558701808452922080549193909116612a57576000548214612a5757805460208601516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505082846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a46117c3565b610d5b8383836001612cbe565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290612ae29033908990889088906004016137f9565b6020604051808303816000875af1925050508015612b1d575060408051601f3d908101601f19168201909252612b1a91810190613836565b60015b612b7b573d808015612b4b576040519150601f19603f3d011682016040523d82523d6000602084013e612b50565b606091505b508051600003612b73576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490505b949350505050565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b8310612bd85772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310612c04576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc100008310612c2257662386f26fc10000830492506010015b6305f5e1008310612c3a576305f5e100830492506008015b6127108310612c4e57612710830492506004015b60648310612c60576064830492506002015b600a8310610be15760010192915050565b600081815b8451811015612cb657612ca282868381518110612c9557612c956137ca565b6020026020010151612e8f565b915080612cae816137e0565b915050612c76565b509392505050565b6000546001600160a01b038516612ce757604051622e076360e81b815260040160405180910390fd5b83600003612d085760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c0181169182176801000000000000000067ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015612db957506001600160a01b0387163b15155b15612e41575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4612e0a6000888480600101955088612aad565b612e27576040516368d2bf6b60e11b815260040160405180910390fd5b808203612dbf578260005414612e3c57600080fd5b612e86565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4808203612e42575b506000556117c3565b6000818310612eab57600082815260208490526040902061191d565b5060009182526020526040902090565b6001600160e01b03198116811461208c57600080fd5b600060208284031215612ee357600080fd5b813561191d81612ebb565b80356001600160a01b0381168114612f0557600080fd5b919050565b60008060408385031215612f1d57600080fd5b612f2683612eee565b915060208301356001600160601b0381168114612f4257600080fd5b809150509250929050565b60005b83811015612f68578181015183820152602001612f50565b50506000910152565b60008151808452612f89816020860160208601612f4d565b601f01601f19169290920160200192915050565b60208152600061191d6020830184612f71565b600060208284031215612fc257600080fd5b5035919050565b60008060408385031215612fdc57600080fd5b612fe583612eee565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b60006001600160401b038084111561302357613023612ff3565b604051601f8501601f19908116603f0116810190828211818310171561304b5761304b612ff3565b8160405280935085815286868601111561306457600080fd5b858560208301376000602087830101525050509392505050565b60006020828403121561309057600080fd5b81356001600160401b038111156130a657600080fd5b8201601f810184136130b757600080fd5b612b9184823560208401613009565b6000806000606084860312156130db57600080fd5b6130e484612eee565b92506130f260208501612eee565b9150604084013590509250925092565b6000806040838503121561311557600080fd5b50508035926020909101359150565b801515811461208c57600080fd5b6000806000806080858703121561314857600080fd5b843561315381613124565b9350602085013561316381613124565b9250604085013561317381613124565b9150606085013561318381613124565b939692955090935050565b6000602082840312156131a057600080fd5b61191d82612eee565b6000806000606084860312156131be57600080fd5b505081359360208301359350604090920135919050565b6000806000806000806000806000806101408b8d0312156131f557600080fd5b505088359a60208a01359a5060408a013599606081013599506080810135985060a0810135975060c0810135965060e081013595506101008101359450610120013592509050565b6000806040838503121561325057600080fd5b61325983612eee565b91506020830135612f4281613124565b6000806000806080858703121561327f57600080fd5b61328885612eee565b935061329660208601612eee565b92506040850135915060608501356001600160401b038111156132b857600080fd5b8501601f810187136132c957600080fd5b6132d887823560208401613009565b91505092959194509250565b600080604083850312156132f757600080fd5b8235915061330760208401612eee565b90509250929050565b60008060006040848603121561332557600080fd5b8335925060208401356001600160401b038082111561334357600080fd5b818601915086601f83011261335757600080fd5b81358181111561336657600080fd5b8760208260051b850101111561337b57600080fd5b6020830194508093505050509250925092565b6000602082840312156133a057600080fd5b813561191d81613124565b600080604083850312156133be57600080fd5b6133c783612eee565b915061330760208401612eee565b6020808252825182820181905260009190848201906040850190845b8181101561340d578351835292840192918401916001016133f1565b50909695505050505050565b600181811c9082168061342d57607f821691505b60208210810361344d57634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115610d5b57600081815260208120601f850160051c8101602086101561347a5750805b601f850160051c820191505b8181101561349957828155600101613486565b505050505050565b81516001600160401b038111156134ba576134ba612ff3565b6134ce816134c88454613419565b84613453565b602080601f83116001811461350357600084156134eb5750858301515b600019600386901b1c1916600185901b178555613499565b600085815260208120601f198616915b8281101561353257888601518255948401946001909101908401613513565b50858210156135505787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60006020828403121561357257600080fd5b815161191d81613124565b634e487b7160e01b600052601160045260246000fd5b8082028115828204841417610be157610be161357d565b6000826135c757634e487b7160e01b600052601260045260246000fd5b500490565b602080825260169082015275496e76616c6964206d696e74207175616e746974792160501b604082015260600190565b80820180821115610be157610be161357d565b6020808252601490820152734d617820737570706c792065786365656465642160601b604082015260600190565b6020808252602a908201527f53656e64657220697320747279696e6720746f206d696e74206d6f7265207468604082015269185b88185b1b1bddd95960b21b606082015260800190565b6020808252601e908201527f496e73756666696369656e742066756e647320666f722062756e646c65210000604082015260600190565b602080825260139082015272496e73756666696369656e742066756e64732160681b604082015260600190565b600081546136f881613419565b60018281168015613710576001811461372557613754565b60ff1984168752821515830287019450613754565b8560005260208060002060005b8581101561374b5781548a820152908401908201613732565b50505082870194505b5050505092915050565b600061376a82866136eb565b845161377a818360208901612f4d565b613786818301866136eb565b979650505050505050565b600084516137a3818460208901612f4d565b84519083019061377a818360208901612f4d565b81810381811115610be157610be161357d565b634e487b7160e01b600052603260045260246000fd5b6000600182016137f2576137f261357d565b5060010190565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061382c90830184612f71565b9695505050505050565b60006020828403121561384857600080fd5b815161191d81612ebb56fea2646970667358221220f52b93ed3c91d56a9854344578096eb4342413f41417f8a1a06b0fc2bdd16ba164736f6c63430008110033

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

00000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000c6f3b40b6c000000000000000000000000000000000000000000000000000000c6f3b40b6c00000000000000000000000000000000000000000000000000000000000000027100000000000000000000000000000000000000000000000000000000000001b5800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000038400000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000000c486f6f74794f776c734e465400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003484f500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002668747470733a2f2f686f6f74796f776c736e66742e636f6d2f6170692f686f6f74796f776c2f0000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _tokenName (string): HootyOwlsNFT
Arg [1] : _tokenSymbol (string): HOP
Arg [2] : _standardCost (uint256): 3500000000000000
Arg [3] : _freeMintAddonCost (uint256): 3500000000000000
Arg [4] : _maxSupply (uint256): 10000
Arg [5] : _freeMintCuttoffSupply (uint256): 7000
Arg [6] : _maxFreeMintQuantityPerTx (uint256): 1
Arg [7] : _maxFreeMintQuantityPerAddress (uint256): 1
Arg [8] : _royaltyAmount (uint96): 900
Arg [9] : _preRevealBaseURI (string): https://hootyowlsnft.com/api/hootyowl/

-----Encoded View---------------
17 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [2] : 000000000000000000000000000000000000000000000000000c6f3b40b6c000
Arg [3] : 000000000000000000000000000000000000000000000000000c6f3b40b6c000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [5] : 0000000000000000000000000000000000000000000000000000000000001b58
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000384
Arg [9] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [10] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [11] : 486f6f74794f776c734e46540000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [13] : 484f500000000000000000000000000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000026
Arg [15] : 68747470733a2f2f686f6f74796f776c736e66742e636f6d2f6170692f686f6f
Arg [16] : 74796f776c2f0000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

80269:12066:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91070:157;;;;;;;;;;-1:-1:-1;91070:157:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;91070:157:0;;;;;;;;88880:141;;;;;;;;;;-1:-1:-1;88880:141:0;;;;;:::i;:::-;;:::i;:::-;;45749:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;47252:204::-;;;;;;;;;;-1:-1:-1;47252:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2246:32:1;;;2228:51;;2216:2;2201:18;47252:204:0;2082:203:1;46815:371:0;;;;;;;;;;-1:-1:-1;46815:371:0;;;;;:::i;:::-;;:::i;90015:100::-;;;;;;;;;;-1:-1:-1;90015:100:0;;;;;:::i;:::-;;:::i;41885:303::-;;;;;;;;;;-1:-1:-1;42139:12:0;;41929:7;42123:13;:28;41885:303;;;3920:25:1;;;3908:2;3893:18;41885:303:0;3774:177:1;80394:33:0;;;;;;;;;;;;;;;;81084:30;;;;;;;;;;-1:-1:-1;81084:30:0;;;;;;;;;;;81401:25;;;;;;;;;;;;;;;;91233:157;;;;;;;;;;-1:-1:-1;91233:157:0;;;;;:::i;:::-;;:::i;76917:442::-;;;;;;;;;;-1:-1:-1;76917:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4916:32:1;;;4898:51;;4980:2;4965:18;;4958:34;;;;4871:18;76917:442:0;4724:274:1;90806:150:0;;;;;;;;;;;;;:::i;80914:39::-;;;;;;;;;;;;;;;;91396:165;;;;;;;;;;-1:-1:-1;91396:165:0;;;;;:::i;:::-;;:::i;81195:28::-;;;;;;;;;;-1:-1:-1;81195:28:0;;;;;;;;;;;90121:245;;;;;;;;;;-1:-1:-1;90121:245:0;;;;;:::i;:::-;;:::i;80625:33::-;;;;;;;;;;;;;:::i;81341:26::-;;;;;;;;;;;;;;;;89915:94;;;;;;;;;;-1:-1:-1;89915:94:0;;;;;:::i;:::-;;:::i;80874:35::-;;;;;;;;;;;;;;;;81054:25;;;;;;;;;;-1:-1:-1;81054:25:0;;;;;;;;81156:34;;;;;;;;;;-1:-1:-1;81156:34:0;;;;;;;;;;;45557:125;;;;;;;;;;-1:-1:-1;45557:125:0;;;;;:::i;:::-;;:::i;80833:36::-;;;;;;;;;;;;;;;;80594:26;;;;;;;;;;;;;:::i;81281:25::-;;;;;;;;;;;;;;;;90558:94;;;;;;;;;;-1:-1:-1;90558:94:0;;;;;:::i;:::-;;:::i;43005:206::-;;;;;;;;;;-1:-1:-1;43005:206:0;;;;;:::i;:::-;;:::i;89266:234::-;;;;;;;;;;-1:-1:-1;89266:234:0;;;;;:::i;:::-;;:::i;62218:103::-;;;;;;;;;;;;;:::i;90372:180::-;;;;;;;;;;-1:-1:-1;90372:180:0;;;;;:::i;:::-;;:::i;81003:44::-;;;;;;;;;;;;;;;;81119:32;;;;;;;;;;-1:-1:-1;81119:32:0;;;;;;;;;;;80734;;;;;;;;;;;;;;;;89027:233;;;;;;;;;;-1:-1:-1;89027:233:0;;;;;:::i;:::-;;:::i;81492:26::-;;;;;;;;;;;;;;;;61570:87;;;;;;;;;;-1:-1:-1;61643:6:0;;-1:-1:-1;;;;;61643:6:0;61570:87;;91763:567;;;;;;;;;;-1:-1:-1;91763:567:0;;;;;:::i;:::-;;:::i;45918:104::-;;;;;;;;;;;;;:::i;84406:248::-;;;;;;:::i;:::-;;:::i;47528:287::-;;;;;;;;;;-1:-1:-1;47528:287:0;;;;;:::i;:::-;;:::i;81431:25::-;;;;;;;;;;;;;;;;80526:61;;;;;;;;;;-1:-1:-1;80526:61:0;;;;;:::i;:::-;;;;;;;;;;;;;;81311:25;;;;;;;;;;;;;;;;81461:26;;;;;;;;;;;;;;;;91567:190;;;;;;;;;;-1:-1:-1;91567:190:0;;;;;:::i;:::-;;:::i;81523:27::-;;;;;;;;;;;;;;;;80464:57;;;;;;;;;;-1:-1:-1;80464:57:0;;;;;:::i;:::-;;;;;;;;;;;;;;87307:182;;;;;;;;;;-1:-1:-1;87307:182:0;;;;;:::i;:::-;;:::i;88285:502::-;;;;;;;;;;-1:-1:-1;88285:502:0;;;;;:::i;:::-;;:::i;81372:24::-;;;;;;;;;;;;;;;;84660:814;;;;;;:::i;:::-;;:::i;89506:269::-;;;;;;;;;;-1:-1:-1;89506:269:0;;;;;:::i;:::-;;:::i;80702:27::-;;;;;;;;;;;;;;;;86549:558;;;;;;:::i;:::-;;:::i;80804:24::-;;;;;;;;;;;;;;;;80432:27;;;;;;;;;;;;;;;;85480:1063;;;;;;:::i;:::-;;:::i;88793:81::-;;;;;;;;;;-1:-1:-1;88793:81:0;;;;;:::i;:::-;;:::i;80958:40::-;;;;;;;;;;;;;;;;80771:28;;;;;;;;;;;;;;;;47886:164;;;;;;;;;;-1:-1:-1;47886:164:0;;;;;:::i;:::-;;:::i;80663:30::-;;;;;;;;;;;;;:::i;81252:24::-;;;;;;;;;;;;;;;;62476:201;;;;;;;;;;-1:-1:-1;62476:201:0;;;;;:::i;:::-;;:::i;89781:128::-;;;;;;;;;;-1:-1:-1;89781:128:0;;;;;:::i;:::-;;:::i;90658:142::-;;;;;;;;;;-1:-1:-1;90658:142:0;;;;;:::i;:::-;;:::i;87495:784::-;;;;;;;;;;-1:-1:-1;87495:784:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;91070:157::-;91165:4;91185:36;91209:11;91185:23;:36::i;:::-;91178:43;91070:157;-1:-1:-1;;91070:157:0:o;88880:141::-;61456:13;:11;:13::i;:::-;88971:44:::1;88990:8;89000:14;88971:18;:44::i;:::-;88880:141:::0;;:::o;45749:100::-;45803:13;45836:5;45829:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45749:100;:::o;47252:204::-;47320:7;47345:16;47353:7;47345;:16::i;:::-;47340:64;;47370:34;;-1:-1:-1;;;47370:34:0;;;;;;;;;;;47340:64;-1:-1:-1;47424:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;47424:24:0;;47252:204::o;46815:371::-;46888:13;46904:24;46920:7;46904:15;:24::i;:::-;46888:40;;46949:5;-1:-1:-1;;;;;46943:11:0;:2;-1:-1:-1;;;;;46943:11:0;;46939:48;;46963:24;;-1:-1:-1;;;46963:24:0;;;;;;;;;;;46939:48;22300:10;-1:-1:-1;;;;;47004:21:0;;;;;;:63;;-1:-1:-1;47030:37:0;47047:5;22300:10;47886:164;:::i;47030:37::-;47029:38;47004:63;47000:138;;;47091:35;;-1:-1:-1;;;47091:35:0;;;;;;;;;;;47000:138;47150:28;47159:2;47163:7;47172:5;47150:8;:28::i;:::-;46877:309;46815:371;;:::o;90015:100::-;61456:13;:11;:13::i;:::-;90087:9:::1;:22;90099:10:::0;90087:9;:22:::1;:::i;91233:157::-:0;91334:4;2457:42;3597:43;:47;3593:699;;3884:10;-1:-1:-1;;;;;3876:18:0;;;3872:85;;91347:37:::1;91366:4;91372:2;91376:7;91347:18;:37::i;:::-;3935:7:::0;;3872:85;4017:67;;-1:-1:-1;;;4017:67:0;;4066:4;4017:67;;;13235:34:1;4073:10:0;13285:18:1;;;13278:43;2457:42:0;;4017:40;;13170:18:1;;4017:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4113:61:0;;-1:-1:-1;;;4113:61:0;;4162:4;4113:61;;;13235:34:1;-1:-1:-1;;;;;13305:15:1;;13285:18;;;13278:43;2457:42:0;;4113:40;;13170:18:1;;4113:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3971:310;;4235:30;;-1:-1:-1;;;4235:30:0;;4254:10;4235:30;;;2228:51:1;2201:18;;4235:30:0;;;;;;;;3971:310;91347:37:::1;91366:4;91372:2;91376:7;91347:18;:37::i;:::-;91233:157:::0;;;;:::o;76917:442::-;77014:7;77072:27;;;:17;:27;;;;;;;;77043:56;;;;;;;;;-1:-1:-1;;;;;77043:56:0;;;;;-1:-1:-1;;;77043:56:0;;;-1:-1:-1;;;;;77043:56:0;;;;;;;;77014:7;;77112:92;;-1:-1:-1;77163:29:0;;;;;;;;;77173:19;77163:29;-1:-1:-1;;;;;77163:29:0;;;;-1:-1:-1;;;77163:29:0;;-1:-1:-1;;;;;77163:29:0;;;;;77112:92;77254:23;;;;77216:21;;77725:5;;77241:36;;-1:-1:-1;;;;;77241:36:0;:10;:36;:::i;:::-;77240:58;;;;:::i;:::-;77319:16;;;;;-1:-1:-1;76917:442:0;;-1:-1:-1;;;;76917:442:0:o;90806:150::-;61456:13;:11;:13::i;:::-;73952:21:::1;:19;:21::i;:::-;90864:7:::2;90885;61643:6:::0;;-1:-1:-1;;;;;61643:6:0;;61570:87;90885:7:::2;-1:-1:-1::0;;;;;90877:21:0::2;90906;90877:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90863:69;;;90947:2;90939:11;;;::::0;::::2;;90856:100;73996:20:::1;73390:1:::0;74516:7;:22;74333:213;73996:20:::1;90806:150::o:0;91396:165::-;91501:4;2457:42;3597:43;:47;3593:699;;3884:10;-1:-1:-1;;;;;3876:18:0;;;3872:85;;91514:41:::1;91537:4;91543:2;91547:7;91514:22;:41::i;3872:85::-:0;4017:67;;-1:-1:-1;;;4017:67:0;;4066:4;4017:67;;;13235:34:1;4073:10:0;13285:18:1;;;13278:43;2457:42:0;;4017:40;;13170:18:1;;4017:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4113:61:0;;-1:-1:-1;;;4113:61:0;;4162:4;4113:61;;;13235:34:1;-1:-1:-1;;;;;13305:15:1;;13285:18;;;13278:43;2457:42:0;;4113:40;;13170:18:1;;4113:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3971:310;;4235:30;;-1:-1:-1;;;4235:30:0;;4254:10;4235:30;;;2228:51:1;2201:18;;4235:30:0;2082:203:1;3971:310:0;91514:41:::1;91537:4;91543:2;91547:7;91514:22;:41::i;90121:245::-:0;61456:13;:11;:13::i;:::-;90237:6:::1;:15:::0;;-1:-1:-1;;90259:25:0;90237:15;::::1;;-1:-1:-1::0;;90259:25:0;;;;;90237:15:::1;90259:25:::0;::::1;;::::0;;;::::1;::::0;;;::::1;-1:-1:-1::0;;90327:33:0;90291:29;;::::1;;::::0;;;::::1;-1:-1:-1::0;;90327:33:0;;;;::::1;;::::0;;;::::1;;::::0;;90121:245::o;80625:33::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;89915:94::-;61456:13;:11;:13::i;:::-;89984:7:::1;:19;89994:9:::0;89984:7;:19:::1;:::i;45557:125::-:0;45621:7;45648:21;45661:7;45648:12;:21::i;:::-;:26;;45557:125;-1:-1:-1;;45557:125:0:o;80594:26::-;;;;;;;:::i;90558:94::-;61456:13;:11;:13::i;:::-;90624:9:::1;:22:::0;90558:94::o;43005:206::-;43069:7;-1:-1:-1;;;;;43093:19:0;;43089:60;;43121:28;;-1:-1:-1;;;43121:28:0;;;;;;;;;;;43089:60;-1:-1:-1;;;;;;43175:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;43175:27:0;;43005:206::o;89266:234::-;61456:13;:11;:13::i;:::-;89391:24:::1;:52:::0;;;;89450:20:::1;:44:::0;89266:234::o;62218:103::-;61456:13;:11;:13::i;:::-;62283:30:::1;62310:1;62283:18;:30::i;90372:180::-:0;61456:13;:11;:13::i;:::-;90471:18:::1;:40:::0;;;;90518:12:::1;:28:::0;90372:180::o;89027:233::-;61456:13;:11;:13::i;:::-;89144:12:::1;:28:::0;;;;89179:17:::1;:38:::0;89224:13:::1;:30:::0;89027:233::o;91763:567::-;61456:13;:11;:13::i;:::-;92015:9:::1;:22:::0;;;;92044:10:::1;:24:::0;;;;92075:10:::1;:24:::0;;;;92106:11:::1;:26:::0;;;;92139:9:::1;:22:::0;;;;92168:10:::1;:24:::0;92199:10:::1;:24:::0;92230:11:::1;:26:::0;92263:11:::1;:26:::0;92296:12:::1;:28:::0;91763:567::o;45918:104::-;45974:13;46007:7;46000:14;;;;;:::i;84406:248::-;84352:6;;;;84351:7;84343:43;;;;-1:-1:-1;;;84343:43:0;;14653:2:1;84343:43:0;;;14635:21:1;14692:2;14672:18;;;14665:30;14731:25;14711:18;;;14704:53;14774:18;;84343:43:0;14451:347:1;84343:43:0;84487:13:::1;82527:1;82511:13;:17;:58;;;;;82549:20;;82532:13;:37;;82511:58;82503:93;;;;-1:-1:-1::0;;;82503:93:0::1;;;;;;;:::i;:::-;82644:9;;82627:13;82611;42139:12:::0;;41929:7;42123:13;:28;;41885:303;82611:13:::1;:29;;;;:::i;:::-;:42;;82603:75;;;;-1:-1:-1::0;;;82603:75:0::1;;;;;;;:::i;:::-;82747:25;::::0;82716:10:::1;82693:34;::::0;;;:22:::1;:34;::::0;;;;;:50:::1;::::0;82730:13;;82693:50:::1;:::i;:::-;:79;;82685:134;;;;-1:-1:-1::0;;;82685:134:0::1;;;;;;;:::i;:::-;84517:13:::2;83417:9;;83402:13;:24;:53;;;;83445:10;;83430:13;:25;83402:53;:81;;;;83474:9;;83459:13;:24;83402:81;:110;;;;83502:10;;83487:13;:25;83402:110;83399:897;;;83544:9;;83527:13;:26:::0;83524:123:::2;;83590:10;;83577:9;:23;;83569:66;;;;-1:-1:-1::0;;;83569:66:0::2;;;;;;;:::i;:::-;83677:10;;83660:13;:27:::0;83657:125:::2;;83724:11;;83711:9;:24;;83703:67;;;;-1:-1:-1::0;;;83703:67:0::2;;;;;;;:::i;:::-;83812:9;;83795:13;:26:::0;83792:123:::2;;83858:10;;83845:9;:23;;83837:66;;;;-1:-1:-1::0;;;83837:66:0::2;;;;;;;:::i;:::-;83945:10;;83928:13;:27:::0;83925:125:::2;;83992:11;;83979:9;:24;;83971:67;;;;-1:-1:-1::0;;;83971:67:0::2;;;;;;;:::i;:::-;84080:11;;84063:13;:28:::0;84060:127:::2;;84128:12;;84115:9;:25;;84107:68;;;;-1:-1:-1::0;;;84107:68:0::2;;;;;;;:::i;:::-;83399:897;;;84251:13;84236:12;;:28;;;;:::i;:::-;84223:9;:41;;84215:73;;;;-1:-1:-1::0;;;84215:73:0::2;;;;;;;:::i;:::-;73952:21:::3;:19;:21::i;:::-;84575:10:::4;84552:34;::::0;;;:22:::4;:34;::::0;;;;:51;;84590:13;;84552:34;:51:::4;::::0;84590:13;;84552:51:::4;:::i;:::-;::::0;;;-1:-1:-1;84610:38:0::4;::::0;-1:-1:-1;22300:10:0;84634:13:::4;84610:9;:38::i;:::-;73996:20:::3;73390:1:::0;74516:7;:22;74333:213;47528:287;22300:10;-1:-1:-1;;;;;47627:24:0;;;47623:54;;47660:17;;-1:-1:-1;;;47660:17:0;;;;;;;;;;;47623:54;22300:10;47690:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;47690:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;47690:53:0;;;;;;;;;;47759:48;;540:41:1;;;47690:42:0;;22300:10;47759:48;;513:18:1;47759:48:0;;;;;;;47528:287;;:::o;91567:190::-;91691:4;2457:42;3597:43;:47;3593:699;;3884:10;-1:-1:-1;;;;;3876:18:0;;;3872:85;;91704:47:::1;91727:4;91733:2;91737:7;91746:4;91704:22;:47::i;:::-;3935:7:::0;;3872:85;4017:67;;-1:-1:-1;;;4017:67:0;;4066:4;4017:67;;;13235:34:1;4073:10:0;13285:18:1;;;13278:43;2457:42:0;;4017:40;;13170:18:1;;4017:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:157;;;;-1:-1:-1;4113:61:0;;-1:-1:-1;;;4113:61:0;;4162:4;4113:61;;;13235:34:1;-1:-1:-1;;;;;13305:15:1;;13285:18;;;13278:43;2457:42:0;;4113:40;;13170:18:1;;4113:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3971:310;;4235:30;;-1:-1:-1;;;4235:30:0;;4254:10;4235:30;;;2228:51:1;2201:18;;4235:30:0;2082:203:1;3971:310:0;91704:47:::1;91727:4;91733:2;91737:7;91746:4;91704:22;:47::i;:::-;91567:190:::0;;;;;:::o;87307:182::-;61456:13;:11;:13::i;:::-;-1:-1:-1;;;;;87391:33:0;::::1;;::::0;;;:22:::1;:33;::::0;;;;:50;;87428:13;;87391:33;:50:::1;::::0;87428:13;;87391:50:::1;:::i;:::-;::::0;;;-1:-1:-1;87448:35:0::1;::::0;-1:-1:-1;87458:9:0;87469:13;87448:9:::1;:35::i;88285:502::-:0;88359:13;88389:17;88397:8;88389:7;:17::i;:::-;88381:77;;;;-1:-1:-1;;;88381:77:0;;16953:2:1;88381:77:0;;;16935:21:1;16992:2;16972:18;;;16965:30;17031:34;17011:18;;;17004:62;-1:-1:-1;;;17082:18:1;;;17075:45;17137:19;;88381:77:0;16751:411:1;88381:77:0;88471:8;;;;;;;:17;;88483:5;88471:17;88467:121;;88530:16;88548:19;:8;:17;:19::i;:::-;88569:9;88513:66;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;88499:81;;88285:502;;;:::o;88467:121::-;88596:28;88627:10;:8;:10::i;:::-;88596:41;;88682:1;88657:14;88651:28;:32;:130;;;;;;;;;;;;;;;;;88719:14;88735:19;:8;:17;:19::i;:::-;88756:9;88702:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;88651:130;88644:137;88285:502;-1:-1:-1;;;88285:502:0:o;84660:814::-;84735:13;82527:1;82511:13;:17;:58;;;;;82549:20;;82532:13;:37;;82511:58;82503:93;;;;-1:-1:-1;;;82503:93:0;;;;;;;:::i;:::-;82644:9;;82627:13;82611;42139:12;;41929:7;42123:13;:28;;41885:303;82611:13;:29;;;;:::i;:::-;:42;;82603:75;;;;-1:-1:-1;;;82603:75:0;;;;;;;:::i;:::-;82747:25;;82716:10;82693:34;;;;:22;:34;;;;;;:50;;82730:13;;82693:50;:::i;:::-;:79;;82685:134;;;;-1:-1:-1;;;82685:134:0;;;;;;;:::i;:::-;73952:21:::1;:19;:21::i;:::-;84779:11:::2;::::0;::::2;::::0;::::2;;;84778:12;84770:56;;;::::0;-1:-1:-1;;;84770:56:0;;19151:2:1;84770:56:0::2;::::0;::::2;19133:21:1::0;19190:2;19170:18;;;19163:30;19229:33;19209:18;;;19202:61;19280:18;;84770:56:0::2;18949:355:1::0;84770:56:0::2;84833:24;84864:29:::0;84945:9:::2;84958:1;84945:14:::0;84942:51:::2;;84980:13;84961:32;;84942:51;85003:9;:13:::0;85000:158:::2;;85066:17;::::0;85054:29:::2;::::0;:9:::2;:29;:::i;:::-;85029:54:::0;-1:-1:-1;85113:37:0::2;85029:54:::0;85113:13;:37:::2;:::i;:::-;85094:56;;85000:158;85166:39;85188:16;85166:21;:39::i;:::-;85253:21;85233:17;;:41;;;;:::i;:::-;85220:9;:54;;85212:86;;;;-1:-1:-1::0;;;85212:86:0::2;;;;;;;:::i;:::-;85330:10;85307:34;::::0;;;:22:::2;:34;::::0;;;;:51;;85345:13;;85307:34;:51:::2;::::0;85345:13;;85307:51:::2;:::i;:::-;::::0;;;-1:-1:-1;;85392:10:0::2;85365:38;::::0;;;:26:::2;:38;::::0;;;;:58;;85407:16;;85365:38;:58:::2;::::0;85407:16;;85365:58:::2;:::i;:::-;::::0;;;-1:-1:-1;85430:38:0::2;::::0;-1:-1:-1;22300:10:0;85454:13:::2;85430:9;:38::i;:::-;84763:711;;73996:20:::1;73390:1:::0;74516:7;:22;74333:213;89506:269;61456:13;:11;:13::i;:::-;89646:29:::1;:62:::0;;;;89715:25:::1;:54:::0;89506:269::o;86549:558::-;86663:13;82527:1;82511:13;:17;:58;;;;;82549:20;;82532:13;:37;;82511:58;82503:93;;;;-1:-1:-1;;;82503:93:0;;;;;;;:::i;:::-;82644:9;;82627:13;82611;42139:12;;41929:7;42123:13;:28;;41885:303;82611:13;:29;;;;:::i;:::-;:42;;82603:75;;;;-1:-1:-1;;;82603:75:0;;;;;;;:::i;:::-;82747:25;;82716:10;82693:34;;;;:22;:34;;;;;;:50;;82730:13;;82693:50;:::i;:::-;:79;;82685:134;;;;-1:-1:-1;;;82685:134:0;;;;;;;:::i;:::-;73952:21:::1;:19;:21::i;:::-;86707:15:::2;::::0;;;::::2;;;86706:16;86698:60;;;::::0;-1:-1:-1;;;86698:60:0;;19644:2:1;86698:60:0::2;::::0;::::2;19626:21:1::0;19683:2;19663:18;;;19656:30;19722:33;19702:18;;;19695:61;19773:18;;86698:60:0::2;19442:355:1::0;86698:60:0::2;86802:13;86786;;:29;;;;:::i;:::-;86773:9;:42;;86765:74;;;;-1:-1:-1::0;;;86765:74:0::2;;;;;;;:::i;:::-;86875:30;::::0;-1:-1:-1;;22300:10:0;19951:2:1;19947:15;19943:53;86875:30:0::2;::::0;::::2;19931:66:1::0;86848:14:0::2;::::0;20013:12:1;;86875:30:0::2;;;;;;;;;;;;86865:41;;;;;;86848:58;;86921:56;86940:14;;86921:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;86956:12:0::2;::::0;;-1:-1:-1;86970:6:0;;-1:-1:-1;86921:18:0::2;:56::i;:::-;86913:83;;;::::0;-1:-1:-1;;;86913:83:0;;20238:2:1;86913:83:0::2;::::0;::::2;20220:21:1::0;20277:2;20257:18;;;20250:30;-1:-1:-1;;;20296:18:1;;;20289:44;20350:18;;86913:83:0::2;20036:338:1::0;86913:83:0::2;87028:10;87005:34;::::0;;;:22:::2;:34;::::0;;;;:51;;87043:13;;87005:34;:51:::2;::::0;87043:13;;87005:51:::2;:::i;:::-;::::0;;;-1:-1:-1;87063:38:0::2;::::0;-1:-1:-1;22300:10:0;87087:13:::2;87063:9;:38::i;:::-;86691:416;73996:20:::1;73390:1:::0;74516:7;:22;74333:213;85480:1063;85598:13;82527:1;82511:13;:17;:58;;;;;82549:20;;82532:13;:37;;82511:58;82503:93;;;;-1:-1:-1;;;82503:93:0;;;;;;;:::i;:::-;82644:9;;82627:13;82611;42139:12;;41929:7;42123:13;:28;;41885:303;82611:13;:29;;;;:::i;:::-;:42;;82603:75;;;;-1:-1:-1;;;82603:75:0;;;;;;;:::i;:::-;82747:25;;82716:10;82693:34;;;;:22;:34;;;;;;:50;;82730:13;;82693:50;:::i;:::-;:79;;82685:134;;;;-1:-1:-1;;;82685:134:0;;;;;;;:::i;:::-;73952:21:::1;:19;:21::i;:::-;85642:13:::2;::::0;;;::::2;;;85641:14;85633:61;;;::::0;-1:-1:-1;;;85633:61:0;;20581:2:1;85633:61:0::2;::::0;::::2;20563:21:1::0;20620:2;20600:18;;;20593:30;20659:34;20639:18;;;20632:62;-1:-1:-1;;;20710:18:1;;;20703:32;20752:19;;85633:61:0::2;20379:398:1::0;85633:61:0::2;85701:24;85732:29:::0;85813:9:::2;85826:1;85813:14:::0;85810:51:::2;;85848:13;85829:32;;85810:51;85871:9;:13:::0;85868:158:::2;;85934:17;::::0;85922:29:::2;::::0;:9:::2;:29;:::i;:::-;85897:54:::0;-1:-1:-1;85981:37:0::2;85897:54:::0;85981:13;:37:::2;:::i;:::-;85962:56;;85868:158;86034:39;86056:16;86034:21;:39::i;:::-;86121:21;86101:17;;:41;;;;:::i;:::-;86088:9;:54;;86080:86;;;;-1:-1:-1::0;;;86080:86:0::2;;;;;;;:::i;:::-;86228:30;::::0;-1:-1:-1;;22300:10:0;19951:2:1;19947:15;19943:53;86228:30:0::2;::::0;::::2;19931:66:1::0;86195:20:0::2;::::0;20013:12:1;;86228:30:0::2;;;;;;;;;;;;86218:41;;;;;;86195:64;;86274:74;86293:20;;86274:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;86315:18:0::2;::::0;;-1:-1:-1;86335:12:0;;-1:-1:-1;86274:18:0::2;:74::i;:::-;86266:101;;;::::0;-1:-1:-1;;;86266:101:0;;20238:2:1;86266:101:0::2;::::0;::::2;20220:21:1::0;20277:2;20257:18;;;20250:30;-1:-1:-1;;;20296:18:1;;;20289:44;20350:18;;86266:101:0::2;20036:338:1::0;86266:101:0::2;86399:10;86376:34;::::0;;;:22:::2;:34;::::0;;;;:51;;86414:13;;86376:34;:51:::2;::::0;86414:13;;86376:51:::2;:::i;:::-;::::0;;;-1:-1:-1;;86461:10:0::2;86434:38;::::0;;;:26:::2;:38;::::0;;;;:58;;86476:16;;86434:38;:58:::2;::::0;86476:16;;86434:58:::2;:::i;:::-;::::0;;;-1:-1:-1;86499:38:0::2;::::0;-1:-1:-1;22300:10:0;86523:13:::2;86499:9;:38::i;:::-;85626:917;;;73996:20:::1;73390:1:::0;74516:7;:22;74333:213;88793:81;61456:13;:11;:13::i;:::-;88851:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;88851:17:0;;::::1;::::0;;;::::1;::::0;;88793:81::o;47886:164::-;-1:-1:-1;;;;;48007:25:0;;;47983:4;48007:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47886:164::o;80663:30::-;;;;;;;:::i;62476:201::-;61456:13;:11;:13::i;:::-;-1:-1:-1;;;;;62565:22:0;::::1;62557:73;;;::::0;-1:-1:-1;;;62557:73:0;;20984:2:1;62557:73:0::1;::::0;::::1;20966:21:1::0;21023:2;21003:18;;;20996:30;21062:34;21042:18;;;21035:62;-1:-1:-1;;;21113:18:1;;;21106:36;21159:19;;62557:73:0::1;20782:402:1::0;62557:73:0::1;62641:28;62660:8;62641:18;:28::i;:::-;62476:201:::0;:::o;89781:128::-;61456:13;:11;:13::i;:::-;89867:16:::1;:36;89886:17:::0;89867:16;:36:::1;:::i;90658:142::-:0;61456:13;:11;:13::i;:::-;90748:21:::1;:46:::0;90658:142::o;87495:784::-;87557:16;87582:23;87608:17;87618:6;87608:9;:17::i;:::-;87582:43;;87632:30;87679:15;-1:-1:-1;;;;;87665:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;87665:30:0;;87632:63;;87702:22;87735:23;87769:26;87804:441;87829:15;87811;:33;:64;;;;;87866:9;;87848:14;:27;;87811:64;87804:441;;;87886:31;87920:27;;;:11;:27;;;;;;;;;87886:61;;;;;;;;;-1:-1:-1;;;;;87886:61:0;;;;-1:-1:-1;;;87886:61:0;;-1:-1:-1;;;;;87886:61:0;;;;;;;;-1:-1:-1;;;87886:61:0;;;;;;;;;;;;;;;;87962:49;;-1:-1:-1;87983:14:0;;-1:-1:-1;;;;;87983:28:0;;;87962:49;87958:111;;;88045:14;;;-1:-1:-1;87958:111:0;88105:6;-1:-1:-1;;;;;88083:28:0;:18;-1:-1:-1;;;;;88083:28:0;;88079:132;;88157:14;88124:13;88138:15;88124:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;88184:17;;;;:::i;:::-;;;;88079:132;88221:16;;;;:::i;:::-;;;;87877:368;87804:441;;;-1:-1:-1;88260:13:0;;87495:784;-1:-1:-1;;;;;87495:784:0:o;76647:215::-;76749:4;-1:-1:-1;;;;;;76773:41:0;;-1:-1:-1;;;76773:41:0;;:81;;;76818:36;76842:11;76818:23;:36::i;61735:132::-;61643:6;;-1:-1:-1;;;;;61643:6:0;22300:10;61799:23;61791:68;;;;-1:-1:-1;;;61791:68:0;;21663:2:1;61791:68:0;;;21645:21:1;;;21682:18;;;21675:30;21741:34;21721:18;;;21714:62;21793:18;;61791:68:0;21461:356:1;78009:332:0;77725:5;-1:-1:-1;;;;;78112:33:0;;;;78104:88;;;;-1:-1:-1;;;78104:88:0;;22024:2:1;78104:88:0;;;22006:21:1;22063:2;22043:18;;;22036:30;22102:34;22082:18;;;22075:62;-1:-1:-1;;;22153:18:1;;;22146:40;22203:19;;78104:88:0;21822:406:1;78104:88:0;-1:-1:-1;;;;;78211:22:0;;78203:60;;;;-1:-1:-1;;;78203:60:0;;22435:2:1;78203:60:0;;;22417:21:1;22474:2;22454:18;;;22447:30;22513:27;22493:18;;;22486:55;22558:18;;78203:60:0;22233:349:1;78203:60:0;78298:35;;;;;;;;;-1:-1:-1;;;;;78298:35:0;;;;;;-1:-1:-1;;;;;78298:35:0;;;;;;;;;;-1:-1:-1;;;78276:57:0;;;;:19;:57;78009:332::o;49238:187::-;49295:4;49359:13;;49349:7;:23;49319:98;;;;-1:-1:-1;;49390:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;49390:27:0;;;;49389:28;;49238:187::o;57408:196::-;57523:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;57523:29:0;-1:-1:-1;;;;;57523:29:0;;;;;;;;;57568:28;;57523:24;;57568:28;;;;;;;57408:196;;;:::o;48117:170::-;48251:28;48261:4;48267:2;48271:7;48251:9;:28::i;74032:293::-;73434:1;74166:7;;:19;74158:63;;;;-1:-1:-1;;;74158:63:0;;22789:2:1;74158:63:0;;;22771:21:1;22828:2;22808:18;;;22801:30;22867:33;22847:18;;;22840:61;22918:18;;74158:63:0;22587:355:1;74158:63:0;73434:1;74299:7;:18;74032:293::o;48358:185::-;48496:39;48513:4;48519:2;48523:7;48496:39;;;;;;;;;;;;:16;:39::i;44386:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;44497:7:0;44580:13;;44573:4;:20;44542:886;;;44614:31;44648:17;;;:11;:17;;;;;;;;;44614:51;;;;;;;;;-1:-1:-1;;;;;44614:51:0;;;;-1:-1:-1;;;44614:51:0;;-1:-1:-1;;;;;44614:51:0;;;;;;;;-1:-1:-1;;;44614:51:0;;;;;;;;;;;;;;44684:729;;44734:14;;-1:-1:-1;;;;;44734:28:0;;44730:101;;44798:9;44386:1109;-1:-1:-1;;;44386:1109:0:o;44730:101::-;-1:-1:-1;;;45173:6:0;45218:17;;;;:11;:17;;;;;;;;;45206:29;;;;;;;;;-1:-1:-1;;;;;45206:29:0;;;;;-1:-1:-1;;;45206:29:0;;-1:-1:-1;;;;;45206:29:0;;;;;;;;-1:-1:-1;;;45206:29:0;;;;;;;;;;;;;45266:28;45262:109;;45334:9;44386:1109;-1:-1:-1;;;44386:1109:0:o;45262:109::-;45133:261;;;44595:833;44542:886;45456:31;;-1:-1:-1;;;45456:31:0;;;;;;;;;;;62837:191;62930:6;;;-1:-1:-1;;;;;62947:17:0;;;-1:-1:-1;;;;;;62947:17:0;;;;;;;62980:40;;62930:6;;;62947:17;62930:6;;62980:40;;62911:16;;62980:40;62900:128;62837:191;:::o;49433:104::-;49502:27;49512:2;49516:8;49502:27;;;;;;;;;;;;:9;:27::i;48614:369::-;48781:28;48791:4;48797:2;48801:7;48781:9;:28::i;:::-;-1:-1:-1;;;;;48824:13:0;;13698:19;:23;;48824:76;;;;;48844:56;48875:4;48881:2;48885:7;48894:5;48844:30;:56::i;:::-;48843:57;48824:76;48820:156;;;48924:40;;-1:-1:-1;;;48924:40:0;;;;;;;;;;;35625:716;35681:13;35732:14;35749:17;35760:5;35749:10;:17::i;:::-;35769:1;35749:21;35732:38;;35785:20;35819:6;-1:-1:-1;;;;;35808:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35808:18:0;-1:-1:-1;35785:41:0;-1:-1:-1;35950:28:0;;;35966:2;35950:28;36007:288;-1:-1:-1;;36039:5:0;-1:-1:-1;;;36176:2:0;36165:14;;36160:30;36039:5;36147:44;36237:2;36228:11;;;-1:-1:-1;36258:21:0;36007:288;36258:21;-1:-1:-1;36316:6:0;35625:716;-1:-1:-1;;;35625:716:0:o;90962:102::-;91022:13;91051:7;91044:14;;;;;:::i;82839:500::-;82920:21;;82917:417;;82977:21;;42139:12;;41929:7;42123:13;:28;82961:37;82953:83;;;;-1:-1:-1;;;82953:83:0;;23149:2:1;82953:83:0;;;23131:21:1;23188:2;23168:18;;;23161:30;23227:34;23207:18;;;23200:62;-1:-1:-1;;;23278:18:1;;;23271:31;23319:19;;82953:83:0;22947:397:1;82953:83:0;83076:24;;83055:17;:45;;83047:115;;;;-1:-1:-1;;;83047:115:0;;23551:2:1;83047:115:0;;;23533:21:1;23590:2;23570:18;;;23563:30;23629:34;23609:18;;;23602:62;23700:27;23680:18;;;23673:55;23745:19;;83047:115:0;23349:421:1;83047:115:0;83243:29;;83208:10;83181:38;;;;:26;:38;;;;;;:58;;83222:17;;83181:58;:::i;:::-;:91;;83173:153;;;;-1:-1:-1;;;83173:153:0;;23977:2:1;83173:153:0;;;23959:21:1;24016:2;23996:18;;;23989:30;24055:34;24035:18;;;24028:62;-1:-1:-1;;;24106:18:1;;;24099:47;24163:19;;83173:153:0;23775:413:1;64181:190:0;64306:4;64359;64330:25;64343:5;64350:4;64330:12;:25::i;:::-;:33;;64181:190;-1:-1:-1;;;;64181:190:0:o;42636:305::-;42738:4;-1:-1:-1;;;;;;42775:40:0;;-1:-1:-1;;;42775:40:0;;:105;;-1:-1:-1;;;;;;;42832:48:0;;-1:-1:-1;;;42832:48:0;42775:105;:158;;;-1:-1:-1;;;;;;;;;;38422:40:0;;;42897:36;38313:157;52351:2130;52466:35;52504:21;52517:7;52504:12;:21::i;:::-;52466:59;;52564:4;-1:-1:-1;;;;;52542:26:0;:13;:18;;;-1:-1:-1;;;;;52542:26:0;;52538:67;;52577:28;;-1:-1:-1;;;52577:28:0;;;;;;;;;;;52538:67;52618:22;22300:10;-1:-1:-1;;;;;52644:20:0;;;;:73;;-1:-1:-1;52681:36:0;52698:4;22300:10;47886:164;:::i;52681:36::-;52644:126;;;-1:-1:-1;22300:10:0;52734:20;52746:7;52734:11;:20::i;:::-;-1:-1:-1;;;;;52734:36:0;;52644:126;52618:153;;52789:17;52784:66;;52815:35;;-1:-1:-1;;;52815:35:0;;;;;;;;;;;52784:66;-1:-1:-1;;;;;52865:16:0;;52861:52;;52890:23;;-1:-1:-1;;;52890:23:0;;;;;;;;;;;52861:52;53034:35;53051:1;53055:7;53064:4;53034:8;:35::i;:::-;-1:-1:-1;;;;;53365:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;53365:31:0;;;-1:-1:-1;;;;;53365:31:0;;;-1:-1:-1;;53365:31:0;;;;;;;53411:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;53411:29:0;;;;;;;;;;;53491:20;;;:11;:20;;;;;;53526:18;;-1:-1:-1;;;;;;53559:49:0;;;;-1:-1:-1;;;53592:15:0;53559:49;;;;;;;;;;53882:11;;53942:24;;;;;53985:13;;53491:20;;53942:24;;53985:13;53981:384;;54195:13;;54180:11;:28;54176:174;;54233:20;;54302:28;;;;-1:-1:-1;;;;;54276:54:0;-1:-1:-1;;;54276:54:0;-1:-1:-1;;;;;;54276:54:0;;;-1:-1:-1;;;;;54233:20:0;;54276:54;;;;54176:174;53340:1036;;;54412:7;54408:2;-1:-1:-1;;;;;54393:27:0;54402:4;-1:-1:-1;;;;;54393:27:0;;;;;;;;;;;54431:42;91233:157;49900:163;50023:32;50029:2;50033:8;50043:5;50050:4;50023:5;:32::i;58096:667::-;58280:72;;-1:-1:-1;;;58280:72:0;;58259:4;;-1:-1:-1;;;;;58280:36:0;;;;;:72;;22300:10;;58331:4;;58337:7;;58346:5;;58280:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58280:72:0;;;;;;;;-1:-1:-1;;58280:72:0;;;;;;;;;;;;:::i;:::-;;;58276:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58514:6;:13;58531:1;58514:18;58510:235;;58560:40;;-1:-1:-1;;;58560:40:0;;;;;;;;;;;58510:235;58703:6;58697:13;58688:6;58684:2;58680:15;58673:38;58276:480;-1:-1:-1;;;;;;58399:55:0;-1:-1:-1;;;58399:55:0;;-1:-1:-1;58276:480:0;58096:667;;;;;;:::o;32647:922::-;32700:7;;-1:-1:-1;;;32778:15:0;;32774:102;;-1:-1:-1;;;32814:15:0;;;-1:-1:-1;32858:2:0;32848:12;32774:102;32903:6;32894:5;:15;32890:102;;32939:6;32930:15;;;-1:-1:-1;32974:2:0;32964:12;32890:102;33019:6;33010:5;:15;33006:102;;33055:6;33046:15;;;-1:-1:-1;33090:2:0;33080:12;33006:102;33135:5;33126;:14;33122:99;;33170:5;33161:14;;;-1:-1:-1;33204:1:0;33194:11;33122:99;33248:5;33239;:14;33235:99;;33283:5;33274:14;;;-1:-1:-1;33317:1:0;33307:11;33235:99;33361:5;33352;:14;33348:99;;33396:5;33387:14;;;-1:-1:-1;33430:1:0;33420:11;33348:99;33474:5;33465;:14;33461:66;;33510:1;33500:11;33555:6;32647:922;-1:-1:-1;;32647:922:0:o;65048:296::-;65131:7;65174:4;65131:7;65189:118;65213:5;:12;65209:1;:16;65189:118;;;65262:33;65272:12;65286:5;65292:1;65286:8;;;;;;;;:::i;:::-;;;;;;;65262:9;:33::i;:::-;65247:48;-1:-1:-1;65227:3:0;;;;:::i;:::-;;;;65189:118;;;-1:-1:-1;65324:12:0;65048:296;-1:-1:-1;;;65048:296:0:o;50322:1775::-;50461:20;50484:13;-1:-1:-1;;;;;50512:16:0;;50508:48;;50537:19;;-1:-1:-1;;;50537:19:0;;;;;;;;;;;50508:48;50571:8;50583:1;50571:13;50567:44;;50593:18;;-1:-1:-1;;;50593:18:0;;;;;;;;;;;50567:44;-1:-1:-1;;;;;50962:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;51021:49:0;;-1:-1:-1;;;;;50962:44:0;;;;;;;51021:49;;;;-1:-1:-1;;50962:44:0;;;;;;51021:49;;;;;;;;;;;;;;;;51087:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;51137:66:0;;;;-1:-1:-1;;;51187:15:0;51137:66;;;;;;;;;;51087:25;51284:23;;;51328:4;:23;;;;-1:-1:-1;;;;;;51336:13:0;;13698:19;:23;;51336:15;51324:641;;;51372:314;51403:38;;51428:12;;-1:-1:-1;;;;;51403:38:0;;;51420:1;;51403:38;;51420:1;;51403:38;51469:69;51508:1;51512:2;51516:14;;;;;;51532:5;51469:30;:69::i;:::-;51464:174;;51574:40;;-1:-1:-1;;;51574:40:0;;;;;;;;;;;51464:174;51681:3;51665:12;:19;51372:314;;51767:12;51750:13;;:29;51746:43;;51781:8;;;51746:43;51324:641;;;51830:120;51861:40;;51886:14;;;;;-1:-1:-1;;;;;51861:40:0;;;51878:1;;51861:40;;51878:1;;51861:40;51945:3;51929:12;:19;51830:120;;51324:641;-1:-1:-1;51979:13:0;:28;52029:60;91233:157;71255:149;71318:7;71349:1;71345;:5;:51;;71480:13;71574:15;;;71610:4;71603:15;;;71657:4;71641:21;;71345:51;;;-1:-1:-1;71480:13:0;71574:15;;;71610:4;71603:15;71657:4;71641:21;;;71255:149::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:250::-;1226:1;1236:113;1250:6;1247:1;1244:13;1236:113;;;1326:11;;;1320:18;1307:11;;;1300:39;1272:2;1265:10;1236:113;;;-1:-1:-1;;1383:1:1;1365:16;;1358:27;1141:250::o;1396:271::-;1438:3;1476:5;1470:12;1503:6;1498:3;1491:19;1519:76;1588:6;1581:4;1576:3;1572:14;1565:4;1558:5;1554:16;1519:76;:::i;:::-;1649:2;1628:15;-1:-1:-1;;1624:29:1;1615:39;;;;1656:4;1611:50;;1396:271;-1:-1:-1;;1396:271:1:o;1672:220::-;1821:2;1810:9;1803:21;1784:4;1841:45;1882:2;1871:9;1867:18;1859:6;1841:45;:::i;1897:180::-;1956:6;2009:2;1997:9;1988:7;1984:23;1980:32;1977:52;;;2025:1;2022;2015:12;1977:52;-1:-1:-1;2048:23:1;;1897:180;-1:-1:-1;1897:180:1:o;2290:254::-;2358:6;2366;2419:2;2407:9;2398:7;2394:23;2390:32;2387:52;;;2435:1;2432;2425:12;2387:52;2458:29;2477:9;2458:29;:::i;:::-;2448:39;2534:2;2519:18;;;;2506:32;;-1:-1:-1;;;2290:254:1:o;2549:127::-;2610:10;2605:3;2601:20;2598:1;2591:31;2641:4;2638:1;2631:15;2665:4;2662:1;2655:15;2681:632;2746:5;-1:-1:-1;;;;;2817:2:1;2809:6;2806:14;2803:40;;;2823:18;;:::i;:::-;2898:2;2892:9;2866:2;2952:15;;-1:-1:-1;;2948:24:1;;;2974:2;2944:33;2940:42;2928:55;;;2998:18;;;3018:22;;;2995:46;2992:72;;;3044:18;;:::i;:::-;3084:10;3080:2;3073:22;3113:6;3104:15;;3143:6;3135;3128:22;3183:3;3174:6;3169:3;3165:16;3162:25;3159:45;;;3200:1;3197;3190:12;3159:45;3250:6;3245:3;3238:4;3230:6;3226:17;3213:44;3305:1;3298:4;3289:6;3281;3277:19;3273:30;3266:41;;;;2681:632;;;;;:::o;3318:451::-;3387:6;3440:2;3428:9;3419:7;3415:23;3411:32;3408:52;;;3456:1;3453;3446:12;3408:52;3496:9;3483:23;-1:-1:-1;;;;;3521:6:1;3518:30;3515:50;;;3561:1;3558;3551:12;3515:50;3584:22;;3637:4;3629:13;;3625:27;-1:-1:-1;3615:55:1;;3666:1;3663;3656:12;3615:55;3689:74;3755:7;3750:2;3737:16;3732:2;3728;3724:11;3689:74;:::i;4138:328::-;4215:6;4223;4231;4284:2;4272:9;4263:7;4259:23;4255:32;4252:52;;;4300:1;4297;4290:12;4252:52;4323:29;4342:9;4323:29;:::i;:::-;4313:39;;4371:38;4405:2;4394:9;4390:18;4371:38;:::i;:::-;4361:48;;4456:2;4445:9;4441:18;4428:32;4418:42;;4138:328;;;;;:::o;4471:248::-;4539:6;4547;4600:2;4588:9;4579:7;4575:23;4571:32;4568:52;;;4616:1;4613;4606:12;4568:52;-1:-1:-1;;4639:23:1;;;4709:2;4694:18;;;4681:32;;-1:-1:-1;4471:248:1:o;5003:118::-;5089:5;5082:13;5075:21;5068:5;5065:32;5055:60;;5111:1;5108;5101:12;5126:647;5200:6;5208;5216;5224;5277:3;5265:9;5256:7;5252:23;5248:33;5245:53;;;5294:1;5291;5284:12;5245:53;5333:9;5320:23;5352:28;5374:5;5352:28;:::i;:::-;5399:5;-1:-1:-1;5456:2:1;5441:18;;5428:32;5469:30;5428:32;5469:30;:::i;:::-;5518:7;-1:-1:-1;5577:2:1;5562:18;;5549:32;5590:30;5549:32;5590:30;:::i;:::-;5639:7;-1:-1:-1;5698:2:1;5683:18;;5670:32;5711:30;5670:32;5711:30;:::i;:::-;5126:647;;;;-1:-1:-1;5126:647:1;;-1:-1:-1;;5126:647:1:o;5778:186::-;5837:6;5890:2;5878:9;5869:7;5865:23;5861:32;5858:52;;;5906:1;5903;5896:12;5858:52;5929:29;5948:9;5929:29;:::i;6222:316::-;6299:6;6307;6315;6368:2;6356:9;6347:7;6343:23;6339:32;6336:52;;;6384:1;6381;6374:12;6336:52;-1:-1:-1;;6407:23:1;;;6477:2;6462:18;;6449:32;;-1:-1:-1;6528:2:1;6513:18;;;6500:32;;6222:316;-1:-1:-1;6222:316:1:o;6543:799::-;6683:6;6691;6699;6707;6715;6723;6731;6739;6747;6755;6808:3;6796:9;6787:7;6783:23;6779:33;6776:53;;;6825:1;6822;6815:12;6776:53;-1:-1:-1;;6848:23:1;;;6918:2;6903:18;;6890:32;;-1:-1:-1;6969:2:1;6954:18;;6941:32;;7020:2;7005:18;;6992:32;;-1:-1:-1;7071:3:1;7056:19;;7043:33;;-1:-1:-1;7123:3:1;7108:19;;7095:33;;-1:-1:-1;7175:3:1;7160:19;;7147:33;;-1:-1:-1;7227:3:1;7212:19;;7199:33;;-1:-1:-1;7279:3:1;7264:19;;7251:33;;-1:-1:-1;7331:3:1;7316:19;7303:33;;-1:-1:-1;6543:799:1;-1:-1:-1;6543:799:1:o;7347:315::-;7412:6;7420;7473:2;7461:9;7452:7;7448:23;7444:32;7441:52;;;7489:1;7486;7479:12;7441:52;7512:29;7531:9;7512:29;:::i;:::-;7502:39;;7591:2;7580:9;7576:18;7563:32;7604:28;7626:5;7604:28;:::i;7667:667::-;7762:6;7770;7778;7786;7839:3;7827:9;7818:7;7814:23;7810:33;7807:53;;;7856:1;7853;7846:12;7807:53;7879:29;7898:9;7879:29;:::i;:::-;7869:39;;7927:38;7961:2;7950:9;7946:18;7927:38;:::i;:::-;7917:48;;8012:2;8001:9;7997:18;7984:32;7974:42;;8067:2;8056:9;8052:18;8039:32;-1:-1:-1;;;;;8086:6:1;8083:30;8080:50;;;8126:1;8123;8116:12;8080:50;8149:22;;8202:4;8194:13;;8190:27;-1:-1:-1;8180:55:1;;8231:1;8228;8221:12;8180:55;8254:74;8320:7;8315:2;8302:16;8297:2;8293;8289:11;8254:74;:::i;:::-;8244:84;;;7667:667;;;;;;;:::o;8339:254::-;8407:6;8415;8468:2;8456:9;8447:7;8443:23;8439:32;8436:52;;;8484:1;8481;8474:12;8436:52;8520:9;8507:23;8497:33;;8549:38;8583:2;8572:9;8568:18;8549:38;:::i;:::-;8539:48;;8339:254;;;;;:::o;8598:683::-;8693:6;8701;8709;8762:2;8750:9;8741:7;8737:23;8733:32;8730:52;;;8778:1;8775;8768:12;8730:52;8814:9;8801:23;8791:33;;8875:2;8864:9;8860:18;8847:32;-1:-1:-1;;;;;8939:2:1;8931:6;8928:14;8925:34;;;8955:1;8952;8945:12;8925:34;8993:6;8982:9;8978:22;8968:32;;9038:7;9031:4;9027:2;9023:13;9019:27;9009:55;;9060:1;9057;9050:12;9009:55;9100:2;9087:16;9126:2;9118:6;9115:14;9112:34;;;9142:1;9139;9132:12;9112:34;9195:7;9190:2;9180:6;9177:1;9173:14;9169:2;9165:23;9161:32;9158:45;9155:65;;;9216:1;9213;9206:12;9155:65;9247:2;9243;9239:11;9229:21;;9269:6;9259:16;;;;;8598:683;;;;;:::o;9286:241::-;9342:6;9395:2;9383:9;9374:7;9370:23;9366:32;9363:52;;;9411:1;9408;9401:12;9363:52;9450:9;9437:23;9469:28;9491:5;9469:28;:::i;9532:260::-;9600:6;9608;9661:2;9649:9;9640:7;9636:23;9632:32;9629:52;;;9677:1;9674;9667:12;9629:52;9700:29;9719:9;9700:29;:::i;:::-;9690:39;;9748:38;9782:2;9771:9;9767:18;9748:38;:::i;9797:632::-;9968:2;10020:21;;;10090:13;;9993:18;;;10112:22;;;9939:4;;9968:2;10191:15;;;;10165:2;10150:18;;;9939:4;10234:169;10248:6;10245:1;10242:13;10234:169;;;10309:13;;10297:26;;10378:15;;;;10343:12;;;;10270:1;10263:9;10234:169;;;-1:-1:-1;10420:3:1;;9797:632;-1:-1:-1;;;;;;9797:632:1:o;10434:380::-;10513:1;10509:12;;;;10556;;;10577:61;;10631:4;10623:6;10619:17;10609:27;;10577:61;10684:2;10676:6;10673:14;10653:18;10650:38;10647:161;;10730:10;10725:3;10721:20;10718:1;10711:31;10765:4;10762:1;10755:15;10793:4;10790:1;10783:15;10647:161;;10434:380;;;:::o;10945:545::-;11047:2;11042:3;11039:11;11036:448;;;11083:1;11108:5;11104:2;11097:17;11153:4;11149:2;11139:19;11223:2;11211:10;11207:19;11204:1;11200:27;11194:4;11190:38;11259:4;11247:10;11244:20;11241:47;;;-1:-1:-1;11282:4:1;11241:47;11337:2;11332:3;11328:12;11325:1;11321:20;11315:4;11311:31;11301:41;;11392:82;11410:2;11403:5;11400:13;11392:82;;;11455:17;;;11436:1;11425:13;11392:82;;;11396:3;;;10945:545;;;:::o;11666:1352::-;11792:3;11786:10;-1:-1:-1;;;;;11811:6:1;11808:30;11805:56;;;11841:18;;:::i;:::-;11870:97;11960:6;11920:38;11952:4;11946:11;11920:38;:::i;:::-;11914:4;11870:97;:::i;:::-;12022:4;;12086:2;12075:14;;12103:1;12098:663;;;;12805:1;12822:6;12819:89;;;-1:-1:-1;12874:19:1;;;12868:26;12819:89;-1:-1:-1;;11623:1:1;11619:11;;;11615:24;11611:29;11601:40;11647:1;11643:11;;;11598:57;12921:81;;12068:944;;12098:663;10892:1;10885:14;;;10929:4;10916:18;;-1:-1:-1;;12134:20:1;;;12252:236;12266:7;12263:1;12260:14;12252:236;;;12355:19;;;12349:26;12334:42;;12447:27;;;;12415:1;12403:14;;;;12282:19;;12252:236;;;12256:3;12516:6;12507:7;12504:19;12501:201;;;12577:19;;;12571:26;-1:-1:-1;;12660:1:1;12656:14;;;12672:3;12652:24;12648:37;12644:42;12629:58;12614:74;;12501:201;-1:-1:-1;;;;;12748:1:1;12732:14;;;12728:22;12715:36;;-1:-1:-1;11666:1352:1:o;13332:245::-;13399:6;13452:2;13440:9;13431:7;13427:23;13423:32;13420:52;;;13468:1;13465;13458:12;13420:52;13500:9;13494:16;13519:28;13541:5;13519:28;:::i;13582:127::-;13643:10;13638:3;13634:20;13631:1;13624:31;13674:4;13671:1;13664:15;13698:4;13695:1;13688:15;13714:168;13787:9;;;13818;;13835:15;;;13829:22;;13815:37;13805:71;;13856:18;;:::i;14019:217::-;14059:1;14085;14075:132;;14129:10;14124:3;14120:20;14117:1;14110:31;14164:4;14161:1;14154:15;14192:4;14189:1;14182:15;14075:132;-1:-1:-1;14221:9:1;;14019:217::o;14803:346::-;15005:2;14987:21;;;15044:2;15024:18;;;15017:30;-1:-1:-1;;;15078:2:1;15063:18;;15056:52;15140:2;15125:18;;14803:346::o;15154:125::-;15219:9;;;15240:10;;;15237:36;;;15253:18;;:::i;15284:344::-;15486:2;15468:21;;;15525:2;15505:18;;;15498:30;-1:-1:-1;;;15559:2:1;15544:18;;15537:50;15619:2;15604:18;;15284:344::o;15633:406::-;15835:2;15817:21;;;15874:2;15854:18;;;15847:30;15913:34;15908:2;15893:18;;15886:62;-1:-1:-1;;;15979:2:1;15964:18;;15957:40;16029:3;16014:19;;15633:406::o;16044:354::-;16246:2;16228:21;;;16285:2;16265:18;;;16258:30;16324:32;16319:2;16304:18;;16297:60;16389:2;16374:18;;16044:354::o;16403:343::-;16605:2;16587:21;;;16644:2;16624:18;;;16617:30;-1:-1:-1;;;16678:2:1;16663:18;;16656:49;16737:2;16722:18;;16403:343::o;17167:722::-;17217:3;17258:5;17252:12;17287:36;17313:9;17287:36;:::i;:::-;17342:1;17359:18;;;17386:133;;;;17533:1;17528:355;;;;17352:531;;17386:133;-1:-1:-1;;17419:24:1;;17407:37;;17492:14;;17485:22;17473:35;;17464:45;;;-1:-1:-1;17386:133:1;;17528:355;17559:5;17556:1;17549:16;17588:4;17633:2;17630:1;17620:16;17658:1;17672:165;17686:6;17683:1;17680:13;17672:165;;;17764:14;;17751:11;;;17744:35;17807:16;;;;17701:10;;17672:165;;;17676:3;;;17866:6;17861:3;17857:16;17850:23;;17352:531;;;;;17167:722;;;;:::o;17894:469::-;18115:3;18143:38;18177:3;18169:6;18143:38;:::i;:::-;18210:6;18204:13;18226:65;18284:6;18280:2;18273:4;18265:6;18261:17;18226:65;:::i;:::-;18307:50;18349:6;18345:2;18341:15;18333:6;18307:50;:::i;:::-;18300:57;17894:469;-1:-1:-1;;;;;;;17894:469:1:o;18368:576::-;18592:3;18630:6;18624:13;18646:66;18705:6;18700:3;18693:4;18685:6;18681:17;18646:66;:::i;:::-;18775:13;;18734:16;;;;18797:70;18775:13;18734:16;18844:4;18832:17;;18797:70;:::i;19309:128::-;19376:9;;;19397:11;;;19394:37;;;19411:18;;:::i;21189:127::-;21250:10;21245:3;21241:20;21238:1;21231:31;21281:4;21278:1;21271:15;21305:4;21302:1;21295:15;21321:135;21360:3;21381:17;;;21378:43;;21401:18;;:::i;:::-;-1:-1:-1;21448:1:1;21437:13;;21321:135::o;24193:489::-;-1:-1:-1;;;;;24462:15:1;;;24444:34;;24514:15;;24509:2;24494:18;;24487:43;24561:2;24546:18;;24539:34;;;24609:3;24604:2;24589:18;;24582:31;;;24387:4;;24630:46;;24656:19;;24648:6;24630:46;:::i;:::-;24622:54;24193:489;-1:-1:-1;;;;;;24193:489:1:o;24687:249::-;24756:6;24809:2;24797:9;24788:7;24784:23;24780:32;24777:52;;;24825:1;24822;24815:12;24777:52;24857:9;24851:16;24876:30;24900:5;24876:30;:::i

Swarm Source

ipfs://f52b93ed3c91d56a9854344578096eb4342413f41417f8a1a06b0fc2bdd16ba1

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