Failed Goonz (FG) Token Tracker

Failed Goonz (FG)

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

Overview

TokenID

5316

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract

0x24e94f7558fc8bee554112506a091b5d7bf985bf

TokenID: 5316

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AnotherFailedProject

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, Unlicense license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-12-14
*/

// SPDX-License-Identifier: UNLICENSED

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: contracts/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;


interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external 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/OperatorFilterer.sol


pragma solidity ^0.8.13;


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() virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (!operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }
}
// File: contracts/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


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

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: underdogenft.sol



// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


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

pragma solidity ^0.8.0;


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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

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

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

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

// File: @openzeppelin/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Context.sol


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

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

// File: erc721a/contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;








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 {}
}

// File: contracts/TutorialErc721A.sol





pragma solidity >=0.8.9 <0.9.0;







contract AnotherFailedProject is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {



  using Strings for uint256;



  bytes32 public merkleRoot;

//   mapping(address => bool) public whitelistClaimed;
  mapping(address => uint256) public whitelistClaimed;



  string public uriPrefix = '';

  string public uriSuffix = '.json';

  string public HiddenMetadataUri;

  

  uint256 public Cost;

  uint256 public MaxSupply;

  uint256 public MaxMintAmountPerTx;

  uint256 public MaxPerWallet;



  bool public paused = true;

  bool public whitelistMintEnabled = false;

  bool public revealed = false;



  constructor(

    string memory _tokenName,

    string memory _tokenSymbol,

    uint256 _Cost,

    uint256 _MaxSupply,

    uint256 _MaxMintAmountPerTx,

    uint256 _MaxPerWallet,

    string memory _HiddenMetadataUri

  ) ERC721A(_tokenName, _tokenSymbol) {

    setCost(_Cost);

    setMaxSupply(_MaxSupply);

    setMaxMintAmountPerTx(_MaxMintAmountPerTx);

    setMaxPerWallet(_MaxPerWallet);

    setHiddenMetadataUri(_HiddenMetadataUri);

  }



  modifier mintCompliance(uint256 _mintAmount) {

    require(_mintAmount > 0 && _mintAmount <= MaxMintAmountPerTx, 'Invalid mint amount!');

    require(totalSupply() + _mintAmount <= MaxSupply, 'Max supply exceeded!');

    require(balanceOf(msg.sender) + _mintAmount <= MaxPerWallet, 'Per Wallet Limit Reached');

    _;

  }



  modifier mintPriceCompliance(uint256 _mintAmount) {

    require(msg.value >= Cost * _mintAmount, 'Insufficient funds!');

    _;

  }



  function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {

    // Verify whitelist requirements

    uint256 WLClaimed = whitelistClaimed[_msgSender()];

    require(whitelistMintEnabled, 'The whitelist sale is not enabled!');

    require(WLClaimed + _mintAmount <= MaxMintAmountPerTx, 'Address already claimed!');

    bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));

    require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), 'Invalid proof!');

    require(msg.value >= Cost * _mintAmount, 'Insufficient funds!');



    whitelistClaimed[_msgSender()] += _mintAmount;

    _safeMint(_msgSender(), _mintAmount);

  }



  function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {

    require(!paused, 'The contract is paused!');



    _safeMint(_msgSender(), _mintAmount);

  }

  

  function ownerMint(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {

    _safeMint(_receiver, _mintAmount);

  }



  function walletOfOwner(address _owner) public view returns (uint256[] memory) {

    uint256 ownerTokenCount = balanceOf(_owner);

    uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);

    uint256 currentTokenId = _startTokenId();

    uint256 ownedTokenIndex = 0;

    address latestOwnerAddress;



    while (ownedTokenIndex < ownerTokenCount && currentTokenId < _currentIndex) {

      TokenOwnership memory ownership = _ownerships[currentTokenId];



      if (!ownership.burned) {

        if (ownership.addr != address(0)) {

          latestOwnerAddress = ownership.addr;

        }



        if (latestOwnerAddress == _owner) {

          ownedTokenIds[ownedTokenIndex] = currentTokenId;



          ownedTokenIndex++;

        }

      }



      currentTokenId++;

    }



    return ownedTokenIds;

  }



  function _startTokenId() internal view virtual override returns (uint256) {

    return 1;

  }



  function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {

    require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');



    if (revealed == false) {

      return HiddenMetadataUri;

    }



    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 setCost(uint256 _Cost) public onlyOwner {

    Cost = _Cost;

  }



  function setMaxSupply(uint256 _MaxSupply) public onlyOwner {

      MaxSupply = _MaxSupply;
  
  }



  function setMaxMintAmountPerTx(uint256 _MaxMintAmountPerTx) public onlyOwner {

    MaxMintAmountPerTx = _MaxMintAmountPerTx;

  }



  function setMaxPerWallet(uint256 _MaxPerWallet) public onlyOwner {       

        MaxPerWallet = _MaxPerWallet;

  }



  function setHiddenMetadataUri(string memory _HiddenMetadataUri) public onlyOwner {

    HiddenMetadataUri = _HiddenMetadataUri;

  }



  function setUriPrefix(string memory _uriPrefix) public onlyOwner {

    uriPrefix = _uriPrefix;

  }



  function setUriSuffix(string memory _uriSuffix) public onlyOwner {

    uriSuffix = _uriSuffix;

  }



  function setPaused(bool _state) public onlyOwner {

    paused = _state;

  }



  function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {

    merkleRoot = _merkleRoot;

  }



  function setWhitelistMintEnabled(bool _state) public onlyOwner {

    whitelistMintEnabled = _state;

  }



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

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

  
  
  function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override
        onlyAllowedOperator

  {

        super.safeTransferFrom(from, to, tokenId, data);

  } 



  function withdrawAll() external payable onlyOwner nonReentrant {
        uint256 balance = address(this).balance;
        uint256 balanceOne = balance * 3 / 100;
        ( bool transferOne, ) = payable(0x34Aa4853C3635421BC99068D0e68Ad9a201Ef029).call{value: balanceOne}(""); // 3% Donation to The Bee Collab #SaveTheBeesWithNFTs
        (bool remaining, ) = payable(owner()).call{value: address(this).balance}('');
        require(transferOne && remaining, "Transfer failed.");

    }



  function _baseURI() internal view virtual override returns (string memory) {

    return uriPrefix;

  }

}

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":"_Cost","type":"uint256"},{"internalType":"uint256","name":"_MaxSupply","type":"uint256"},{"internalType":"uint256","name":"_MaxMintAmountPerTx","type":"uint256"},{"internalType":"uint256","name":"_MaxPerWallet","type":"uint256"},{"internalType":"string","name":"_HiddenMetadataUri","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":[],"name":"Cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HiddenMetadataUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxMintAmountPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_Cost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_HiddenMetadataUri","type":"string"}],"name":"setHiddenMetadataUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_MaxMintAmountPerTx","type":"uint256"}],"name":"setMaxMintAmountPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_MaxPerWallet","type":"uint256"}],"name":"setMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_MaxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriPrefix","type":"string"}],"name":"setUriPrefix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriSuffix","type":"string"}],"name":"setUriSuffix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setWhitelistMintEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uriPrefix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uriSuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"whitelistMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029a000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000c4661696c656420476f6f6e7a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024647000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005768747470733a2f2f746865626565636f6c6c61622e6d7970696e6174612e636c6f75642f697066732f516d524c466931784c41344c5a5a47555a7939677a414d473175323547573435467372733654693468554d794d45000000000000000000

