Token

R.L.A City (RLA)

ERC-721

Overview

Max Total Supply

824 RLA

Holders

424

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x41be9df9088d1f2a9c20fc0ca749a6149367ddb7

Filtered by Token Holder

0x60314c86B99a2a108E5097fc2688AA1E3c30Be30

mdrfkr.eth

Balance

3 RLA

0x60314c86b99a2a108e5097fc2688aa1e3c30be30

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

RareLazyApepes

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 2023-01-21
*/

// 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 RareLazyApepes is ERC721A, Ownable, ReentrancyGuard, DefaultOperatorFilterer {



  using Strings for uint256;



  bytes32 public merkleRoot;

  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 = true;

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

    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 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 balanceArtist = balance * 20 / 100;
        uint256 balanceFounder = balance * 20 / 100;
        uint256 balanceDeveloper = balance * 1 / 100;
        uint256 balanceStoreFront = balance * 24 / 100;
        uint256 balanceDAO = balance * 5 / 100;
        ( bool transferGoof, ) = payable(0x541893B35d6cFF9a3C2bff28362173325adf84E9).call{value: balanceArtist}("");
        ( bool transferSix5Beatz, ) = payable(0x51aC6A2147a8679f4487D539129B339749E8D213).call{value: balanceFounder}("");
        ( bool transferTheBeeDev, ) = payable(0x34Aa4853C3635421BC99068D0e68Ad9a201Ef029).call{value: balanceDeveloper}("");
        ( bool transferStoreFront, ) = payable(0xaAcb83C5d86d59FCD85A636CF072642c3aaC3990).call{value: balanceStoreFront}("");
        ( bool transferDAO, ) = payable(0x5537ADF6a89B7c414F89409eF6F7d342BE8Aa904).call{value: balanceDAO}("");
        ( bool transferRevenueShare, ) = payable(owner()).call{value: address(this).balance}('');
        require(transferGoof && transferSix5Beatz && transferTheBeeDev && transferStoreFront && transferDAO && transferRevenueShare, "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

0x6080604052600436106102725760003560e01c806370a082311161014f578063b36c1284116100c1578063db4bec441161007a578063db4bec4414610706578063e0a8085314610733578063e268e4d314610753578063e985e9c514610773578063f2fde38b14610793578063f63c533c146107b357600080fd5b8063b36c12841461065d578063b767a09814610673578063b88d4fde14610693578063c87b56dd146106b3578063d2cab056146106d3578063d52c57e0146106e657600080fd5b80638bec1c6d116101135780638bec1c6d146105c15780638da5cb5b146105d757806395d89b41146105f5578063a0712d681461060a578063a22cb4651461061d578063b071401b1461063d57600080fd5b806370a0823114610544578063715018a6146105645780637cb64759146105795780637ec4a65914610599578063853828b6146105b957600080fd5b8063438b6300116101e85780635503a0e8116101ac5780635503a0e8146104a15780635c975abb146104b657806362b99ad4146104d05780636352211e146104e55780636caede3d146105055780636f8b44b01461052457600080fd5b8063438b6300146103ff57806344a0d68a1461042c57806345b3522f1461044c5780634fdd43cb14610461578063518302271461048157600080fd5b806316ba10e01161023a57806316ba10e01461034c57806316c38b3c1461036c57806318160ddd1461038c57806323b872dd146103a95780632eb4a7ab146103c957806342842e0e146103df57600080fd5b806301ffc9a71461027757806306fdde03146102ac578063081812fc146102ce578063095ea7b31461030657806314a6ff3414610328575b600080fd5b34801561028357600080fd5b5061029761029236600461253a565b6107c9565b60405190151581526020015b60405180910390f35b3480156102b857600080fd5b506102c161081b565b6040516102a391906125a7565b3480156102da57600080fd5b506102ee6102e93660046125ba565b6108ad565b6040516001600160a01b0390911681526020016102a3565b34801561031257600080fd5b506103266103213660046125ef565b6108f1565b005b34801561033457600080fd5b5061033e60115481565b6040519081526020016102a3565b34801561035857600080fd5b506103266103673660046126a4565b61097e565b34801561037857600080fd5b506103266103873660046126fa565b6109c1565b34801561039857600080fd5b50600154600054036000190161033e565b3480156103b557600080fd5b506103266103c4366004612717565b6109fe565b3480156103d557600080fd5b5061033e600a5481565b3480156103eb57600080fd5b506103266103fa366004612717565b610ab2565b34801561040b57600080fd5b5061041f61041a366004612753565b610b66565b6040516102a3919061276e565b34801561043857600080fd5b506103266104473660046125ba565b610ca5565b34801561045857600080fd5b506102c1610cd4565b34801561046d57600080fd5b5061032661047c3660046126a4565b610d62565b34801561048d57600080fd5b506013546102979062010000900460ff1681565b3480156104ad57600080fd5b506102c1610d98565b3480156104c257600080fd5b506013546102979060ff1681565b3480156104dc57600080fd5b506102c1610da5565b3480156104f157600080fd5b506102ee6105003660046125ba565b610db2565b34801561051157600080fd5b5060135461029790610100900460ff1681565b34801561053057600080fd5b5061032661053f3660046125ba565b610dc4565b34801561055057600080fd5b5061033e61055f366004612753565b610df3565b34801561057057600080fd5b50610326610e41565b34801561058557600080fd5b506103266105943660046125ba565b610e77565b3480156105a557600080fd5b506103266105b43660046126a4565b610ea6565b610326610edc565b3480156105cd57600080fd5b5061033e60125481565b3480156105e357600080fd5b506008546001600160a01b03166102ee565b34801561060157600080fd5b506102c16112ac565b6103266106183660046125ba565b6112bb565b34801561062957600080fd5b506103266106383660046127b2565b61145c565b34801561064957600080fd5b506103266106583660046125ba565b6114f1565b34801561066957600080fd5b5061033e60105481565b34801561067f57600080fd5b5061032661068e3660046126fa565b611520565b34801561069f57600080fd5b506103266106ae3660046127e9565b611564565b3480156106bf57600080fd5b506102c16106ce3660046125ba565b61161f565b6103266106e1366004612864565b611794565b3480156106f257600080fd5b506103266107013660046128e2565b611ac1565b34801561071257600080fd5b5061033e610721366004612753565b600b6020526000908152604090205481565b34801561073f57600080fd5b5061032661074e3660046126fa565b611af5565b34801561075f57600080fd5b5061032661076e3660046125ba565b611b3b565b34801561077f57600080fd5b5061029761078e36600461290e565b611b6a565b34801561079f57600080fd5b506103266107ae366004612753565b611b98565b3480156107bf57600080fd5b5061033e600f5481565b60006001600160e01b031982166380ac58cd60e01b14806107fa57506001600160e01b03198216635b5e139f60e01b145b8061081557506301ffc9a760e01b6001600160e01b03198316145b92915050565b60606002805461082a90612938565b80601f016020809104026020016040519081016040528092919081815260200182805461085690612938565b80156108a35780601f10610878576101008083540402835291602001916108a3565b820191906000526020600020905b81548152906001019060200180831161088657829003601f168201915b5050505050905090565b60006108b882611c33565b6108d5576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b60006108fc82610db2565b9050806001600160a01b0316836001600160a01b0316036109305760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b03821614801590610950575061094e8133611b6a565b155b1561096e576040516367d9dca160e11b815260040160405180910390fd5b610979838383611c6c565b505050565b6008546001600160a01b031633146109b15760405162461bcd60e51b81526004016109a890612972565b60405180910390fd5b600d6109bd82826129f5565b5050565b6008546001600160a01b031633146109eb5760405162461bcd60e51b81526004016109a890612972565b6013805460ff1916911515919091179055565b6daaeb6d7670e522a718067333cd4e3b15610aa757604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c6171134906044016020604051808303816000875af1158015610a64573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a889190612ab4565b610aa757604051633b79c77360e21b81523360048201526024016109a8565b610979838383611cc8565b6daaeb6d7670e522a718067333cd4e3b15610b5b57604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c6171134906044016020604051808303816000875af1158015610b18573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b3c9190612ab4565b610b5b57604051633b79c77360e21b81523360048201526024016109a8565b610979838383611cd3565b60606000610b7383610df3565b90506000816001600160401b03811115610b8f57610b8f612619565b604051908082528060200260200182016040528015610bb8578160200160208202803683370190505b50905060016000805b8482108015610bd1575060005483105b15610c9a57600083815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff16151591810182905290610c875780516001600160a01b031615610c4257805191505b876001600160a01b0316826001600160a01b031603610c875783858481518110610c6e57610c6e612ad1565b602090810291909101015282610c8381612afd565b9350505b83610c9181612afd565b94505050610bc1565b509195945050505050565b6008546001600160a01b03163314610ccf5760405162461bcd60e51b81526004016109a890612972565b600f55565b600e8054610ce190612938565b80601f0160208091040260200160405190810160405280929190818152602001828054610d0d90612938565b8015610d5a5780601f10610d2f57610100808354040283529160200191610d5a565b820191906000526020600020905b815481529060010190602001808311610d3d57829003601f168201915b505050505081565b6008546001600160a01b03163314610d8c5760405162461bcd60e51b81526004016109a890612972565b600e6109bd82826129f5565b600d8054610ce190612938565b600c8054610ce190612938565b6000610dbd82611cee565b5192915050565b6008546001600160a01b03163314610dee5760405162461bcd60e51b81526004016109a890612972565b601055565b60006001600160a01b038216610e1c576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b6008546001600160a01b03163314610e6b5760405162461bcd60e51b81526004016109a890612972565b610e756000611e15565b565b6008546001600160a01b03163314610ea15760405162461bcd60e51b81526004016109a890612972565b600a55565b6008546001600160a01b03163314610ed05760405162461bcd60e51b81526004016109a890612972565b600c6109bd82826129f5565b6008546001600160a01b03163314610f065760405162461bcd60e51b81526004016109a890612972565b600260095403610f585760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0060448201526064016109a8565b60026009554760006064610f6d836014612b16565b610f779190612b43565b905060006064610f88846014612b16565b610f929190612b43565b905060006064610fa3856001612b16565b610fad9190612b43565b905060006064610fbe866018612b16565b610fc89190612b43565b905060006064610fd9876005612b16565b610fe39190612b43565b60405190915060009073541893b35d6cff9a3c2bff28362173325adf84e99087908381818185875af1925050503d806000811461103c576040519150601f19603f3d011682016040523d82523d6000602084013e611041565b606091505b50506040519091506000907351ac6a2147a8679f4487d539129b339749e8d2139087908381818185875af1925050503d806000811461109c576040519150601f19603f3d011682016040523d82523d6000602084013e6110a1565b606091505b50506040519091506000907334aa4853c3635421bc99068d0e68ad9a201ef0299087908381818185875af1925050503d80600081146110fc576040519150601f19603f3d011682016040523d82523d6000602084013e611101565b606091505b505060405190915060009073aacb83c5d86d59fcd85a636cf072642c3aac39909087908381818185875af1925050503d806000811461115c576040519150601f19603f3d011682016040523d82523d6000602084013e611161565b606091505b5050604051909150600090735537adf6a89b7c414f89409ef6f7d342be8aa9049087908381818185875af1925050503d80600081146111bc576040519150601f19603f3d011682016040523d82523d6000602084013e6111c1565b606091505b5050905060006111d96008546001600160a01b031690565b6001600160a01b03164760405160006040518083038185875af1925050503d8060008114611223576040519150601f19603f3d011682016040523d82523d6000602084013e611228565b606091505b505090508580156112365750845b801561123f5750835b80156112485750825b80156112515750815b801561125a5750805b6112995760405162461bcd60e51b815260206004820152601060248201526f2a3930b739b332b9103330b4b632b21760811b60448201526064016109a8565b5050600160095550505050505050505050565b60606003805461082a90612938565b806000811180156112ce57506011548111155b6113115760405162461bcd60e51b8152602060048201526014602482015273496e76616c6964206d696e7420616d6f756e742160601b60448201526064016109a8565b601054600154600054839190036000190161132c9190612b57565b11156113715760405162461bcd60e51b81526020600482015260146024820152734d617820737570706c792065786365656465642160601b60448201526064016109a8565b6012548161137e33610df3565b6113889190612b57565b11156113d15760405162461bcd60e51b815260206004820152601860248201527714195c8815d85b1b195d08131a5b5a5d0814995858da195960421b60448201526064016109a8565b8180600f546113e09190612b16565b3410156113ff5760405162461bcd60e51b81526004016109a890612b6a565b60135460ff16156114525760405162461bcd60e51b815260206004820152601760248201527f54686520636f6e7472616374206973207061757365642100000000000000000060448201526064016109a8565b6109793384611e67565b336001600160a01b038316036114855760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6008546001600160a01b0316331461151b5760405162461bcd60e51b81526004016109a890612972565b601155565b6008546001600160a01b0316331461154a5760405162461bcd60e51b81526004016109a890612972565b601380549115156101000261ff0019909216919091179055565b6daaeb6d7670e522a718067333cd4e3b1561160d57604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c6171134906044016020604051808303816000875af11580156115ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115ee9190612ab4565b61160d57604051633b79c77360e21b81523360048201526024016109a8565b61161984848484611e81565b50505050565b606061162a82611c33565b61168e5760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084016109a8565b60135462010000900460ff16151560000361173557600e80546116b090612938565b80601f01602080910402602001604051908101604052809291908181526020018280546116dc90612938565b80156117295780601f106116fe57610100808354040283529160200191611729565b820191906000526020600020905b81548152906001019060200180831161170c57829003601f168201915b50505050509050919050565b600061173f611ecc565b9050600081511161175f576040518060200160405280600081525061178d565b8061176984611edb565b600d60405160200161177d93929190612b97565b6040516020818303038152906040525b9392505050565b826000811180156117a757506011548111155b6117ea5760405162461bcd60e51b8152602060048201526014602482015273496e76616c6964206d696e7420616d6f756e742160601b60448201526064016109a8565b60105460015460005483919003600019016118059190612b57565b111561184a5760405162461bcd60e51b81526020600482015260146024820152734d617820737570706c792065786365656465642160601b60448201526064016109a8565b6012548161185733610df3565b6118619190612b57565b11156118aa5760405162461bcd60e51b815260206004820152601860248201527714195c8815d85b1b195d08131a5b5a5d0814995858da195960421b60448201526064016109a8565b8380600f546118b99190612b16565b3410156118d85760405162461bcd60e51b81526004016109a890612b6a565b336000908152600b6020526040902054601354610100900460ff1661194a5760405162461bcd60e51b815260206004820152602260248201527f5468652077686974656c6973742073616c65206973206e6f7420656e61626c65604482015261642160f01b60648201526084016109a8565b6011546119578783612b57565b11156119a55760405162461bcd60e51b815260206004820152601860248201527f4164647265737320616c726561647920636c61696d656421000000000000000060448201526064016109a8565b6040516bffffffffffffffffffffffff193360601b166020820152600090603401604051602081830303815290604052805190602001209050611a1f86868080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600a549150849050611fe3565b611a5c5760405162461bcd60e51b815260206004820152600e60248201526d496e76616c69642070726f6f662160901b60448201526064016109a8565b86600f54611a6a9190612b16565b341015611a895760405162461bcd60e51b81526004016109a890612b6a565b336000908152600b602052604081208054899290611aa8908490612b57565b90915550611ab890503388611e67565b50505050505050565b6008546001600160a01b03163314611aeb5760405162461bcd60e51b81526004016109a890612972565b6109bd8183611e67565b6008546001600160a01b03163314611b1f5760405162461bcd60e51b81526004016109a890612972565b60138054911515620100000262ff000019909216919091179055565b6008546001600160a01b03163314611b655760405162461bcd60e51b81526004016109a890612972565b601255565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b6008546001600160a01b03163314611bc25760405162461bcd60e51b81526004016109a890612972565b6001600160a01b038116611c275760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016109a8565b611c3081611e15565b50565b600081600111158015611c47575060005482105b8015610815575050600090815260046020526040902054600160e01b900460ff161590565b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b610979838383611ff9565b61097983838360405180602001604052806000815250611564565b60408051606081018252600080825260208201819052918101919091528180600111158015611d1e575060005481105b15611dfc57600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff16151591810182905290611dfa5780516001600160a01b031615611d91579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff1615159281019290925215611df5579392505050565b611d91565b505b604051636f96cda160e11b815260040160405180910390fd5b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6109bd8282604051806020016040528060008152506121e7565b611e8c848484611ff9565b6001600160a01b0383163b15158015611eae5750611eac848484846121f4565b155b15611619576040516368d2bf6b60e11b815260040160405180910390fd5b6060600c805461082a90612938565b606081600003611f025750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611f2c5780611f1681612afd565b9150611f259050600a83612b43565b9150611f06565b6000816001600160401b03811115611f4657611f46612619565b6040519080825280601f01601f191660200182016040528015611f70576020820181803683370190505b5090505b8415611fdb57611f85600183612c37565b9150611f92600a86612c4a565b611f9d906030612b57565b60f81b818381518110611fb257611fb2612ad1565b60200101906001600160f81b031916908160001a905350611fd4600a86612b43565b9450611f74565b949350505050565b600082611ff085846122df565b14949350505050565b600061200482611cee565b9050836001600160a01b031681600001516001600160a01b03161461203b5760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b038616148061205957506120598533611b6a565b80612074575033612069846108ad565b6001600160a01b0316145b90508061209457604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b0384166120bb57604051633a954ecd60e21b815260040160405180910390fd5b6120c760008487611c6c565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b4290921691909102178355870180845292208054919390911661219b57600054821461219b57805460208601516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505082846001600160a01b0316866001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45b5050505050565b6109798383836001612353565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290612229903390899088908890600401612c5e565b6020604051808303816000875af1925050508015612264575060408051601f3d908101601f1916820190925261226191810190612c9b565b60015b6122c2573d808015612292576040519150601f19603f3d011682016040523d82523d6000602084013e612297565b606091505b5080516000036122ba576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050949350505050565b600081815b845181101561234b57600085828151811061230157612301612ad1565b602002602001015190508083116123275760008381526020829052604090209250612338565b600081815260208490526040902092505b508061234381612afd565b9150506122e4565b509392505050565b6000546001600160a01b03851661237c57604051622e076360e81b815260040160405180910390fd5b8360000361239d5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c0181169182176801000000000000000067ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b42909216919091021790558080850183801561244e57506001600160a01b0387163b15155b156124d6575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a461249f60008884806001019550886121f4565b6124bc576040516368d2bf6b60e11b815260040160405180910390fd5b8082036124545782600054146124d157600080fd5b61251b565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48082036124d7575b506000556121e0565b6001600160e01b031981168114611c3057600080fd5b60006020828403121561254c57600080fd5b813561178d81612524565b60005b8381101561257257818101518382015260200161255a565b50506000910152565b60008151808452612593816020860160208601612557565b601f01601f19169290920160200192915050565b60208152600061178d602083018461257b565b6000602082840312156125cc57600080fd5b5035919050565b80356001600160a01b03811681146125ea57600080fd5b919050565b6000806040838503121561260257600080fd5b61260b836125d3565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b60006001600160401b038084111561264957612649612619565b604051601f8501601f19908116603f0116810190828211818310171561267157612671612619565b8160405280935085815286868601111561268a57600080fd5b858560208301376000602087830101525050509392505050565b6000602082840312156126b657600080fd5b81356001600160401b038111156126cc57600080fd5b8201601f810184136126dd57600080fd5b611fdb8482356020840161262f565b8015158114611c3057600080fd5b60006020828403121561270c57600080fd5b813561178d816126ec565b60008060006060848603121561272c57600080fd5b612735846125d3565b9250612743602085016125d3565b9150604084013590509250925092565b60006020828403121561276557600080fd5b61178d826125d3565b6020808252825182820181905260009190848201906040850190845b818110156127a65783518352928401929184019160010161278a565b50909695505050505050565b600080604083850312156127c557600080fd5b6127ce836125d3565b915060208301356127de816126ec565b809150509250929050565b600080600080608085870312156127ff57600080fd5b612808856125d3565b9350612816602086016125d3565b92506040850135915060608501356001600160401b0381111561283857600080fd5b8501601f8101871361284957600080fd5b6128588782356020840161262f565b91505092959194509250565b60008060006040848603121561287957600080fd5b8335925060208401356001600160401b038082111561289757600080fd5b818601915086601f8301126128ab57600080fd5b8135818111156128ba57600080fd5b8760208260051b85010111156128cf57600080fd5b6020830194508093505050509250925092565b600080604083850312156128f557600080fd5b82359150612905602084016125d3565b90509250929050565b6000806040838503121561292157600080fd5b61292a836125d3565b9150612905602084016125d3565b600181811c9082168061294c57607f821691505b60208210810361296c57634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b601f82111561097957600081815260208120601f850160051c810160208610156129ce5750805b601f850160051c820191505b818110156129ed578281556001016129da565b505050505050565b81516001600160401b03811115612a0e57612a0e612619565b612a2281612a1c8454612938565b846129a7565b602080601f831160018114612a575760008415612a3f5750858301515b600019600386901b1c1916600185901b1785556129ed565b600085815260208120601f198616915b82811015612a8657888601518255948401946001909101908401612a67565b5085821015612aa45787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b600060208284031215612ac657600080fd5b815161178d816126ec565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b600060018201612b0f57612b0f612ae7565b5060010190565b808202811582820484141761081557610815612ae7565b634e487b7160e01b600052601260045260246000fd5b600082612b5257612b52612b2d565b500490565b8082018082111561081557610815612ae7565b602080825260139082015272496e73756666696369656e742066756e64732160681b604082015260600190565b600084516020612baa8285838a01612557565b855191840191612bbd8184848a01612557565b8554920191600090612bce81612938565b60018281168015612be65760018114612bfb57612c27565b60ff1984168752821515830287019450612c27565b896000528560002060005b84811015612c1f57815489820152908301908701612c06565b505082870194505b50929a9950505050505050505050565b8181038181111561081557610815612ae7565b600082612c5957612c59612b2d565b500690565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612c919083018461257b565b9695505050505050565b600060208284031215612cad57600080fd5b815161178d8161252456fea2646970667358221220f710e1cf8aa480c923063f1333a599cf3ab7e1f6cdd051329ef1594e6b6f3a2364736f6c63430008110033

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

00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002710000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000000a522e4c2e412043697479000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003524c410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004368747470733a2f2f697066732e696f2f697066732f516d506b61756b354e4d54733154684a327a6e354a79594c4b79575a713348637142337a455a7266473772324c580000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _tokenName (string): R.L.A City
Arg [1] : _tokenSymbol (string): RLA
Arg [2] : _Cost (uint256): 0
Arg [3] : _MaxSupply (uint256): 10000
Arg [4] : _MaxMintAmountPerTx (uint256): 1
Arg [5] : _MaxPerWallet (uint256): 1
Arg [6] : _HiddenMetadataUri (string): https://ipfs.io/ipfs/QmPkauk5NMTs1ThJ2zn5JyYLKyWZq3HcqB3zEZrfG7r2LX

-----Encoded View---------------
15 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [8] : 522e4c2e41204369747900000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [10] : 524c410000000000000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [12] : 68747470733a2f2f697066732e696f2f697066732f516d506b61756b354e4d54
Arg [13] : 733154684a327a6e354a79594c4b79575a713348637142337a455a7266473772
Arg [14] : 324c580000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

67481:7393: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;:::-;;67884:33;;;;;;;;;;;;;;;;;;;2324:25:1;;;2312:2;2297:18;67884:33:0;2178:177:1;72468:104:0;;;;;;;;;;-1:-1:-1;72468:104:0;;;;;:::i;:::-;;:::i;72582:81::-;;;;;;;;;;-1:-1:-1;72582:81:0;;;;;:::i;:::-;;:::i;48888:303::-;;;;;;;;;;-1:-1:-1;71142:1:0;49142:12;48932:7;49126:13;:28;-1:-1:-1;;49126:46:0;48888:303;;72904:158;;;;;;;;;;-1:-1:-1;72904:158:0;;;;;:::i;:::-;;:::i;67614:25::-;;;;;;;;;;;;;;;;73074:173;;;;;;;;;;-1:-1:-1;73074:173:0;;;;;:::i;:::-;;:::i;70157:885::-;;;;;;;;;;-1:-1:-1;70157:885:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;71733:78::-;;;;;;;;;;-1:-1:-1;71733:78:0;;;;;:::i;:::-;;:::i;67783:31::-;;;;;;;;;;;;;:::i;72208:136::-;;;;;;;;;;-1:-1:-1;72208:136:0;;;;;:::i;:::-;;:::i;68040:28::-;;;;;;;;;;-1:-1:-1;68040:28:0;;;;;;;;;;;67743:33;;;;;;;;;;;;;:::i;67962:25::-;;;;;;;;;;-1:-1:-1;67962:25:0;;;;;;;;67708:28;;;;;;;;;;;;;:::i;52560:125::-;;;;;;;;;;-1:-1:-1;52560:125:0;;;;;:::i;:::-;;:::i;67994:39::-;;;;;;;;;;-1:-1:-1;67994:39:0;;;;;;;;;;;71821:102;;;;;;;;;;-1:-1:-1;71821:102:0;;;;;:::i;:::-;;:::i;50008:206::-;;;;;;;;;;-1:-1:-1;50008:206:0;;;;;:::i;:::-;;:::i;27397:103::-;;;;;;;;;;;;;:::i;72673:102::-;;;;;;;;;;-1:-1:-1;72673:102:0;;;;;:::i;:::-;;:::i;72354:104::-;;;;;;;;;;-1:-1:-1;72354:104:0;;;;;:::i;:::-;;:::i;73496:1255::-;;;:::i;67924:27::-;;;;;;;;;;;;;;;;26746:87;;;;;;;;;;-1:-1:-1;26819:6:0;;-1:-1:-1;;;;;26819:6:0;26746:87;;52921:104;;;;;;;;;;;;;:::i;69788:220::-;;;;;;:::i;:::-;;:::i;54531:287::-;;;;;;;;;;-1:-1:-1;54531:287:0;;;;;:::i;:::-;;:::i;71933:134::-;;;;;;;;;;-1:-1:-1;71933:134:0;;;;;:::i;:::-;;:::i;67853:24::-;;;;;;;;;;;;;;;;72785:109;;;;;;;;;;-1:-1:-1;72785:109:0;;;;;:::i;:::-;;:::i;73261:224::-;;;;;;;;;;-1:-1:-1;73261:224:0;;;;;:::i;:::-;;:::i;71161:467::-;;;;;;;;;;-1:-1:-1;71161:467:0;;;;;:::i;:::-;;:::i;69065:713::-;;;;;;:::i;:::-;;:::i;70020:126::-;;;;;;;;;;-1:-1:-1;70020:126:0;;;;;:::i;:::-;;:::i;67646:51::-;;;;;;;;;;-1:-1:-1;67646:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;71638:85;;;;;;;;;;-1:-1:-1;71638:85:0;;;;;:::i;:::-;;:::i;72077:121::-;;;;;;;;;;-1:-1:-1;72077:121:0;;;;;:::i;:::-;;:::i;54889:164::-;;;;;;;;;;-1:-1:-1;54889:164:0;;;;;:::i;:::-;;:::i;27655:201::-;;;;;;;;;;-1:-1:-1;27655:201:0;;;;;:::i;:::-;;:::i;67827: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;72468:104::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;;;;;;;;;72542:9:::1;:22;72554:10:::0;72542:9;:22:::1;:::i;:::-;;72468:104:::0;:::o;72582:81::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72640:6:::1;:15:::0;;-1:-1:-1;;72640:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;72582:81::o;72904: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;73016:37:::1;73035:4;73041:2;73045:7;73016:18;:37::i;73074: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;73190:41:::1;73213:4;73219:2;73223:7;73190:22;:41::i;70157:885::-:0;70217:16;70244:23;70270:17;70280:6;70270:9;:17::i;:::-;70244:43;;70296:30;70343:15;-1:-1:-1;;;;;70329:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70329:30:0;-1:-1:-1;70296:63:0;-1:-1:-1;71142:1:0;70368:22;;70492:510;70517:15;70499;:33;:67;;;;;70553:13;;70536:14;:30;70499:67;70492:510;;;70579:31;70613:27;;;:11;:27;;;;;;;;;70579:61;;;;;;;;;-1:-1:-1;;;;;70579:61:0;;;;-1:-1:-1;;;70579:61:0;;-1:-1:-1;;;;;70579:61:0;;;;;;;;-1:-1:-1;;;70579:61:0;;;;;;;;;;;;;;70655:307;;70695:14;;-1:-1:-1;;;;;70695:28:0;;70691:98;;70761:14;;;-1:-1:-1;70691:98:0;70831:6;-1:-1:-1;;;;;70809:28:0;:18;-1:-1:-1;;;;;70809:28:0;;70805:146;;70887:14;70854:13;70868:15;70854:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;70920:17;;;;:::i;:::-;;;;70805:146;70976:16;;;;:::i;:::-;;;;70568:434;70492:510;;;-1:-1:-1;71021:13:0;;70157:885;-1:-1:-1;;;;;70157:885:0:o;71733:78::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;71791:4:::1;:12:::0;71733:78::o;67783:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;72208:136::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72298:17:::1;:38;72318:18:::0;72298:17;:38:::1;:::i;67743:33::-:0;;;;;;;:::i;67708:28::-;;;;;;;:::i;52560:125::-;52624:7;52651:21;52664:7;52651:12;:21::i;:::-;:26;;52560:125;-1:-1:-1;;52560:125:0:o;71821:102::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;71891:9:::1;:22:::0;71821: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;72673:102::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72743:10:::1;:24:::0;72673:102::o;72354:104::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72428:9:::1;:22;72440:10:::0;72428:9;:22:::1;:::i;73496:1255::-: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;73588:21:::2;73570:15;73659:3;73644:12;73588:21:::0;73654:2:::2;73644:12;:::i;:::-;:18;;;;:::i;:::-;73620:42:::0;-1:-1:-1;73673:22:0::2;73713:3;73698:12;:7:::0;73708:2:::2;73698:12;:::i;:::-;:18;;;;:::i;:::-;73673:43:::0;-1:-1:-1;73727:24:0::2;73768:3;73754:11;:7:::0;73764:1:::2;73754:11;:::i;:::-;:17;;;;:::i;:::-;73727:44:::0;-1:-1:-1;73782:25:0::2;73825:3;73810:12;:7:::0;73820:2:::2;73810:12;:::i;:::-;:18;;;;:::i;:::-;73782:46:::0;-1:-1:-1;73839:18:0::2;73874:3;73860:11;:7:::0;73870:1:::2;73860:11;:::i;:::-;:17;;;;:::i;:::-;73913:82;::::0;73839:38;;-1:-1:-1;73890:17:0::2;::::0;73921:42:::2;::::0;73977:13;;73890:17;73913:82;73890:17;73913:82;73977:13;73921:42;73913:82:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;74036:83:0::2;::::0;73888:107;;-1:-1:-1;74008:22:0::2;::::0;74044:42:::2;::::0;74100:14;;74008:22;74036:83;74008:22;74036:83;74100:14;74044:42;74036:83:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;74160:85:0::2;::::0;74006:113;;-1:-1:-1;74132:22:0::2;::::0;74168:42:::2;::::0;74224:16;;74132:22;74160:85;74132:22;74160:85;74224:16;74168:42;74160:85:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;74287:86:0::2;::::0;74130:115;;-1:-1:-1;74258:23:0::2;::::0;74295:42:::2;::::0;74351:17;;74258:23;74287:86;74258:23;74287:86;74351:17;74295:42;74287:86:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;74408:79:0::2;::::0;74256:117;;-1:-1:-1;74386:16:0::2;::::0;74416:42:::2;::::0;74472:10;;74386:16;74408:79;74386:16;74408:79;74472:10;74416:42;74408:79:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74384:103;;;74500:25;74539:7;26819:6:::0;;-1:-1:-1;;;;;26819:6:0;;26746:87;74539:7:::2;-1:-1:-1::0;;;;;74531:21:0::2;74560;74531:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74498:88;;;74605:12;:33;;;;;74621:17;74605:33;:54;;;;;74642:17;74605:54;:76;;;;;74663:18;74605:76;:91;;;;;74685:11;74605:91;:115;;;;;74700:20;74605:115;74597:144;;;::::0;-1:-1:-1;;;74597:144:0;;12801:2:1;74597:144:0::2;::::0;::::2;12783:21:1::0;12840:2;12820:18;;;12813:30;-1:-1:-1;;;12859:18:1;;;12852:46;12915:18;;74597:144:0::2;12599:340:1::0;74597:144:0::2;-1:-1:-1::0;;19287:1:0::1;20241:7;:22:::0;-1:-1:-1;;;;;;;;;;73496:1255:0:o;52921:104::-;52977:13;53010:7;53003:14;;;;;:::i;69788:220::-;69853:11;68645:1;68631:11;:15;:52;;;;;68665:18;;68650:11;:33;;68631:52;68623:85;;;;-1:-1:-1;;;68623:85:0;;13146:2:1;68623:85:0;;;13128:21:1;13185:2;13165:18;;;13158:30;-1:-1:-1;;;13204:18:1;;;13197:50;13264:18;;68623:85:0;12944:344:1;68623:85:0;68756:9;;71142:1;49142:12;48932:7;49126:13;68741:11;;49126:28;;-1:-1:-1;;49126:46:0;68725:27;;;;:::i;:::-;:40;;68717:73;;;;-1:-1:-1;;;68717:73:0;;13625:2:1;68717:73:0;;;13607:21:1;13664:2;13644:18;;;13637:30;-1:-1:-1;;;13683:18:1;;;13676:50;13743:18;;68717:73:0;13423:344:1;68717:73:0;68846:12;;68831:11;68807:21;68817:10;68807:9;:21::i;:::-;:35;;;;:::i;:::-;:51;;68799:88;;;;-1:-1:-1;;;68799:88:0;;13974:2:1;68799:88:0;;;13956:21:1;14013:2;13993:18;;;13986:30;-1:-1:-1;;;14032:18:1;;;14025:54;14096:18;;68799:88:0;13772:348:1;68799:88:0;69886:11:::1;69002;68995:4;;:18;;;;:::i;:::-;68982:9;:31;;68974:63;;;;-1:-1:-1::0;;;68974:63:0::1;;;;;;;:::i;:::-;69917:6:::2;::::0;::::2;;69916:7;69908:43;;;::::0;-1:-1:-1;;;69908:43:0;;14675:2:1;69908:43:0::2;::::0;::::2;14657:21:1::0;14714:2;14694:18;;;14687:30;14753:25;14733:18;;;14726:53;14796:18;;69908:43:0::2;14473:347:1::0;69908:43:0::2;69964:36;25550:10:::0;69988:11:::2;69964: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;71933:134::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72019:18:::1;:40:::0;71933:134::o;72785:109::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72857:20:::1;:29:::0;;;::::1;;;;-1:-1:-1::0;;72857:29:0;;::::1;::::0;;;::::1;::::0;;72785:109::o;73261: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;73430:47:::1;73453:4;73459:2;73463:7;73472:4;73430:22;:47::i;:::-;73261:224:::0;;;;:::o;71161:467::-;71235:13;71267:17;71275:8;71267:7;:17::i;:::-;71259:77;;;;-1:-1:-1;;;71259:77:0;;15027:2:1;71259: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;;71259:77:0;14825:411:1;71259:77:0;71353:8;;;;;;;:17;;71365:5;71353:17;71349:68;;71390:17;71383:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71161:467;;;:::o;71349:68::-;71429:28;71460:10;:8;:10::i;:::-;71429:41;;71517:1;71492:14;71486:28;:32;:134;;;;;;;;;;;;;;;;;71556:14;71572:19;:8;:17;:19::i;:::-;71593:9;71539:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71486:134;71479:141;71161:467;-1:-1:-1;;;71161:467:0:o;69065:713::-;69172:11;68645:1;68631:11;:15;:52;;;;;68665:18;;68650:11;:33;;68631:52;68623:85;;;;-1:-1:-1;;;68623:85:0;;13146:2:1;68623:85:0;;;13128:21:1;13185:2;13165:18;;;13158:30;-1:-1:-1;;;13204:18:1;;;13197:50;13264:18;;68623:85:0;12944:344:1;68623:85:0;68756:9;;71142:1;49142:12;48932:7;49126:13;68741:11;;49126:28;;-1:-1:-1;;49126:46:0;68725:27;;;;:::i;:::-;:40;;68717:73;;;;-1:-1:-1;;;68717:73:0;;13625:2:1;68717:73:0;;;13607:21:1;13664:2;13644:18;;;13637:30;-1:-1:-1;;;13683:18:1;;;13676:50;13743:18;;68717:73:0;13423:344:1;68717:73:0;68846:12;;68831:11;68807:21;68817:10;68807:9;:21::i;:::-;:35;;;;:::i;:::-;:51;;68799:88;;;;-1:-1:-1;;;68799:88:0;;13974:2:1;68799:88:0;;;13956:21:1;14013:2;13993:18;;;13986:30;-1:-1:-1;;;14032:18:1;;;14025:54;14096:18;;68799:88:0;13772:348:1;68799:88:0;69205:11:::1;69002;68995:4;;:18;;;;:::i;:::-;68982:9;:31;;68974:63;;;;-1:-1:-1::0;;;68974:63:0::1;;;;;;;:::i;:::-;25550:10:::0;69227:17:::2;69247:30:::0;;;:16:::2;:30;::::0;;;;;69294:20:::2;::::0;::::2;::::0;::::2;;;69286:67;;;::::0;-1:-1:-1;;;69286:67:0;;16704:2:1;69286: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;;69286:67:0::2;16502:398:1::0;69286:67:0::2;69397:18;::::0;69370:23:::2;69382:11:::0;69370:9;:23:::2;:::i;:::-;:45;;69362:82;;;::::0;-1:-1:-1;;;69362:82:0;;17107:2:1;69362:82:0::2;::::0;::::2;17089:21:1::0;17146:2;17126:18;;;17119:30;17185:26;17165:18;;;17158:54;17229:18;;69362:82:0::2;16905:348:1::0;69362:82:0::2;69478:30;::::0;-1:-1:-1;;25550:10:0;17407:2:1;17403:15;17399:53;69478:30:0::2;::::0;::::2;17387:66:1::0;69453:12:0::2;::::0;17469::1;;69478:30:0::2;;;;;;;;;;;;69468:41;;;;;;69453:56;;69526:50;69545:12;;69526:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;69559:10:0::2;::::0;;-1:-1:-1;69571:4:0;;-1:-1:-1;69526:18:0::2;:50::i;:::-;69518:77;;;::::0;-1:-1:-1;;;69518:77:0;;17694:2:1;69518: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;;69518:77:0::2;17492:338:1::0;69518:77:0::2;69632:11;69625:4;;:18;;;;:::i;:::-;69612:9;:31;;69604:63;;;;-1:-1:-1::0;;;69604:63:0::2;;;;;;;:::i;:::-;25550:10:::0;69680:30:::2;::::0;;;:16:::2;:30;::::0;;;;:45;;69714:11;;69680:30;:45:::2;::::0;69714:11;;69680:45:::2;:::i;:::-;::::0;;;-1:-1:-1;69734:36:0::2;::::0;-1:-1:-1;25550:10:0;69758:11:::2;69734:9;:36::i;:::-;69218:560;;68896:1:::1;69065:713:::0;;;;:::o;70020:126::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;70105:33:::1;70115:9;70126:11;70105:9;:33::i;71638:85::-:0;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;71698:8:::1;:17:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;71698:17:0;;::::1;::::0;;;::::1;::::0;;71638:85::o;72077:121::-;26819:6;;-1:-1:-1;;;;;26819:6:0;25550:10;26966:23;26958:68;;;;-1:-1:-1;;;26958:68:0;;;;;;;:::i;:::-;72162:12:::1;:28:::0;72077: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;71142: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;;71142: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;;;;;;;;;;;74761:108;74821:13;74852:9;74845: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;73261: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;13293:125::-;13358:9;;;13379:10;;;13376:36;;;13392:18;;:::i;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://f710e1cf8aa480c923063f1333a599cf3ab7e1f6cdd051329ef1594e6b6f3a23

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