-----Decoded View---------------
Arg [0] : _tokenName (string): Failed Goonz
Arg [1] : _tokenSymbol (string): FG
Arg [2] : _Cost (uint256): 0
Arg [3] : _MaxSupply (uint256): 666
Arg [4] : _MaxMintAmountPerTx (uint256): 6
Arg [5] : _MaxPerWallet (uint256): 6
Arg [6] : _HiddenMetadataUri (string): https://thebeecollab.mypinata.cloud/ipfs/QmRLFi1xLA4LZZGUZy9gzAMG1u25GW45Fsrs6Ti4hUMyME

-----Encoded View---------------
15 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 000000000000000000000000000000000000000000000000000000000000029a
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [8] : 4661696c656420476f6f6e7a0000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [10] : 4647000000000000000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000057
Arg [12] : 68747470733a2f2f746865626565636f6c6c61622e6d7970696e6174612e636c
Arg [13] : 6f75642f697066732f516d524c466931784c41344c5a5a47555a7939677a414d
Arg [14] : 473175323547573435467372733654693468554d794d45000000000000000000

Deployed Bytecode Sourcemap

67481:6759:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49639:305;;;;;;;;;;-1:-1:-1;49639:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;49639:305:0;;;;;;;;52752:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54255:204::-;;;;;;;;;;-1:-1:-1;54255:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;54255:204:0;1533:203:1;53818:371:0;;;;;;;;;;-1:-1:-1;53818:371:0;;;;;:::i;:::-;;:::i;:::-;;67946:33;;;;;;;;;;;;;;;;;;;2324:25:1;;;2312:2;2297:18;67946:33:0;2178:177:1;72598:104:0;;;;;;;;;;-1:-1:-1;72598:104:0;;;;;:::i;:::-;;:::i;72712:81::-;;;;;;;;;;-1:-1:-1;72712:81:0;;;;;:::i;:::-;;:::i;48888:303::-;;;;;;;;;;;;71272:1;49142:12;48932:7;49126:13;:28;-1:-1:-1;;49126:46:0;;48888:303;73034:158;;;;;;;;;;-1:-1:-1;73034:158:0;;;;;:::i;:::-;;:::i;67620:25::-;;;;;;;;;;;;;;;;73204:173;;;;;;;;;;-1:-1:-1;73204:173:0;;;;;:::i;:::-;;:::i;70287:885::-;;;;;;;;;;-1:-1:-1;70287:885:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;71863:78::-;;;;;;;;;;-1:-1:-1;71863:78:0;;;;;:::i;:::-;;:::i;67845:31::-;;;;;;;;;;;;;:::i;72338:136::-;;;;;;;;;;-1:-1:-1;72338:136:0;;;;;:::i;:::-;;:::i;68103:28::-;;;;;;;;;;-1:-1:-1;68103:28:0;;;;;;;;;;;67805:33;;;;;;;;;;;;;:::i;68024:25::-;;;;;;;;;;-1:-1:-1;68024:25:0;;;;;;;;67770:28;;;;;;;;;;;;;:::i;52560:125::-;;;;;;;;;;-1:-1:-1;52560:125:0;;;;;:::i;:::-;;:::i;68056:40::-;;;;;;;;;;-1:-1:-1;68056:40:0;;;;;;;;;;;71951:102;;;;;;;;;;-1:-1:-1;71951:102:0;;;;;:::i;:::-;;:::i;50008:206::-;;;;;;;;;;-1:-1:-1;50008:206:0;;;;;:::i;:::-;;:::i;27397:103::-;;;;;;;;;;;;;:::i;72803:102::-;;;;;;;;;;-1:-1:-1;72803:102:0;;;;;:::i;:::-;;:::i;72484:104::-;;;;;;;;;;-1:-1:-1;72484:104:0;;;;;:::i;:::-;;:::i;73626:491::-;;;:::i;67986:27::-;;;;;;;;;;;;;;;;26746:87;;;;;;;;;;-1:-1:-1;26819:6:0;;-1:-1:-1;;;;;26819:6:0;26746:87;;52921:104;;;;;;;;;;;;;:::i;69891:220::-;;;;;;:::i;:::-;;:::i;54531:287::-;;;;;;;;;;-1:-1:-1;54531:287:0;;;;;:::i;:::-;;:::i;72063:134::-;;;;;;;;;;-1:-1:-1;72063:134:0;;;;;:::i;:::-;;:::i;67915:24::-;;;;;;;;;;;;;;;;72915:109;;;;;;;;;;-1:-1:-1;72915:109:0;;;;;:::i;:::-;;:::i;73391:224::-;;;;;;;;;;-1:-1:-1;73391:224:0;;;;;:::i;:::-;;:::i;71291:467::-;;;;;;;;;;-1:-1:-1;71291:467:0;;;;;:::i;:::-;;:::i;69128:753::-;;;;;;:::i;:::-;;:::i;70123:154::-;;;;;;;;;;-1:-1:-1;70123:154:0;;;;;:::i;:::-;;:::i;67708:51::-;;;;;;;;;;-1:-1:-1;67708:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;71768:85;;;;;;;;;;-1:-1:-1;71768:85:0;;;;;:::i;:::-;;:::i;72207:121::-;;;;;;;;;;-1:-1:-1;72207:121:0;;;;;:::i;:::-;;:::i;54889:164::-;;;;;;;;;;-1:-1:-1;54889:164:0;;;;;:::i;:::-;;:::i;27655:201::-;;;;;;;;;;-1:-1:-1;27655:201:0;;;;;:::i;:::-;;:::i;67889:19::-;;;;;;;;;;;;;;;;49639:305;49741:4;-1:-1:-1;;;;;;49778:40:0;;-1:-1:-1;;;49778:40:0;;:105;;-1:-1:-1;;;;;;;49835:48:0;;-1:-1:-1;;;49835:48:0;49778:105;:158;;;-1:-1:-1;;;;;;;;;;39639:40:0;;;49900:36;49758:178;49639:305;-1:-1:-1;;49639:305:0:o;52752:100::-;52806:13;52839:5;52832:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52752:100;:::o;54255:204::-;54323:7;54348:16;54356:7;54348;:16::i;:::-;54343:64;;54373:34;;-1:-1:-1;;;54373:34:0;;;;;;;;;;;54343:64;-1:-1:-1;54427:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54427:24:0;;54255:204::o;53818:371::-;53891:13;53907:24;53923:7;53907:15;:24::i;:::-;53891:40;;53952:5;-1:-1:-1;;;;;53946:11:0;:2;-1:-1:-1;;;;;53946:11:0;;53942:48;;53966:24;;-1:-1:-1;;;53966:24:0;;;;;;;;;;;53942:48;25550:10;-1:-1:-1;;;;;54007:21:0;;;;;;:63;;-1:-1:-1;54033:37:0;54050:5;25550:10;54889:164;:::i;54033:37::-;54032:38;54007:63;54003:138;;;54094:35;;-1:-1:-1;;;54094:35:0;;;;;;;;;;;54003:138;54153:28;54162:2;54166:7;54175:5;54153:8;:28::i;:::-;53880:309;53818:371;;:::o;72598:104::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;;;;;;;;;72672:9:::1;:22;72684:10:::0;72672:9;:22:::1;:::i;:::-;;72598:104:::0;:::o;72712:81::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72770:6:::1;:15:::0;;-1:-1:-1;;72770:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;72712:81::o;73034:158::-;15803:42;16931:43;:47;16927:225;;17000:67;;-1:-1:-1;;;17000:67:0;;17049:4;17000:67;;;10848:34:1;17056:10:0;10898:18:1;;;10891:43;15803:42:0;;17000:40;;10783:18:1;;17000:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16995:146;;17095:30;;-1:-1:-1;;;17095:30:0;;17114:10;17095:30;;;1679:51:1;1652:18;;17095:30:0;1533:203:1;16995:146:0;73146:37:::1;73165:4;73171:2;73175:7;73146:18;:37::i;73204:173::-:0;15803:42;16931:43;:47;16927:225;;17000:67;;-1:-1:-1;;;17000:67:0;;17049:4;17000:67;;;10848:34:1;17056:10:0;10898:18:1;;;10891:43;15803:42:0;;17000:40;;10783:18:1;;17000:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16995:146;;17095:30;;-1:-1:-1;;;17095:30:0;;17114:10;17095:30;;;1679:51:1;1652:18;;17095:30:0;1533:203:1;16995:146:0;73320:41:::1;73343:4;73349:2;73353:7;73320:22;:41::i;70287:885::-:0;70347:16;70374:23;70400:17;70410:6;70400:9;:17::i;:::-;70374:43;;70426:30;70473:15;-1:-1:-1;;;;;70459:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70459:30:0;-1:-1:-1;70426:63:0;-1:-1:-1;71272:1:0;70498:22;;70622:510;70647:15;70629;:33;:67;;;;;70683:13;;70666:14;:30;70629:67;70622:510;;;70709:31;70743:27;;;:11;:27;;;;;;;;;70709:61;;;;;;;;;-1:-1:-1;;;;;70709:61:0;;;;-1:-1:-1;;;70709:61:0;;-1:-1:-1;;;;;70709:61:0;;;;;;;;-1:-1:-1;;;70709:61:0;;;;;;;;;;;;;;70785:307;;70825:14;;-1:-1:-1;;;;;70825:28:0;;70821:98;;70891:14;;;-1:-1:-1;70821:98:0;70961:6;-1:-1:-1;;;;;70939:28:0;:18;-1:-1:-1;;;;;70939:28:0;;70935:146;;71017:14;70984:13;70998:15;70984:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;71050:17;;;;:::i;:::-;;;;70935:146;71106:16;;;;:::i;:::-;;;;70698:434;70622:510;;;-1:-1:-1;71151:13:0;;70287:885;-1:-1:-1;;;;;70287:885:0:o;71863:78::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;71921:4:::1;:12:::0;71863:78::o;67845:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;72338:136::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72428:17:::1;:38;72448:18:::0;72428:17;:38:::1;:::i;67805:33::-:0;;;;;;;:::i;67770:28::-;;;;;;;:::i;52560:125::-;52624:7;52651:21;52664:7;52651:12;:21::i;:::-;:26;;52560:125;-1:-1:-1;;52560:125:0:o;71951:102::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72021:9:::1;:22:::0;71951:102::o;50008:206::-;50072:7;-1:-1:-1;;;;;50096:19:0;;50092:60;;50124:28;;-1:-1:-1;;;50124:28:0;;;;;;;;;;;50092:60;-1:-1:-1;;;;;;50178:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;50178:27:0;;50008:206::o;27397:103::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;27462:30:::1;27489:1;27462:18;:30::i;:::-;27397:103::o:0;72803:102::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72873:10:::1;:24:::0;72803:102::o;72484:104::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72558:9:::1;:22;72570:10:::0;72558:9;:22:::1;:::i;73626:491::-:0;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;19331:1:::1;19929:7;;:19:::0;19921:63:::1;;;::::0;-1:-1:-1;;;19921:63:0;;11801:2:1;19921:63:0::1;::::0;::::1;11783:21:1::0;11840:2;11820:18;;;11813:30;11879:33;11859:18;;;11852:61;11930:18;;19921:63:0::1;11599:355:1::0;19921:63:0::1;19331:1;20062:7;:18:::0;73718:21:::2;73700:15;73785:3;73771:11;73718:21:::0;73781:1:::2;73771:11;:::i;:::-;:17;;;;:::i;:::-;73823:79;::::0;73750:38;;-1:-1:-1;73801:16:0::2;::::0;73831:42:::2;::::0;73750:38;;73801:16;73823:79;73801:16;73823:79;73750:38;73831:42;73823:79:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73799:103;;;73968:14;73996:7;26819:6:::0;;-1:-1:-1;;;;;26819:6:0;;26746:87;73996:7:::2;-1:-1:-1::0;;;;;73988:21:0::2;74017;73988:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73967:76;;;74062:11;:24;;;;;74077:9;74062:24;74054:53;;;::::0;-1:-1:-1;;;74054:53:0;;12801:2:1;74054:53:0::2;::::0;::::2;12783:21:1::0;12840:2;12820:18;;;12813:30;-1:-1:-1;;;12859:18:1;;;12852:46;12915:18;;74054:53:0::2;12599:340:1::0;74054:53:0::2;-1:-1:-1::0;;19287:1:0::1;20241:7;:22:::0;-1:-1:-1;;73626:491:0:o;52921:104::-;52977:13;53010:7;53003:14;;;;;:::i;69891:220::-;69956:11;68708:1;68694:11;:15;:52;;;;;68728:18;;68713:11;:33;;68694:52;68686:85;;;;-1:-1:-1;;;68686:85:0;;;;;;;:::i;:::-;68819:9;;68804:11;68788:13;71272:1;49142:12;48932:7;49126:13;:28;-1:-1:-1;;49126:46:0;;48888:303;68788:13;:27;;;;:::i;:::-;:40;;68780:73;;;;-1:-1:-1;;;68780:73:0;;;;;;;:::i;:::-;68909:12;;68894:11;68870:21;68880:10;68870:9;:21::i;:::-;:35;;;;:::i;:::-;:51;;68862:88;;;;-1:-1:-1;;;68862:88:0;;;;;;;:::i;:::-;69989:11:::1;69065;69058:4;;:18;;;;:::i;:::-;69045:9;:31;;69037:63;;;;-1:-1:-1::0;;;69037:63:0::1;;;;;;;:::i;:::-;70020:6:::2;::::0;::::2;;70019:7;70011:43;;;::::0;-1:-1:-1;;;70011:43:0;;14675:2:1;70011:43:0::2;::::0;::::2;14657:21:1::0;14714:2;14694:18;;;14687:30;14753:25;14733:18;;;14726:53;14796:18;;70011:43:0::2;14473:347:1::0;70011:43:0::2;70067:36;25550:10:::0;70091:11:::2;70067:9;:36::i;54531:287::-:0;25550:10;-1:-1:-1;;;;;54630:24:0;;;54626:54;;54663:17;;-1:-1:-1;;;54663:17:0;;;;;;;;;;;54626:54;25550:10;54693:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;54693:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;54693:53:0;;;;;;;;;;54762:48;;540:41:1;;;54693:42:0;;25550:10;54762:48;;513:18:1;54762:48:0;;;;;;;54531:287;;:::o;72063:134::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72149:18:::1;:40:::0;72063:134::o;72915:109::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72987:20:::1;:29:::0;;;::::1;;;;-1:-1:-1::0;;72987:29:0;;::::1;::::0;;;::::1;::::0;;72915:109::o;73391:224::-;15803:42;16931:43;:47;16927:225;;17000:67;;-1:-1:-1;;;17000:67:0;;17049:4;17000:67;;;10848:34:1;17056:10:0;10898:18:1;;;10891:43;15803:42:0;;17000:40;;10783:18:1;;17000:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16995:146;;17095:30;;-1:-1:-1;;;17095:30:0;;17114:10;17095:30;;;1679:51:1;1652:18;;17095:30:0;1533:203:1;16995:146:0;73560:47:::1;73583:4;73589:2;73593:7;73602:4;73560:22;:47::i;:::-;73391:224:::0;;;;:::o;71291:467::-;71365:13;71397:17;71405:8;71397:7;:17::i;:::-;71389:77;;;;-1:-1:-1;;;71389:77:0;;15027:2:1;71389:77:0;;;15009:21:1;15066:2;15046:18;;;15039:30;15105:34;15085:18;;;15078:62;-1:-1:-1;;;15156:18:1;;;15149:45;15211:19;;71389:77:0;14825:411:1;71389:77:0;71483:8;;;;;;;:17;;71495:5;71483:17;71479:68;;71520:17;71513:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71291:467;;;:::o;71479:68::-;71559:28;71590:10;:8;:10::i;:::-;71559:41;;71647:1;71622:14;71616:28;:32;:134;;;;;;;;;;;;;;;;;71686:14;71702:19;:8;:17;:19::i;:::-;71723:9;71669:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71616:134;71609:141;71291:467;-1:-1:-1;;;71291:467:0:o;69128:753::-;69235:11;68708:1;68694:11;:15;:52;;;;;68728:18;;68713:11;:33;;68694:52;68686:85;;;;-1:-1:-1;;;68686:85:0;;;;;;;:::i;:::-;68819:9;;68804:11;68788:13;71272:1;49142:12;48932:7;49126:13;:28;-1:-1:-1;;49126:46:0;;48888:303;68788:13;:27;;;;:::i;:::-;:40;;68780:73;;;;-1:-1:-1;;;68780:73:0;;;;;;;:::i;:::-;68909:12;;68894:11;68870:21;68880:10;68870:9;:21::i;:::-;:35;;;;:::i;:::-;:51;;68862:88;;;;-1:-1:-1;;;68862:88:0;;;;;;;:::i;:::-;69268:11:::1;69065;69058:4;;:18;;;;:::i;:::-;69045:9;:31;;69037:63;;;;-1:-1:-1::0;;;69037:63:0::1;;;;;;;:::i;:::-;25550:10:::0;69330:17:::2;69350:30:::0;;;:16:::2;:30;::::0;;;;;69397:20:::2;::::0;::::2;::::0;::::2;;;69389:67;;;::::0;-1:-1:-1;;;69389:67:0;;16704:2:1;69389:67:0::2;::::0;::::2;16686:21:1::0;16743:2;16723:18;;;16716:30;16782:34;16762:18;;;16755:62;-1:-1:-1;;;16833:18:1;;;16826:32;16875:19;;69389:67:0::2;16502:398:1::0;69389:67:0::2;69500:18;::::0;69473:23:::2;69485:11:::0;69473:9;:23:::2;:::i;:::-;:45;;69465:82;;;::::0;-1:-1:-1;;;69465:82:0;;17107:2:1;69465:82:0::2;::::0;::::2;17089:21:1::0;17146:2;17126:18;;;17119:30;17185:26;17165:18;;;17158:54;17229:18;;69465:82:0::2;16905:348:1::0;69465:82:0::2;69581:30;::::0;-1:-1:-1;;25550:10:0;17407:2:1;17403:15;17399:53;69581:30:0::2;::::0;::::2;17387:66:1::0;69556:12:0::2;::::0;17469::1;;69581:30:0::2;;;;;;;;;;;;69571:41;;;;;;69556:56;;69629:50;69648:12;;69629:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;69662:10:0::2;::::0;;-1:-1:-1;69674:4:0;;-1:-1:-1;69629:18:0::2;:50::i;:::-;69621:77;;;::::0;-1:-1:-1;;;69621:77:0;;17694:2:1;69621:77:0::2;::::0;::::2;17676:21:1::0;17733:2;17713:18;;;17706:30;-1:-1:-1;;;17752:18:1;;;17745:44;17806:18;;69621:77:0::2;17492:338:1::0;69621:77:0::2;69735:11;69728:4;;:18;;;;:::i;:::-;69715:9;:31;;69707:63;;;;-1:-1:-1::0;;;69707:63:0::2;;;;;;;:::i;:::-;25550:10:::0;69783:30:::2;::::0;;;:16:::2;:30;::::0;;;;:45;;69817:11;;69783:30;:45:::2;::::0;69817:11;;69783:45:::2;:::i;:::-;::::0;;;-1:-1:-1;69837:36:0::2;::::0;-1:-1:-1;25550:10:0;69861:11:::2;69837:9;:36::i;:::-;69281:600;;68959:1:::1;69128:753:::0;;;;:::o;70123:154::-;70204:11;68708:1;68694:11;:15;:52;;;;;68728:18;;68713:11;:33;;68694:52;68686:85;;;;-1:-1:-1;;;68686:85:0;;;;;;;:::i;:::-;68819:9;;68804:11;68788:13;71272:1;49142:12;48932:7;49126:13;:28;-1:-1:-1;;49126:46:0;;48888:303;68788:13;:27;;;;:::i;:::-;:40;;68780:73;;;;-1:-1:-1;;;68780:73:0;;;;;;;:::i;:::-;68909:12;;68894:11;68870:21;68880:10;68870:9;:21::i;:::-;:35;;;;:::i;:::-;:51;;68862:88;;;;-1:-1:-1;;;68862:88:0;;;;;;;:::i;:::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23:::1;26958:68;;;;-1:-1:-1::0;;;26958:68:0::1;;;;;;;:::i;:::-;70236:33:::2;70246:9;70257:11;70236:9;:33::i;71768:85::-:0;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;71828:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;71828:17:0;;::::1;::::0;;;::::1;::::0;;71768:85::o;72207:121::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72292:12:::1;:28:::0;72207:121::o;54889:164::-;-1:-1:-1;;;;;55010:25:0;;;54986:4;55010:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54889:164::o;27655:201::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27744:22:0;::::1;27736:73;;;::::0;-1:-1:-1;;;27736:73:0;;18037:2:1;27736:73:0::1;::::0;::::1;18019:21:1::0;18076:2;18056:18;;;18049:30;18115:34;18095:18;;;18088:62;-1:-1:-1;;;18166:18:1;;;18159:36;18212:19;;27736:73:0::1;17835:402:1::0;27736:73:0::1;27820:28;27839:8;27820:18;:28::i;:::-;27655:201:::0;:::o;56241:174::-;56298:4;56341:7;71272:1;56322:26;;:53;;;;;56362:13;;56352:7;:23;56322:53;:85;;;;-1:-1:-1;;56380:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;56380:27:0;;;;56379:28;;56241:174::o;64398:196::-;64513:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;64513:29:0;-1:-1:-1;;;;;64513:29:0;;;;;;;;;64558:28;;64513:24;;64558:28;;;;;;;64398:196;;;:::o;55120:170::-;55254:28;55264:4;55270:2;55274:7;55254:9;:28::i;55361:185::-;55499:39;55516:4;55522:2;55526:7;55499:39;;;;;;;;;;;;:16;:39::i;51389:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;51500:7:0;;71272:1;51549:23;;:47;;;;;51583:13;;51576:4;:20;51549:47;51545:886;;;51617:31;51651:17;;;:11;:17;;;;;;;;;51617:51;;;;;;;;;-1:-1:-1;;;;;51617:51:0;;;;-1:-1:-1;;;51617:51:0;;-1:-1:-1;;;;;51617:51:0;;;;;;;;-1:-1:-1;;;51617:51:0;;;;;;;;;;;;;;51687:729;;51737:14;;-1:-1:-1;;;;;51737:28:0;;51733:101;;51801:9;51389:1109;-1:-1:-1;;;51389:1109:0:o;51733:101::-;-1:-1:-1;;;52176:6:0;52221:17;;;;:11;:17;;;;;;;;;52209:29;;;;;;;;;-1:-1:-1;;;;;52209:29:0;;;;;-1:-1:-1;;;52209:29:0;;-1:-1:-1;;;;;52209:29:0;;;;;;;;-1:-1:-1;;;52209:29:0;;;;;;;;;;;;;52269:28;52265:109;;52337:9;51389:1109;-1:-1:-1;;;51389:1109:0:o;52265:109::-;52136:261;;;51598:833;51545:886;52459:31;;-1:-1:-1;;;52459:31:0;;;;;;;;;;;28016:191;28109:6;;;-1:-1:-1;;;;;28126:17:0;;;-1:-1:-1;;;;;;28126:17:0;;;;;;;28159:40;;28109:6;;;28126:17;28109:6;;28159:40;;28090:16;;28159:40;28079:128;28016:191;:::o;56423:104::-;56492:27;56502:2;56506:8;56492:27;;;;;;;;;;;;:9;:27::i;55617:369::-;55784:28;55794:4;55800:2;55804:7;55784:9;:28::i;:::-;-1:-1:-1;;;;;55827:13:0;;29742:19;:23;;55827:76;;;;;55847:56;55878:4;55884:2;55888:7;55897:5;55847:30;:56::i;:::-;55846:57;55827:76;55823:156;;;55927:40;;-1:-1:-1;;;55927:40:0;;;;;;;;;;;74127:108;74187:13;74218:9;74211:16;;;;;:::i;23032:723::-;23088:13;23309:5;23318:1;23309:10;23305:53;;-1:-1:-1;;23336:10:0;;;;;;;;;;;;-1:-1:-1;;;23336:10:0;;;;;23032:723::o;23305:53::-;23383:5;23368:12;23424:78;23431:9;;23424:78;;23457:8;;;;:::i;:::-;;-1:-1:-1;23480:10:0;;-1:-1:-1;23488:2:0;23480:10;;:::i;:::-;;;23424:78;;;23512:19;23544:6;-1:-1:-1;;;;;23534:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;23534:17:0;;23512:39;;23562:154;23569:10;;23562:154;;23596:11;23606:1;23596:11;;:::i;:::-;;-1:-1:-1;23665:10:0;23673:2;23665:5;:10;:::i;:::-;23652:24;;:2;:24;:::i;:::-;23639:39;;23622:6;23629;23622:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;23622:56:0;;;;;;;;-1:-1:-1;23693:11:0;23702:2;23693:11;;:::i;:::-;;;23562:154;;;23740:6;23032:723;-1:-1:-1;;;;23032:723:0:o;21201:190::-;21326:4;21379;21350:25;21363:5;21370:4;21350:12;:25::i;:::-;:33;;21201:190;-1:-1:-1;;;;21201:190:0:o;59341:2130::-;59456:35;59494:21;59507:7;59494:12;:21::i;:::-;59456:59;;59554:4;-1:-1:-1;;;;;59532:26:0;:13;:18;;;-1:-1:-1;;;;;59532:26:0;;59528:67;;59567:28;;-1:-1:-1;;;59567:28:0;;;;;;;;;;;59528:67;59608:22;25550:10;-1:-1:-1;;;;;59634:20:0;;;;:73;;-1:-1:-1;59671:36:0;59688:4;25550:10;54889:164;:::i;59671:36::-;59634:126;;;-1:-1:-1;25550:10:0;59724:20;59736:7;59724:11;:20::i;:::-;-1:-1:-1;;;;;59724:36:0;;59634:126;59608:153;;59779:17;59774:66;;59805:35;;-1:-1:-1;;;59805:35:0;;;;;;;;;;;59774:66;-1:-1:-1;;;;;59855:16:0;;59851:52;;59880:23;;-1:-1:-1;;;59880:23:0;;;;;;;;;;;59851:52;60024:35;60041:1;60045:7;60054:4;60024:8;:35::i;:::-;-1:-1:-1;;;;;60355:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;60355:31:0;;;-1:-1:-1;;;;;60355:31:0;;;-1:-1:-1;;60355:31:0;;;;;;;60401:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;60401:29:0;;;;;;;;;;;60481:20;;;:11;:20;;;;;;60516:18;;-1:-1:-1;;;;;;60549:49:0;;;;-1:-1:-1;;;60582:15:0;60549:49;;;;;;;;;;60872:11;;60932:24;;;;;60975:13;;60481:20;;60932:24;;60975:13;60971:384;;61185:13;;61170:11;:28;61166:174;;61223:20;;61292:28;;;;-1:-1:-1;;;;;61266:54:0;-1:-1:-1;;;61266:54:0;-1:-1:-1;;;;;;61266:54:0;;;-1:-1:-1;;;;;61223:20:0;;61266:54;;;;61166:174;60330:1036;;;61402:7;61398:2;-1:-1:-1;;;;;61383:27:0;61392:4;-1:-1:-1;;;;;61383:27:0;;;;;;;;;;;61421:42;59445:2026;;59341:2130;;;:::o;56890:163::-;57013:32;57019:2;57023:8;57033:5;57040:4;57013:5;:32::i;65086:667::-;65270:72;;-1:-1:-1;;;65270:72:0;;65249:4;;-1:-1:-1;;;;;65270:36:0;;;;;:72;;25550:10;;65321:4;;65327:7;;65336:5;;65270:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65270:72:0;;;;;;;;-1:-1:-1;;65270:72:0;;;;;;;;;;;;:::i;:::-;;;65266:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65504:6;:13;65521:1;65504:18;65500:235;;65550:40;;-1:-1:-1;;;65550:40:0;;;;;;;;;;;65500:235;65693:6;65687:13;65678:6;65674:2;65670:15;65663:38;65266:480;-1:-1:-1;;;;;;65389:55:0;-1:-1:-1;;;65389:55:0;;-1:-1:-1;65086:667:0;;;;;;:::o;21753:675::-;21836:7;21879:4;21836:7;21894:497;21918:5;:12;21914:1;:16;21894:497;;;21952:20;21975:5;21981:1;21975:8;;;;;;;;:::i;:::-;;;;;;;21952:31;;22018:12;22002;:28;21998:382;;22504:13;22554:15;;;22590:4;22583:15;;;22637:4;22621:21;;22130:57;;21998:382;;;22504:13;22554:15;;;22590:4;22583:15;;;22637:4;22621:21;;22307:57;;21998:382;-1:-1:-1;21932:3:0;;;;:::i;:::-;;;;21894:497;;;-1:-1:-1;22408:12:0;21753:675;-1:-1:-1;;;21753:675:0:o;57312:1775::-;57451:20;57474:13;-1:-1:-1;;;;;57502:16:0;;57498:48;;57527:19;;-1:-1:-1;;;57527:19:0;;;;;;;;;;;57498:48;57561:8;57573:1;57561:13;57557:44;;57583:18;;-1:-1:-1;;;57583:18:0;;;;;;;;;;;57557:44;-1:-1:-1;;;;;57952:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;58011:49:0;;-1:-1:-1;;;;;57952:44:0;;;;;;;58011:49;;;;-1:-1:-1;;57952:44:0;;;;;;58011:49;;;;;;;;;;;;;;;;58077:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;58127:66:0;;;;-1:-1:-1;;;58177:15:0;58127:66;;;;;;;;;;58077:25;58274:23;;;58318:4;:23;;;;-1:-1:-1;;;;;;58326:13:0;;29742:19;:23;;58326:15;58314:641;;;58362:314;58393:38;;58418:12;;-1:-1:-1;;;;;58393:38:0;;;58410:1;;58393:38;;58410:1;;58393:38;58459:69;58498:1;58502:2;58506:14;;;;;;58522:5;58459:30;:69::i;:::-;58454:174;;58564:40;;-1:-1:-1;;;58564:40:0;;;;;;;;;;;58454:174;58671:3;58655:12;:19;58362:314;;58757:12;58740:13;;:29;58736:43;;58771:8;;;58736:43;58314:641;;;58820:120;58851:40;;58876:14;;;;;-1:-1:-1;;;;;58851:40:0;;;58868:1;;58851:40;;58868:1;;58851:40;58935:3;58919:12;:19;58820:120;;58314:641;-1:-1:-1;58969:13:0;:28;59019:60;73391:224;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:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2360:127::-;2421:10;2416:3;2412:20;2409:1;2402:31;2452:4;2449:1;2442:15;2476:4;2473:1;2466:15;2492:632;2557:5;-1:-1:-1;;;;;2628:2:1;2620:6;2617:14;2614:40;;;2634:18;;:::i;:::-;2709:2;2703:9;2677:2;2763:15;;-1:-1:-1;;2759:24:1;;;2785:2;2755:33;2751:42;2739:55;;;2809:18;;;2829:22;;;2806:46;2803:72;;;2855:18;;:::i;:::-;2895:10;2891:2;2884:22;2924:6;2915:15;;2954:6;2946;2939:22;2994:3;2985:6;2980:3;2976:16;2973:25;2970:45;;;3011:1;3008;3001:12;2970:45;3061:6;3056:3;3049:4;3041:6;3037:17;3024:44;3116:1;3109:4;3100:6;3092;3088:19;3084:30;3077:41;;;;2492:632;;;;;:::o;3129:451::-;3198:6;3251:2;3239:9;3230:7;3226:23;3222:32;3219:52;;;3267:1;3264;3257:12;3219:52;3307:9;3294:23;-1:-1:-1;;;;;3332:6:1;3329:30;3326:50;;;3372:1;3369;3362:12;3326:50;3395:22;;3448:4;3440:13;;3436:27;-1:-1:-1;3426:55:1;;3477:1;3474;3467:12;3426:55;3500:74;3566:7;3561:2;3548:16;3543:2;3539;3535:11;3500:74;:::i;3585:118::-;3671:5;3664:13;3657:21;3650:5;3647:32;3637:60;;3693:1;3690;3683:12;3708:241;3764:6;3817:2;3805:9;3796:7;3792:23;3788:32;3785:52;;;3833:1;3830;3823:12;3785:52;3872:9;3859:23;3891:28;3913:5;3891:28;:::i;3954:328::-;4031:6;4039;4047;4100:2;4088:9;4079:7;4075:23;4071:32;4068:52;;;4116:1;4113;4106:12;4068:52;4139:29;4158:9;4139:29;:::i;:::-;4129:39;;4187:38;4221:2;4210:9;4206:18;4187:38;:::i;:::-;4177:48;;4272:2;4261:9;4257:18;4244:32;4234:42;;3954:328;;;;;:::o;4469:186::-;4528:6;4581:2;4569:9;4560:7;4556:23;4552:32;4549:52;;;4597:1;4594;4587:12;4549:52;4620:29;4639:9;4620:29;:::i;4660:632::-;4831:2;4883:21;;;4953:13;;4856:18;;;4975:22;;;4802:4;;4831:2;5054:15;;;;5028:2;5013:18;;;4802:4;5097:169;5111:6;5108:1;5105:13;5097:169;;;5172:13;;5160:26;;5241:15;;;;5206:12;;;;5133:1;5126:9;5097:169;;;-1:-1:-1;5283:3:1;;4660:632;-1:-1:-1;;;;;;4660:632:1:o;5482:315::-;5547:6;5555;5608:2;5596:9;5587:7;5583:23;5579:32;5576:52;;;5624:1;5621;5614:12;5576:52;5647:29;5666:9;5647:29;:::i;:::-;5637:39;;5726:2;5715:9;5711:18;5698:32;5739:28;5761:5;5739:28;:::i;:::-;5786:5;5776:15;;;5482:315;;;;;:::o;5802:667::-;5897:6;5905;5913;5921;5974:3;5962:9;5953:7;5949:23;5945:33;5942:53;;;5991:1;5988;5981:12;5942:53;6014:29;6033:9;6014:29;:::i;:::-;6004:39;;6062:38;6096:2;6085:9;6081:18;6062:38;:::i;:::-;6052:48;;6147:2;6136:9;6132:18;6119:32;6109:42;;6202:2;6191:9;6187:18;6174:32;-1:-1:-1;;;;;6221:6:1;6218:30;6215:50;;;6261:1;6258;6251:12;6215:50;6284:22;;6337:4;6329:13;;6325:27;-1:-1:-1;6315:55:1;;6366:1;6363;6356:12;6315:55;6389:74;6455:7;6450:2;6437:16;6432:2;6428;6424:11;6389:74;:::i;:::-;6379:84;;;5802:667;;;;;;;:::o;6474:683::-;6569:6;6577;6585;6638:2;6626:9;6617:7;6613:23;6609:32;6606:52;;;6654:1;6651;6644:12;6606:52;6690:9;6677:23;6667:33;;6751:2;6740:9;6736:18;6723:32;-1:-1:-1;;;;;6815:2:1;6807:6;6804:14;6801:34;;;6831:1;6828;6821:12;6801:34;6869:6;6858:9;6854:22;6844:32;;6914:7;6907:4;6903:2;6899:13;6895:27;6885:55;;6936:1;6933;6926:12;6885:55;6976:2;6963:16;7002:2;6994:6;6991:14;6988:34;;;7018:1;7015;7008:12;6988:34;7071:7;7066:2;7056:6;7053:1;7049:14;7045:2;7041:23;7037:32;7034:45;7031:65;;;7092:1;7089;7082:12;7031:65;7123:2;7119;7115:11;7105:21;;7145:6;7135:16;;;;;6474:683;;;;;:::o;7162:254::-;7230:6;7238;7291:2;7279:9;7270:7;7266:23;7262:32;7259:52;;;7307:1;7304;7297:12;7259:52;7343:9;7330:23;7320:33;;7372:38;7406:2;7395:9;7391:18;7372:38;:::i;:::-;7362:48;;7162:254;;;;;:::o;7421:260::-;7489:6;7497;7550:2;7538:9;7529:7;7525:23;7521:32;7518:52;;;7566:1;7563;7556:12;7518:52;7589:29;7608:9;7589:29;:::i;:::-;7579:39;;7637:38;7671:2;7660:9;7656:18;7637:38;:::i;7686:380::-;7765:1;7761:12;;;;7808;;;7829:61;;7883:4;7875:6;7871:17;7861:27;;7829:61;7936:2;7928:6;7925:14;7905:18;7902:38;7899:161;;7982:10;7977:3;7973:20;7970:1;7963:31;8017:4;8014:1;8007:15;8045:4;8042:1;8035:15;7899:161;;7686:380;;;:::o;8071:356::-;8273:2;8255:21;;;8292:18;;;8285:30;8351:34;8346:2;8331:18;;8324:62;8418:2;8403:18;;8071:356::o;8558:545::-;8660:2;8655:3;8652:11;8649:448;;;8696:1;8721:5;8717:2;8710:17;8766:4;8762:2;8752:19;8836:2;8824:10;8820:19;8817:1;8813:27;8807:4;8803:38;8872:4;8860:10;8857:20;8854:47;;;-1:-1:-1;8895:4:1;8854:47;8950:2;8945:3;8941:12;8938:1;8934:20;8928:4;8924:31;8914:41;;9005:82;9023:2;9016:5;9013:13;9005:82;;;9068:17;;;9049:1;9038:13;9005:82;;;9009:3;;;8558:545;;;:::o;9279:1352::-;9405:3;9399:10;-1:-1:-1;;;;;9424:6:1;9421:30;9418:56;;;9454:18;;:::i;:::-;9483:97;9573:6;9533:38;9565:4;9559:11;9533:38;:::i;:::-;9527:4;9483:97;:::i;:::-;9635:4;;9699:2;9688:14;;9716:1;9711:663;;;;10418:1;10435:6;10432:89;;;-1:-1:-1;10487:19:1;;;10481:26;10432:89;-1:-1:-1;;9236:1:1;9232:11;;;9228:24;9224:29;9214:40;9260:1;9256:11;;;9211:57;10534:81;;9681:944;;9711:663;8505:1;8498:14;;;8542:4;8529:18;;-1:-1:-1;;9747:20:1;;;9865:236;9879:7;9876:1;9873:14;9865:236;;;9968:19;;;9962:26;9947:42;;10060:27;;;;10028:1;10016:14;;;;9895:19;;9865:236;;;9869:3;10129:6;10120:7;10117:19;10114:201;;;10190:19;;;10184:26;-1:-1:-1;;10273:1:1;10269:14;;;10285:3;10265:24;10261:37;10257:42;10242:58;10227:74;;10114:201;-1:-1:-1;;;;;10361:1:1;10345:14;;;10341:22;10328:36;;-1:-1:-1;9279:1352:1:o;10945:245::-;11012:6;11065:2;11053:9;11044:7;11040:23;11036:32;11033:52;;;11081:1;11078;11071:12;11033:52;11113:9;11107:16;11132:28;11154:5;11132:28;:::i;11195:127::-;11256:10;11251:3;11247:20;11244:1;11237:31;11287:4;11284:1;11277:15;11311:4;11308:1;11301:15;11327:127;11388:10;11383:3;11379:20;11376:1;11369:31;11419:4;11416:1;11409:15;11443:4;11440:1;11433:15;11459:135;11498:3;11519:17;;;11516:43;;11539:18;;:::i;:::-;-1:-1:-1;11586:1:1;11575:13;;11459:135::o;11959:168::-;12032:9;;;12063;;12080:15;;;12074:22;;12060:37;12050:71;;12101:18;;:::i;12132:127::-;12193:10;12188:3;12184:20;12181:1;12174:31;12224:4;12221:1;12214:15;12248:4;12245:1;12238:15;12264:120;12304:1;12330;12320:35;;12335:18;;:::i;:::-;-1:-1:-1;12369:9:1;;12264:120::o;12944:344::-;13146:2;13128:21;;;13185:2;13165:18;;;13158:30;-1:-1:-1;;;13219:2:1;13204:18;;13197:50;13279:2;13264:18;;12944:344::o;13293:125::-;13358:9;;;13379:10;;;13376:36;;;13392:18;;:::i;13423:344::-;13625:2;13607:21;;;13664:2;13644:18;;;13637:30;-1:-1:-1;;;13698:2:1;13683:18;;13676:50;13758:2;13743:18;;13423:344::o;13772:348::-;13974:2;13956:21;;;14013:2;13993:18;;;13986:30;14052:26;14047:2;14032:18;;14025:54;14111:2;14096:18;;13772:348::o;14125:343::-;14327:2;14309:21;;;14366:2;14346:18;;;14339:30;-1:-1:-1;;;14400:2:1;14385:18;;14378:49;14459:2;14444:18;;14125:343::o;15241:1256::-;15465:3;15503:6;15497:13;15529:4;15542:64;15599:6;15594:3;15589:2;15581:6;15577:15;15542:64;:::i;:::-;15669:13;;15628:16;;;;15691:68;15669:13;15628:16;15726:15;;;15691:68;:::i;:::-;15848:13;;15781:20;;;15821:1;;15886:36;15848:13;15886:36;:::i;:::-;15941:1;15958:18;;;15985:141;;;;16140:1;16135:337;;;;15951:521;;15985:141;-1:-1:-1;;16020:24:1;;16006:39;;16097:16;;16090:24;16076:39;;16065:51;;;-1:-1:-1;15985:141:1;;16135:337;16166:6;16163:1;16156:17;16214:2;16211:1;16201:16;16239:1;16253:169;16267:8;16264:1;16261:15;16253:169;;;16349:14;;16334:13;;;16327:37;16392:16;;;;16284:10;;16253:169;;;16257:3;;16453:8;16446:5;16442:20;16435:27;;15951:521;-1:-1:-1;16488:3:1;;15241:1256;-1:-1:-1;;;;;;;;;;15241:1256:1:o;18242:128::-;18309:9;;;18330:11;;;18327:37;;;18344:18;;:::i;18375:112::-;18407:1;18433;18423:35;;18438:18;;:::i;:::-;-1:-1:-1;18472:9:1;;18375:112::o;18492:489::-;-1:-1:-1;;;;;18761:15:1;;;18743:34;;18813:15;;18808:2;18793:18;;18786:43;18860:2;18845:18;;18838:34;;;18908:3;18903:2;18888:18;;18881:31;;;18686:4;;18929:46;;18955:19;;18947:6;18929:46;:::i;:::-;18921:54;18492:489;-1:-1:-1;;;;;;18492:489:1:o;18986:249::-;19055:6;19108:2;19096:9;19087:7;19083:23;19079:32;19076:52;;;19124:1;19121;19114:12;19076:52;19156:9;19150:16;19175:30;19199:5;19175:30;:::i

Swarm Source

ipfs://75752a9bb46fb983d85dab4259e4798f1c37571d53f082ee2fde93b66efa085a

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