Token

UA3 The Real OG Pass ()

ERC-1155

Pass

Overview

Max Total Supply

333

Holders

111

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x488130618bf46cd904fdfe1e2f94d377d73f5eb9

Filtered by Token Holder

0x3de7bF799df670855235445874007b555FD590E2

0x3de7bf799df670855235445874007b555fd590e2

OVERVIEW

Private access to the inner circle of UA3, the only pass you will need.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

FlyingCopper

Compiler Version

v0.8.20+commit.a1b79de6

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-07
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(
        address registrant,
        address operator
    ) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(
        address registrant,
        address subscription
    ) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(
        address registrant,
        address registrantToCopy
    ) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(
        address registrant,
        address operator,
        bool filtered
    ) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(
        address registrant,
        address[] calldata operators,
        bool filtered
    ) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(
        address registrant,
        bytes32 codehash,
        bool filtered
    ) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(
        address registrant,
        bytes32[] calldata codeHashes,
        bool filtered
    ) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(
        address registrant,
        address registrantToSubscribe
    ) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(
        address registrant
    ) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(
        address registrant,
        uint256 index
    ) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(
        address registrant,
        address registrantToCopy
    ) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(
        address registrant,
        address operator
    ) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(
        address registrant,
        address operatorWithCode
    ) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(
        address registrant,
        bytes32 codeHash
    ) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(
        address addr
    ) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(
        address addr
    ) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(
        address registrant,
        uint256 index
    ) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(
        address registrant,
        uint256 index
    ) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

pragma solidity ^0.8.13;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

pragma solidity ^0.8.13;

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

    /// @dev The constructor that is called when the contract is being deployed.
    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(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(
                    address(this),
                    subscriptionOrRegistrantToCopy
                );
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(
                        address(this),
                        subscriptionOrRegistrantToCopy
                    );
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (
                !OPERATOR_FILTER_REGISTRY.isOperatorAllowed(
                    address(this),
                    operator
                )
            ) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

pragma solidity ^0.8.13;

/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 * @dev    Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    /// @dev The constructor that is called when the contract is being deployed.
    constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {}
}

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

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

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

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

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

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

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

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

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

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

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

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

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

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

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

// 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 (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(
        bytes memory returndata,
        string memory errorMessage
    ) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/utils/introspection/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/ERC1155/IERC1155Receiver.sol

// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(
        address account,
        uint256 id
    ) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(
        address account,
        address operator
    ) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC1155/ERC1155.sol

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(
        address account,
        uint256 id
    ) public view virtual override returns (uint256) {
        require(
            account != address(0),
            "ERC1155: address zero is not a valid owner"
        );
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    ) public view virtual override returns (uint256[] memory) {
        require(
            accounts.length == ids.length,
            "ERC1155: accounts and ids length mismatch"
        );

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(
        address operator,
        bool approved
    ) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        uint256 fromBalance = _balances[id][from];
        require(
            fromBalance >= amount,
            "ERC1155: insufficient balance for transfer"
        );
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(
            ids.length == amounts.length,
            "ERC1155: ids and amounts length mismatch"
        );
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(
                fromBalance >= amount,
                "ERC1155: insufficient balance for transfer"
            );
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            operator,
            from,
            to,
            ids,
            amounts,
            data
        );
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(
            operator,
            address(0),
            to,
            id,
            amount,
            data
        );
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(
            ids.length == amounts.length,
            "ERC1155: ids and amounts length mismatch"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            operator,
            address(0),
            to,
            ids,
            amounts,
            data
        );
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(address from, uint256 id, uint256 amount) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(
            ids.length == amounts.length,
            "ERC1155: ids and amounts length mismatch"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(
                fromBalance >= amount,
                "ERC1155: burn amount exceeds balance"
            );
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `ids` and `amounts` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155Received(
                    operator,
                    from,
                    id,
                    amount,
                    data
                )
            returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    amounts,
                    data
                )
            returns (bytes4 response) {
                if (
                    response != IERC1155Receiver.onERC1155BatchReceived.selector
                ) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non-ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(
        uint256 element
    ) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

        return (royalty.receiver, royaltyAmount);
    }

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

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

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

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

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

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

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

pragma solidity 0.8.20;

/// @title "Flying Copper" Token (ERC-1155)
/// @author @0xhammadghazi
/// @notice This contract allows for minting the "Flying Copper" with a maximum of 333 copies.
contract FlyingCopper is DefaultOperatorFilterer, Ownable, ERC2981, ERC1155 {
    using MerkleProof for bytes32[];

    /*//////////////////////////////////////////////////////////////
                           STATE VARIABLES
    //////////////////////////////////////////////////////////////*/

    // Maximum supply (copies) of "Flying Copper" token
    uint256 public constant MAX_SUPPLY = 333;

    // Token ID of "Flying Copper" token
    uint256 public constant TOKEN_ID = 1;

    // Price of each copy of "Flying Copper" token for both the whitelist and public phases
    uint256 public constant PRICE = 0.1 ether;

    // Mint phases
    enum MintPhase {
        NOT_LIVE, // Minting is not live yet
        WHITELIST_PHASE, // Mint is in the Whitelist phase
        PUBLIC_PHASE, // Mint is in the Public phase
        MINT_OVER // Minting is over
    }

    // Tracks the current mint phase
    MintPhase public mintPhase;

    // Tracks whether trading of the token is currently allowed or not
    bool public isTradingAllowed;

    // Stores merkle root to be used for whitelisting
    bytes32 public merkleRoot;

    // Tracks total minted supply (copies) of "Flying Copper" token
    uint256 public totalSupply;

    /*//////////////////////////////////////////////////////////////
                                EVENTS
    //////////////////////////////////////////////////////////////*/

    event EtherWithdrawn(address recipient, uint256 withdrawAmount);
    event MintPhaseChanged(MintPhase newMintPhase);
    event MerkleRootChanged(bytes32 newMerkleRoot);
    event URIChanged(string newURI);

    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/

    error AlreadyMinted();
    error IncorrectEth();
    error MerkleRootNotSet();
    error NotPublicPhase();
    error NotWhitelistPhase();
    error NotEligibleForWhitelistMint();
    error SameValueAsOld();
    error Sold();
    error TradingIsNotAllowed();
    error TransferFailed();
    error ZeroAddress();
    error ZeroBalance();

    /*//////////////////////////////////////////////////////////////
                               MODIFIER
    //////////////////////////////////////////////////////////////*/

    /// @notice Reverts if trading of the flying copper token is currently prohibited.
    modifier onlyIfTradingAllowed() {
        if (!isTradingAllowed) {
            revert TradingIsNotAllowed();
        }
        _;
    }

    /*//////////////////////////////////////////////////////////////
                             CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    /// @notice Constructor function to initialize the "Flying Copper" token with specified parameters.
    /// @param _royaltyReceiverAddress The address that will receive royalty payments from secondary sales.
    /// @param _royaltyPercentage The percentage of royalty to be paid on secondary sales (0-10000, where 10000 is 100%).
    /// @param _tokenURI URI of "Flying Copper" token.
    constructor(
        address _royaltyReceiverAddress,
        uint96 _royaltyPercentage,
        string memory _tokenURI
    ) ERC1155(_tokenURI) {
        // Reverts if '_royaltyReceiverAddress' is a zero address.
        if (_royaltyReceiverAddress == address(0)) {
            revert ZeroAddress();
        }

        // Set initial default royalty.
        _setDefaultRoyalty(_royaltyReceiverAddress, _royaltyPercentage);
    }

    /*//////////////////////////////////////////////////////////////
                           MINT FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Allows a whitelisted address to mint one copy of the "Flying Copper" token.
    /// @dev This function can only be called during the whitelist phase.
    /// @param _merkleProof The Merkle proof to verify the caller's whitelisted status.
    function whitelistMint(bytes32[] calldata _merkleProof) external payable {
        // Ensure mint is in the whitelist phase.
        if (mintPhase != MintPhase.WHITELIST_PHASE) {
            revert NotWhitelistPhase();
        }

        // Verify that the caller is whitelisted.
        if (
            !MerkleProof.verify(
                _merkleProof,
                merkleRoot,
                keccak256(abi.encodePacked(msg.sender))
            )
        ) {
            revert NotEligibleForWhitelistMint();
        }

        // Perform sanity checks and mint the token for the caller.
        _sanityCheckAndMint();
    }

    /// @notice Allows anyone to mint one copy of the "Flying Copper" token during the public minting phase.
    /// @dev This function can only be called during the public minting phase.
    function publicMint() external payable {
        // Ensure mint is in the public phase.
        if (mintPhase != MintPhase.PUBLIC_PHASE) {
            revert NotPublicPhase();
        }

        // Perform sanity checks and mint the token for the caller.
        _sanityCheckAndMint();
    }

    /// @dev Performs sanity checks and mints a token for the given caller.
    function _sanityCheckAndMint() private {
        // Ensure that the maximum supply has not been reached.
        if (totalSupply + 1 > MAX_SUPPLY) {
            revert Sold();
        }
        // Ensure that the correct amount of Ether is sent for the minting.
        if (msg.value != PRICE) {
            revert IncorrectEth();
        }

        // Ensure that the caller hasn't already minted the token.
        if (balanceOf(msg.sender, TOKEN_ID) == 1) {
            revert AlreadyMinted();
        }

        // Increment total minted copies.
        ++totalSupply;

        // Mint one copy of the "Flying Copper" token for the caller.
        _mint(msg.sender, TOKEN_ID, 1, "");
    }

    /*//////////////////////////////////////////////////////////////
                      OWNER RESTRICTED FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Switches the minting phase of the contract to a new phase.
    /// @dev This function can only be called by the contract owner.
    /// @param _newMintPhase The new minting phase to switch to.
    function switchMintPhase(MintPhase _newMintPhase) external onlyOwner {
        // Ensure the new minting phase is different from the current one.
        if (mintPhase == _newMintPhase) {
            revert SameValueAsOld();
        }

        // If the new mint phase is the whitelist phase, ensure that the Merkle root is already set.
        if (_newMintPhase == MintPhase.WHITELIST_PHASE) {
            if (merkleRoot == bytes32(0)) {
                revert MerkleRootNotSet();
            }
        }

        // Update the minting phase to the new phase.
        mintPhase = _newMintPhase;

        // Emit an event to signal the change in minting phase.
        emit MintPhaseChanged(_newMintPhase);
    }

    /// @notice Sets a new Merkle root for verifying whitelist status.
    /// @dev This function can only be called by the contract owner.
    /// @param _newMerkleRoot The new Merkle root to set.
    function setMerkleRoot(bytes32 _newMerkleRoot) external onlyOwner {
        // Ensure the new Merkle root is different from the current one.
        if (merkleRoot == _newMerkleRoot) {
            revert SameValueAsOld();
        }

        // Update the Merkle root to the new value.
        merkleRoot = _newMerkleRoot;

        // Emit an event to signal the change in the Merkle root.
        emit MerkleRootChanged(_newMerkleRoot);
    }

    /// @notice Sets a new URI for "Flying Copper" token.
    /// @dev This function can only be called by the contract owner.
    /// @param _newuri URL of the new URI.
    function setURI(string calldata _newuri) external onlyOwner {
        // Overwrites the old URI.
        _setURI(_newuri);

        emit URIChanged(_newuri);
    }

    /// @notice Flips the current trading status of the token.
    /// @dev This function can only be called by the owner of the contract.
    function flipTradingStatus() external onlyOwner {
        isTradingAllowed = !isTradingAllowed;
    }

    /// @notice Function to withdraw the contract's ether balance. Only the contract owner can call this function.
    /// @dev The contract must have a positive ether balance to execute the withdrawal.
    function withdrawEther() external onlyOwner {
        // Get the current contract's ether balance.
        uint256 contractBalance = address(this).balance;

        // Ensure there's ether balance to withdraw.
        if (contractBalance == 0) {
            revert ZeroBalance();
        }

        // Attempt to transfer the contract's ether balance to the contract owner.
        (bool success, ) = msg.sender.call{value: contractBalance}("");
        if (!success) {
            revert TransferFailed();
        }

        // Emit an event to log the ether withdrawal.
        emit EtherWithdrawn(msg.sender, contractBalance);
    }

    /*//////////////////////////////////////////////////////////////
                            ERC1155 FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    function setApprovalForAll(
        address operator,
        bool approved
    ) public override onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

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

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public override onlyIfTradingAllowed onlyAllowedOperator(from) {
        super.safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /*//////////////////////////////////////////////////////////////
                            ERC2891 FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Set the default royalty.
    /// @param receiver The address of the receiver for the royalty payments.
    /// @param feeNumerator The percentage of royalty to be paid to the receiver.
    /// @dev This function can only be called by the owner of the contract.
    function setDefaultRoyalty(
        address receiver,
        uint96 feeNumerator
    ) external onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    /// @notice Delete the default royalty for all tokens in the contract.
    /// @dev This function can only be called by the owner of the contract.
    function deleteDefaultRoyalty() external onlyOwner {
        _deleteDefaultRoyalty();
    }

    /*//////////////////////////////////////////////////////////////
                            ERC165 FUNCTION
    //////////////////////////////////////////////////////////////*/

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

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_royaltyReceiverAddress","type":"address"},{"internalType":"uint96","name":"_royaltyPercentage","type":"uint96"},{"internalType":"string","name":"_tokenURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyMinted","type":"error"},{"inputs":[],"name":"IncorrectEth","type":"error"},{"inputs":[],"name":"MerkleRootNotSet","type":"error"},{"inputs":[],"name":"NotEligibleForWhitelistMint","type":"error"},{"inputs":[],"name":"NotPublicPhase","type":"error"},{"inputs":[],"name":"NotWhitelistPhase","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"SameValueAsOld","type":"error"},{"inputs":[],"name":"Sold","type":"error"},{"inputs":[],"name":"TradingIsNotAllowed","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroBalance","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"withdrawAmount","type":"uint256"}],"name":"EtherWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"newMerkleRoot","type":"bytes32"}],"name":"MerkleRootChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"enum FlyingCopper.MintPhase","name":"newMintPhase","type":"uint8"}],"name":"MintPhaseChanged","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newURI","type":"string"}],"name":"URIChanged","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_ID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deleteDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipTradingStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isTradingAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPhase","outputs":[{"internalType":"enum FlyingCopper.MintPhase","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newMerkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setURI","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":[{"internalType":"enum FlyingCopper.MintPhase","name":"_newMintPhase","type":"uint8"}],"name":"switchMintPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawEther","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000fbab009a69608c5dcd1c3dee386175ed1900f05400000000000000000000000000000000000000000000000000000000000003e800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d58517674685876446456454c41514a6659746f3165415150375a6537475735326e4b74564a7747634144584a2f00000000000000000000

-----Decoded View---------------
Arg [0] : _royaltyReceiverAddress (address): 0xfbAB009a69608c5dCd1C3DEe386175eD1900F054
Arg [1] : _royaltyPercentage (uint96): 1000
Arg [2] : _tokenURI (string): ipfs://QmXQvthXvDdVELAQJfYto1eAQP7Ze7GW52nKtVJwGcADXJ/

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000fbab009a69608c5dcd1c3dee386175ed1900f054
Arg [1] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [4] : 697066733a2f2f516d58517674685876446456454c41514a6659746f31654151
Arg [5] : 50375a6537475735326e4b74564a7747634144584a2f00000000000000000000

Deployed Bytecode Sourcemap

69253:11608:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47504:292;;;;;;;;;;-1:-1:-1;47504:292:0;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;47504:292:0;;;;;;;;80671:187;;;;;;;;;;-1:-1:-1;80671:187:0;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;80671:187:0;1019::1;77276:168:0;;;;;;;;;;-1:-1:-1;77276:168:0;;;;;:::i;:::-;;:::i;:::-;;80051:171;;;;;;;;;;-1:-1:-1;80051:171:0;;;;;:::i;:::-;;:::i;47248:105::-;;;;;;;;;;-1:-1:-1;47248:105:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;70185:26::-;;;;;;;;;;-1:-1:-1;70185:26:0;;;;;;;;;;;;;;;:::i;70487:::-;;;;;;;;;;;;;;;;77593:103;;;;;;;;;;;;;:::i;74194:299::-;;;:::i;66427:476::-;;;;;;;;;;-1:-1:-1;66427:476:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3941:32:1;;;3923:51;;4005:2;3990:18;;3983:34;;;;3896:18;66427:476:0;3749:274:1;79258:315:0;;;;;;;;;;-1:-1:-1;79258:315:0;;;;;:::i;:::-;;:::i;70384:25::-;;;;;;;;;;;;;;;;69619:40;;;;;;;;;;;;69656:3;69619:40;;73346:650;;;;;;:::i;:::-;;:::i;8031:143::-;;;;;;;;;;;;6899:42;8031:143;;;;;-1:-1:-1;;;;;7836:32:1;;;7818:51;;7806:2;7791:18;8031:143:0;7641:234:1;47962:536:0;;;;;;;;;;-1:-1:-1;47962:536:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;24500:103::-;;;;;;;;;;;;;:::i;77909:652::-;;;;;;;;;;;;;:::i;76642:453::-;;;;;;;;;;-1:-1:-1;76642:453:0;;;;;:::i;:::-;;:::i;69710:36::-;;;;;;;;;;;;69745:1;69710:36;;69848:41;;;;;;;;;;;;69880:9;69848:41;;23859:87;;;;;;;;;;-1:-1:-1;23905:7:0;23932:6;-1:-1:-1;;;;;23932:6:0;23859:87;;78758:201;;;;;;;;;;-1:-1:-1;78758:201:0;;;;;:::i;:::-;;:::i;70292:28::-;;;;;;;;;;-1:-1:-1;70292:28:0;;;;;;;;;;;80383:93;;;;;;;;;;;;;:::i;75703:730::-;;;;;;;;;;-1:-1:-1;75703:730:0;;;;;:::i;:::-;;:::i;48823:193::-;;;;;;;;;;-1:-1:-1;48823:193:0;;;;;:::i;:::-;-1:-1:-1;;;;;48971:27:0;;;48947:4;48971:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;48823:193;78967:283;;;;;;;;;;-1:-1:-1;78967:283:0;;;;;:::i;:::-;;:::i;24758:238::-;;;;;;;;;;-1:-1:-1;24758:238:0;;;;;:::i;:::-;;:::i;47504:292::-;47615:7;-1:-1:-1;;;;;47657:21:0;;47635:113;;;;-1:-1:-1;;;47635:113:0;;12179:2:1;47635:113:0;;;12161:21:1;12218:2;12198:18;;;12191:30;12257:34;12237:18;;;12230:62;-1:-1:-1;;;12308:18:1;;;12301:40;12358:19;;47635:113:0;;;;;;;;;-1:-1:-1;47766:13:0;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;47766:22:0;;;;;;;;;;47504:292;;;;;:::o;80671:187::-;80790:4;80814:36;80838:11;80814:23;:36::i;77276:168::-;23745:13;:11;:13::i;:::-;77383:16:::1;77391:7;;77383:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;77383:7:0::1;::::0;-1:-1:-1;;;77383:16:0:i:1;:::-;77417:19;77428:7;;77417:19;;;;;;;:::i;:::-;;;;;;;;77276:168:::0;;:::o;80051:171::-;23745:13;:11;:13::i;:::-;80172:42:::1;80191:8;80201:12;80172:18;:42::i;:::-;80051:171:::0;;:::o;47248:105::-;47308:13;47341:4;47334:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47248:105;;;:::o;77593:103::-;23745:13;:11;:13::i;:::-;77672:16:::1;::::0;;-1:-1:-1;;77652:36:0;::::1;77672:16;::::0;;;::::1;;;77671:17;77652:36:::0;;::::1;;::::0;;77593:103::o;74194:299::-;74309:22;74296:9;;;;:35;;;;;;;;:::i;:::-;;74292:91;;74355:16;;-1:-1:-1;;;74355:16:0;;;;;;;;;;;74292:91;74464:21;:19;:21::i;:::-;74194:299::o;66427:476::-;66547:7;66605:26;;;:17;:26;;;;;;;;66576:55;;;;;;;;;-1:-1:-1;;;;;66576:55:0;;;;;-1:-1:-1;;;66576:55:0;;;-1:-1:-1;;;;;66576:55:0;;;;;;;;66547:7;;66644:92;;-1:-1:-1;66695:29:0;;;;;;;;;66705:19;66695:29;-1:-1:-1;;;;;66695:29:0;;;;-1:-1:-1;;;66695:29:0;;-1:-1:-1;;;;;66695:29:0;;;;;66644:92;66785:23;;;;66748:21;;67269:5;;66773:35;;-1:-1:-1;;;;;66773:35:0;:9;:35;:::i;:::-;66772:70;;;;:::i;:::-;66863:16;;;;;-1:-1:-1;66427:476:0;;-1:-1:-1;;;;66427:476:0:o;79258:315::-;71776:16;;;;;;;71771:78;;71816:21;;-1:-1:-1;;;71816:21:0;;;;;;;;;;;71771:78;79491:4;-1:-1:-1;;;;;9673:18:0;::::1;9681:10;9673:18;9669:83;;9708:32;9729:10;9708:20;:32::i;:::-;79508:57:::2;79536:4;79542:2;79546:3;79551:7;79560:4;79508:27;:57::i;:::-;71859:1:::1;79258:315:::0;;;;;:::o;73346:650::-;73498:25;73485:9;;;;:38;;;;;;;;:::i;:::-;;73481:97;;73547:19;;-1:-1:-1;;;73547:19:0;;;;;;;;;;;73481:97;73660:151;73697:12;;73660:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;73728:10:0;;73767:28;;-1:-1:-1;;73784:10:0;13844:2:1;13840:15;13836:53;73767:28:0;;;13824:66:1;73728:10:0;;-1:-1:-1;13906:12:1;;;-1:-1:-1;73767:28:0;;;;;;;;;;;;73757:39;;;;;;73660:18;:151::i;:::-;73641:245;;73845:29;;-1:-1:-1;;;73845:29:0;;;;;;;;;;;73641:245;73967:21;:19;:21::i;47962:536::-;48098:16;48168:3;:10;48149:8;:15;:29;48127:120;;;;-1:-1:-1;;;48127:120:0;;14131:2:1;48127:120:0;;;14113:21:1;14170:2;14150:18;;;14143:30;14209:34;14189:18;;;14182:62;-1:-1:-1;;;14260:18:1;;;14253:39;14309:19;;48127:120:0;13929:405:1;48127:120:0;48260:30;48307:8;:15;48293:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48293:30:0;;48260:63;;48341:9;48336:122;48360:8;:15;48356:1;:19;48336:122;;;48416:30;48426:8;48435:1;48426:11;;;;;;;;:::i;:::-;;;;;;;48439:3;48443:1;48439:6;;;;;;;;:::i;:::-;;;;;;;48416:9;:30::i;:::-;48397:13;48411:1;48397:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;48377:3;;;:::i;:::-;;;48336:122;;;-1:-1:-1;48477:13:0;47962:536;-1:-1:-1;;;47962:536:0:o;24500:103::-;23745:13;:11;:13::i;:::-;24565:30:::1;24592:1;24565:18;:30::i;77909:652::-:0;23745:13;:11;:13::i;:::-;78044:21:::1;78018:23;78136:20:::0;;;78132:73:::1;;78180:13;;-1:-1:-1::0;;;78180:13:0::1;;;;;;;;;;;78132:73;78320:43;::::0;78302:12:::1;::::0;78320:10:::1;::::0;78343:15;;78302:12;78320:43;78302:12;78320:43;78343:15;78320:10;:43:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78301:62;;;78379:7;78374:64;;78410:16;;-1:-1:-1::0;;;78410:16:0::1;;;;;;;;;;;78374:64;78510:43;::::0;;78525:10:::1;3923:51:1::0;;4005:2;3990:18;;3983:34;;;78510:43:0::1;::::0;3896:18:1;78510:43:0::1;3749:274:1::0;76642:453:0;23745:13;:11;:13::i;:::-;76811:14:::1;76797:10;;:28:::0;76793:84:::1;;76849:16;;-1:-1:-1::0;;;76849:16:0::1;;;;;;;;;;;76793:84;76942:10;:27:::0;;;77054:33:::1;::::0;597:25:1;;;77054:33:0::1;::::0;585:2:1;570:18;77054:33:0::1;;;;;;;;76642:453:::0;:::o;78758:201::-;78887:8;9947:30;9968:8;9947:20;:30::i;:::-;78908:43:::1;78932:8;78942;78908:23;:43::i;:::-;78758:201:::0;;;:::o;80383:93::-;23745:13;:11;:13::i;:::-;80445:23:::1;68091:19:::0;;68084:26;68023:95;75703:730;23745:13;:11;:13::i;:::-;75876::::1;75863:26;;;;;;;;:::i;:::-;:9;::::0;::::1;;:26;::::0;::::1;;;;;;:::i;:::-;::::0;75859:82:::1;;75913:16;;-1:-1:-1::0;;;75913:16:0::1;;;;;;;;;;;75859:82;76076:25;76059:13;:42;;;;;;;;:::i;:::-;::::0;76055:164:::1;;76122:10;::::0;76118:90:::1;;76174:18;;-1:-1:-1::0;;;76174:18:0::1;;;;;;;;;;;76118:90;76286:9;:25:::0;;76298:13;;76286:9;-1:-1:-1;;76286:25:0::1;::::0;76298:13;76286:25:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;76394:31;76411:13;76394:31;;;;;;:::i;78967:283::-:0;71776:16;;;;;;;71771:78;;71816:21;;-1:-1:-1;;;71816:21:0;;;;;;;;;;;71771:78;79175:4;-1:-1:-1;;;;;9673:18:0;::::1;9681:10;9673:18;9669:83;;9708:32;9729:10;9708:20;:32::i;:::-;79192:50:::2;79215:4;79221:2;79225;79229:6;79237:4;79192:22;:50::i;24758:238::-:0;23745:13;:11;:13::i;:::-;-1:-1:-1;;;;;24861:22:0;::::1;24839:110;;;::::0;-1:-1:-1;;;24839:110:0;;15023:2:1;24839:110:0::1;::::0;::::1;15005:21:1::0;15062:2;15042:18;;;15035:30;15101:34;15081:18;;;15074:62;-1:-1:-1;;;15152:18:1;;;15145:36;15198:19;;24839:110:0::1;14821:402:1::0;24839:110:0::1;24960:28;24979:8;24960:18;:28::i;:::-;24758:238:::0;:::o;46511:326::-;46629:4;-1:-1:-1;;;;;;46666:41:0;;-1:-1:-1;;;46666:41:0;;:110;;-1:-1:-1;;;;;;;46724:52:0;;-1:-1:-1;;;46724:52:0;46666:110;:163;;;;46793:36;46817:11;46793:23;:36::i;24024:132::-;23905:7;23932:6;-1:-1:-1;;;;;23932:6:0;22469:10;24088:23;24080:68;;;;-1:-1:-1;;;24080:68:0;;15430:2:1;24080:68:0;;;15412:21:1;;;15449:18;;;15442:30;15508:34;15488:18;;;15481:62;15560:18;;24080:68:0;15228:356:1;54007:88:0;54074:4;:13;54081:6;54074:4;:13;:::i;67553:394::-;67269:5;-1:-1:-1;;;;;67695:33:0;;;;67673:125;;;;-1:-1:-1;;;67673:125:0;;17995:2:1;67673:125:0;;;17977:21:1;18034:2;18014:18;;;18007:30;18073:34;18053:18;;;18046:62;-1:-1:-1;;;18124:18:1;;;18117:40;18174:19;;67673:125:0;17793:406:1;67673:125:0;-1:-1:-1;;;;;67817:22:0;;67809:60;;;;-1:-1:-1;;;67809:60:0;;18406:2:1;67809:60:0;;;18388:21:1;18445:2;18425:18;;;18418:30;18484:27;18464:18;;;18457:55;18529:18;;67809:60:0;18204:349:1;67809:60:0;67904:35;;;;;;;;;-1:-1:-1;;;;;67904:35:0;;;;;;-1:-1:-1;;;;;67904:35:0;;;;;;;;;;-1:-1:-1;;;67882:57:0;;;;:19;:57;67553:394::o;74578:713::-;69656:3;74697:11;;74711:1;74697:15;;;;:::i;:::-;:28;74693:74;;;74749:6;;-1:-1:-1;;;74749:6:0;;;;;;;;;;;74693:74;69880:9;74858;:18;74854:72;;74900:14;;-1:-1:-1;;;74900:14:0;;;;;;;;;;;74854:72;75010:31;75020:10;69745:1;75010:9;:31::i;:::-;75045:1;75010:36;75006:91;;75070:15;;-1:-1:-1;;;75070:15:0;;;;;;;;;;;75006:91;75154:11;;75152:13;;;;;:::i;:::-;;;;;;;;75249:34;75255:10;69745:1;75277;75249:34;;;;;;;;;;;;:5;:34::i;10090:740::-;6899:42;10281:45;:49;10277:546;;10598:128;;-1:-1:-1;;;10598:128:0;;10671:4;10598:128;;;18900:34:1;-1:-1:-1;;;;;18970:15:1;;18950:18;;;18943:43;6899:42:0;;10598;;18835:18:1;;10598:128:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10575:237;;10768:28;;-1:-1:-1;;;10768:28:0;;-1:-1:-1;;;;;7836:32:1;;10768:28:0;;;7818:51:1;7791:18;;10768:28:0;7641:234:1;49571:438:0;-1:-1:-1;;;;;49804:20:0;;22469:10;49804:20;;:60;;-1:-1:-1;49828:36:0;49845:4;22469:10;48823:193;:::i;49828:36::-;49782:156;;;;-1:-1:-1;;;49782:156:0;;;;;;;:::i;:::-;49949:52;49972:4;49978:2;49982:3;49987:7;49996:4;49949:22;:52::i;:::-;49571:438;;;;;:::o;12758:190::-;12883:4;12936;12907:25;12920:5;12927:4;12907:12;:25::i;:::-;:33;;12758:190;-1:-1:-1;;;;12758:190:0:o;25156:191::-;25230:16;25249:6;;-1:-1:-1;;;;;25266:17:0;;;-1:-1:-1;;;;;;25266:17:0;;;;;;25299:40;;25249:6;;;;;;;25299:40;;25230:16;25299:40;25219:128;25156:191;:::o;48571:180::-;48691:52;22469:10;48724:8;48734;48691:18;:52::i;49088:406::-;-1:-1:-1;;;;;49296:20:0;;22469:10;49296:20;;:60;;-1:-1:-1;49320:36:0;49337:4;22469:10;48823:193;:::i;49320:36::-;49274:156;;;;-1:-1:-1;;;49274:156:0;;;;;;;:::i;:::-;49441:45;49459:4;49465:2;49469;49473:6;49481:4;49441:17;:45::i;66115:257::-;66233:4;-1:-1:-1;;;;;;66270:41:0;;-1:-1:-1;;;66270:41:0;;:94;;-1:-1:-1;;;;;;;;;;37793:40:0;;;66328:36;37668:173;54481:818;-1:-1:-1;;;;;54634:16:0;;54626:62;;;;-1:-1:-1;;;54626:62:0;;19864:2:1;54626:62:0;;;19846:21:1;19903:2;19883:18;;;19876:30;19942:34;19922:18;;;19915:62;-1:-1:-1;;;19993:18:1;;;19986:31;20034:19;;54626:62:0;19662:397:1;54626:62:0;22469:10;54701:16;54766:21;54784:2;54766:17;:21::i;:::-;54743:44;;54798:24;54825:25;54843:6;54825:17;:25::i;:::-;54798:52;;54942:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;54942:17:0;;;;;;;;;:27;;54963:6;;54942:13;:27;;54963:6;;54942:27;:::i;:::-;;;;-1:-1:-1;;54985:52:0;;;20238:25:1;;;20294:2;20279:18;;20272:34;;;-1:-1:-1;;;;;54985:52:0;;;;55018:1;;54985:52;;;;;;20211:18:1;54985:52:0;;;;;;;55128:163;55173:8;55204:1;55221:2;55238;55255:6;55276:4;55128:30;:163::i;:::-;54615:684;;;54481:818;;;;:::o;51842:1321::-;52083:7;:14;52069:3;:10;:28;52047:118;;;;-1:-1:-1;;;52047:118:0;;20519:2:1;52047:118:0;;;20501:21:1;20558:2;20538:18;;;20531:30;20597:34;20577:18;;;20570:62;-1:-1:-1;;;20648:18:1;;;20641:38;20696:19;;52047:118:0;20317:404:1;52047:118:0;-1:-1:-1;;;;;52184:16:0;;52176:66;;;;-1:-1:-1;;;52176:66:0;;;;;;;:::i;:::-;22469:10;52255:16;52372:470;52396:3;:10;52392:1;:14;52372:470;;;52428:10;52441:3;52445:1;52441:6;;;;;;;;:::i;:::-;;;;;;;52428:19;;52462:14;52479:7;52487:1;52479:10;;;;;;;;:::i;:::-;;;;;;;;;;;;52506:19;52528:13;;;:9;:13;;;;;;-1:-1:-1;;;;;52528:19:0;;;;;;;;;;;;52479:10;;-1:-1:-1;52588:21:0;;;;52562:125;;;;-1:-1:-1;;;52562:125:0;;;;;;;:::i;:::-;52731:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;52731:19:0;;;;;;;;;;52753:20;;;52731:42;;52803:17;;;;;;;:27;;52753:20;;52731:13;52803:27;;52753:20;;52803:27;:::i;:::-;;;;;;;;52413:429;;;52408:3;;;;:::i;:::-;;;52372:470;;;;52889:2;-1:-1:-1;;;;;52859:47:0;52883:4;-1:-1:-1;;;;;52859:47:0;52873:8;-1:-1:-1;;;;;52859:47:0;;52893:3;52898:7;52859:47;;;;;;;:::i;:::-;;;;;;;;52991:164;53041:8;53064:4;53083:2;53100:3;53118:7;53140:4;52991:35;:164::i;13625:321::-;13733:7;13776:4;13733:7;13791:118;13815:5;:12;13811:1;:16;13791:118;;;13864:33;13874:12;13888:5;13894:1;13888:8;;;;;;;;:::i;:::-;;;;;;;13864:9;:33::i;:::-;13849:48;-1:-1:-1;13829:3:0;;;;:::i;:::-;;;;13791:118;;59161:331;59316:8;-1:-1:-1;;;;;59307:17:0;:5;-1:-1:-1;;;;;59307:17:0;;59299:71;;;;-1:-1:-1;;;59299:71:0;;22215:2:1;59299:71:0;;;22197:21:1;22254:2;22234:18;;;22227:30;22293:34;22273:18;;;22266:62;-1:-1:-1;;;22344:18:1;;;22337:39;22393:19;;59299:71:0;22013:405:1;59299:71:0;-1:-1:-1;;;;;59381:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;59381:46:0;;;;;;;;;;59443:41;;1159::1;;;59443::0;;1132:18:1;59443:41:0;;;;;;;59161:331;;;:::o;50473:1011::-;-1:-1:-1;;;;;50661:16:0;;50653:66;;;;-1:-1:-1;;;50653:66:0;;;;;;;:::i;:::-;22469:10;50732:16;50797:21;50815:2;50797:17;:21::i;:::-;50774:44;;50829:24;50856:25;50874:6;50856:17;:25::i;:::-;50829:52;;50967:19;50989:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;50989:19:0;;;;;;;;;;51041:21;;;;51019:113;;;;-1:-1:-1;;;51019:113:0;;;;;;;:::i;:::-;51168:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;51168:19:0;;;;;;;;;;51190:20;;;51168:42;;51232:17;;;;;;;:27;;51190:20;;51168:13;51232:27;;51190:20;;51232:27;:::i;:::-;;;;-1:-1:-1;;51277:46:0;;;20238:25:1;;;20294:2;20279:18;;20272:34;;;-1:-1:-1;;;;;51277:46:0;;;;;;;;;;;;;;20211:18:1;51277:46:0;;;;;;;51408:68;51439:8;51449:4;51455:2;51459;51463:6;51471:4;51408:30;:68::i;:::-;50642:842;;;;50473:1011;;;;;:::o;63743:214::-;63879:16;;;63893:1;63879:16;;;;;;;;;63825;;63854:22;;63879:16;;;;;;;;;;;;-1:-1:-1;63879:16:0;63854:41;;63917:7;63906:5;63912:1;63906:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;63944:5;63743:214;-1:-1:-1;;63743:214:0:o;61854:898::-;-1:-1:-1;;;;;62069:13:0;;27121:19;:23;62065:680;;62122:196;;-1:-1:-1;;;62122:196:0;;-1:-1:-1;;;;;62122:38:0;;;;;:196;;62183:8;;62214:4;;62241:2;;62266:6;;62295:4;;62122:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62122:196:0;;;;;;;;-1:-1:-1;;62122:196:0;;;;;;;;;;;;:::i;:::-;;;62101:633;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;62607:6;62600:14;;-1:-1:-1;;;62600:14:0;;;;;;;;:::i;62101:633::-;;;62656:62;;-1:-1:-1;;;62656:62:0;;24305:2:1;62656:62:0;;;24287:21:1;24344:2;24324:18;;;24317:30;24383:34;24363:18;;;24356:62;-1:-1:-1;;;24434:18:1;;;24427:50;24494:19;;62656:62:0;24103:416:1;62101:633:0;-1:-1:-1;;;;;;62381:55:0;;-1:-1:-1;;;62381:55:0;62377:154;;62461:50;;-1:-1:-1;;;62461:50:0;;;;;;;:::i;62760:975::-;-1:-1:-1;;;;;63000:13:0;;27121:19;:23;62996:732;;63053:203;;-1:-1:-1;;;63053:203:0;;-1:-1:-1;;;;;63053:43:0;;;;;:203;;63119:8;;63150:4;;63177:3;;63203:7;;63233:4;;63053:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63053:203:0;;;;;;;;-1:-1:-1;;63053:203:0;;;;;;;;;;;;:::i;:::-;;;63032:685;;;;:::i;:::-;-1:-1:-1;;;;;;63341:60:0;;-1:-1:-1;;;63341:60:0;63315:199;;63444:50;;-1:-1:-1;;;63444:50:0;;;;;;;:::i;21255:149::-;21318:7;21349:1;21345;:5;:51;;21505:13;21599:15;;;21635:4;21628:15;;;21682:4;21666:21;;21345:51;;;21505:13;21599:15;;;21635:4;21628:15;;;21682:4;21666:21;;21353:20;21338:58;21255:149;-1:-1:-1;;;21255:149:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;1211:592::-;1282:6;1290;1343:2;1331:9;1322:7;1318:23;1314:32;1311:52;;;1359:1;1356;1349:12;1311:52;1399:9;1386:23;1428:18;1469:2;1461:6;1458:14;1455:34;;;1485:1;1482;1475:12;1455:34;1523:6;1512:9;1508:22;1498:32;;1568:7;1561:4;1557:2;1553:13;1549:27;1539:55;;1590:1;1587;1580:12;1539:55;1630:2;1617:16;1656:2;1648:6;1645:14;1642:34;;;1672:1;1669;1662:12;1642:34;1717:7;1712:2;1703:6;1699:2;1695:15;1691:24;1688:37;1685:57;;;1738:1;1735;1728:12;1685:57;1769:2;1761:11;;;;;1791:6;;-1:-1:-1;1211:592:1;;-1:-1:-1;;;;1211:592:1:o;1808:366::-;1875:6;1883;1936:2;1924:9;1915:7;1911:23;1907:32;1904:52;;;1952:1;1949;1942:12;1904:52;1975:29;1994:9;1975:29;:::i;:::-;1965:39;;2054:2;2043:9;2039:18;2026:32;-1:-1:-1;;;;;2091:5:1;2087:38;2080:5;2077:49;2067:77;;2140:1;2137;2130:12;2067:77;2163:5;2153:15;;;1808:366;;;;;:::o;2179:180::-;2238:6;2291:2;2279:9;2270:7;2266:23;2262:32;2259:52;;;2307:1;2304;2297:12;2259:52;-1:-1:-1;2330:23:1;;2179:180;-1:-1:-1;2179:180:1:o;2364:423::-;2406:3;2444:5;2438:12;2471:6;2466:3;2459:19;2496:1;2506:162;2520:6;2517:1;2514:13;2506:162;;;2582:4;2638:13;;;2634:22;;2628:29;2610:11;;;2606:20;;2599:59;2535:12;2506:162;;;2510:3;2713:1;2706:4;2697:6;2692:3;2688:16;2684:27;2677:38;2776:4;2769:2;2765:7;2760:2;2752:6;2748:15;2744:29;2739:3;2735:39;2731:50;2724:57;;;2364:423;;;;:::o;2792:220::-;2941:2;2930:9;2923:21;2904:4;2961:45;3002:2;2991:9;2987:18;2979:6;2961:45;:::i;3017:127::-;3078:10;3073:3;3069:20;3066:1;3059:31;3109:4;3106:1;3099:15;3133:4;3130:1;3123:15;3149:342;3295:2;3280:18;;3328:1;3317:13;;3307:144;;3373:10;3368:3;3364:20;3361:1;3354:31;3408:4;3405:1;3398:15;3436:4;3433:1;3426:15;3307:144;3460:25;;;3149:342;:::o;3496:248::-;3564:6;3572;3625:2;3613:9;3604:7;3600:23;3596:32;3593:52;;;3641:1;3638;3631:12;3593:52;-1:-1:-1;;3664:23:1;;;3734:2;3719:18;;;3706:32;;-1:-1:-1;3496:248:1:o;4028:127::-;4089:10;4084:3;4080:20;4077:1;4070:31;4120:4;4117:1;4110:15;4144:4;4141:1;4134:15;4160:249;4270:2;4251:13;;-1:-1:-1;;4247:27:1;4235:40;;4305:18;4290:34;;4326:22;;;4287:62;4284:88;;;4352:18;;:::i;:::-;4388:2;4381:22;-1:-1:-1;;4160:249:1:o;4414:183::-;4474:4;4507:18;4499:6;4496:30;4493:56;;;4529:18;;:::i;:::-;-1:-1:-1;4574:1:1;4570:14;4586:4;4566:25;;4414:183::o;4602:724::-;4656:5;4709:3;4702:4;4694:6;4690:17;4686:27;4676:55;;4727:1;4724;4717:12;4676:55;4763:6;4750:20;4789:4;4812:43;4852:2;4812:43;:::i;:::-;4884:2;4878:9;4896:31;4924:2;4916:6;4896:31;:::i;:::-;4962:18;;;5054:1;5050:10;;;;5038:23;;5034:32;;;4996:15;;;;-1:-1:-1;5078:15:1;;;5075:35;;;5106:1;5103;5096:12;5075:35;5142:2;5134:6;5130:15;5154:142;5170:6;5165:3;5162:15;5154:142;;;5236:17;;5224:30;;5274:12;;;;5187;;5154:142;;;-1:-1:-1;5314:6:1;4602:724;-1:-1:-1;;;;;;4602:724:1:o;5331:555::-;5373:5;5426:3;5419:4;5411:6;5407:17;5403:27;5393:55;;5444:1;5441;5434:12;5393:55;5480:6;5467:20;5506:18;5502:2;5499:26;5496:52;;;5528:18;;:::i;:::-;5577:2;5571:9;5589:67;5644:2;5625:13;;-1:-1:-1;;5621:27:1;5650:4;5617:38;5571:9;5589:67;:::i;:::-;5680:2;5672:6;5665:18;5726:3;5719:4;5714:2;5706:6;5702:15;5698:26;5695:35;5692:55;;;5743:1;5740;5733:12;5692:55;5807:2;5800:4;5792:6;5788:17;5781:4;5773:6;5769:17;5756:54;5854:1;5830:15;;;5847:4;5826:26;5819:37;;;;5834:6;5331:555;-1:-1:-1;;;5331:555:1:o;5891:943::-;6045:6;6053;6061;6069;6077;6130:3;6118:9;6109:7;6105:23;6101:33;6098:53;;;6147:1;6144;6137:12;6098:53;6170:29;6189:9;6170:29;:::i;:::-;6160:39;;6218:38;6252:2;6241:9;6237:18;6218:38;:::i;:::-;6208:48;;6307:2;6296:9;6292:18;6279:32;6330:18;6371:2;6363:6;6360:14;6357:34;;;6387:1;6384;6377:12;6357:34;6410:61;6463:7;6454:6;6443:9;6439:22;6410:61;:::i;:::-;6400:71;;6524:2;6513:9;6509:18;6496:32;6480:48;;6553:2;6543:8;6540:16;6537:36;;;6569:1;6566;6559:12;6537:36;6592:63;6647:7;6636:8;6625:9;6621:24;6592:63;:::i;:::-;6582:73;;6708:3;6697:9;6693:19;6680:33;6664:49;;6738:2;6728:8;6725:16;6722:36;;;6754:1;6751;6744:12;6722:36;;6777:51;6820:7;6809:8;6798:9;6794:24;6777:51;:::i;:::-;6767:61;;;5891:943;;;;;;;;:::o;7021:615::-;7107:6;7115;7168:2;7156:9;7147:7;7143:23;7139:32;7136:52;;;7184:1;7181;7174:12;7136:52;7224:9;7211:23;7253:18;7294:2;7286:6;7283:14;7280:34;;;7310:1;7307;7300:12;7280:34;7348:6;7337:9;7333:22;7323:32;;7393:7;7386:4;7382:2;7378:13;7374:27;7364:55;;7415:1;7412;7405:12;7364:55;7455:2;7442:16;7481:2;7473:6;7470:14;7467:34;;;7497:1;7494;7487:12;7467:34;7550:7;7545:2;7535:6;7532:1;7528:14;7524:2;7520:23;7516:32;7513:45;7510:65;;;7571:1;7568;7561:12;7880:1208;7998:6;8006;8059:2;8047:9;8038:7;8034:23;8030:32;8027:52;;;8075:1;8072;8065:12;8027:52;8115:9;8102:23;8144:18;8185:2;8177:6;8174:14;8171:34;;;8201:1;8198;8191:12;8171:34;8239:6;8228:9;8224:22;8214:32;;8284:7;8277:4;8273:2;8269:13;8265:27;8255:55;;8306:1;8303;8296:12;8255:55;8342:2;8329:16;8364:4;8387:43;8427:2;8387:43;:::i;:::-;8459:2;8453:9;8471:31;8499:2;8491:6;8471:31;:::i;:::-;8537:18;;;8625:1;8621:10;;;;8613:19;;8609:28;;;8571:15;;;;-1:-1:-1;8649:19:1;;;8646:39;;;8681:1;8678;8671:12;8646:39;8705:11;;;;8725:148;8741:6;8736:3;8733:15;8725:148;;;8807:23;8826:3;8807:23;:::i;:::-;8795:36;;8758:12;;;;8851;;;;8725:148;;;8892:6;-1:-1:-1;;8936:18:1;;8923:32;;-1:-1:-1;;8967:16:1;;;8964:36;;;8996:1;8993;8986:12;8964:36;;9019:63;9074:7;9063:8;9052:9;9048:24;9019:63;:::i;:::-;9009:73;;;7880:1208;;;;;:::o;9093:435::-;9146:3;9184:5;9178:12;9211:6;9206:3;9199:19;9237:4;9266:2;9261:3;9257:12;9250:19;;9303:2;9296:5;9292:14;9324:1;9334:169;9348:6;9345:1;9342:13;9334:169;;;9409:13;;9397:26;;9443:12;;;;9478:15;;;;9370:1;9363:9;9334:169;;;-1:-1:-1;9519:3:1;;9093:435;-1:-1:-1;;;;;9093:435:1:o;9533:261::-;9712:2;9701:9;9694:21;9675:4;9732:56;9784:2;9773:9;9769:18;9761:6;9732:56;:::i;10192:118::-;10278:5;10271:13;10264:21;10257:5;10254:32;10244:60;;10300:1;10297;10290:12;10315:315;10380:6;10388;10441:2;10429:9;10420:7;10416:23;10412:32;10409:52;;;10457:1;10454;10447:12;10409:52;10480:29;10499:9;10480:29;:::i;:::-;10470:39;;10559:2;10548:9;10544:18;10531:32;10572:28;10594:5;10572:28;:::i;10635:270::-;10708:6;10761:2;10749:9;10740:7;10736:23;10732:32;10729:52;;;10777:1;10774;10767:12;10729:52;10816:9;10803:23;10855:1;10848:5;10845:12;10835:40;;10871:1;10868;10861:12;10910:260;10978:6;10986;11039:2;11027:9;11018:7;11014:23;11010:32;11007:52;;;11055:1;11052;11045:12;11007:52;11078:29;11097:9;11078:29;:::i;:::-;11068:39;;11126:38;11160:2;11149:9;11145:18;11126:38;:::i;:::-;11116:48;;10910:260;;;;;:::o;11175:606::-;11279:6;11287;11295;11303;11311;11364:3;11352:9;11343:7;11339:23;11335:33;11332:53;;;11381:1;11378;11371:12;11332:53;11404:29;11423:9;11404:29;:::i;:::-;11394:39;;11452:38;11486:2;11475:9;11471:18;11452:38;:::i;:::-;11442:48;;11537:2;11526:9;11522:18;11509:32;11499:42;;11588:2;11577:9;11573:18;11560:32;11550:42;;11643:3;11632:9;11628:19;11615:33;11671:18;11663:6;11660:30;11657:50;;;11703:1;11700;11693:12;11657:50;11726:49;11767:7;11758:6;11747:9;11743:22;11726:49;:::i;11786:186::-;11845:6;11898:2;11886:9;11877:7;11873:23;11869:32;11866:52;;;11914:1;11911;11904:12;11866:52;11937:29;11956:9;11937:29;:::i;12388:390::-;12547:2;12536:9;12529:21;12586:6;12581:2;12570:9;12566:18;12559:34;12643:6;12635;12630:2;12619:9;12615:18;12602:48;12699:1;12670:22;;;12694:2;12666:31;;;12659:42;;;;12762:2;12741:15;;;-1:-1:-1;;12737:29:1;12722:45;12718:54;;12388:390;-1:-1:-1;12388:390:1:o;12783:380::-;12862:1;12858:12;;;;12905;;;12926:61;;12980:4;12972:6;12968:17;12958:27;;12926:61;13033:2;13025:6;13022:14;13002:18;12999:38;12996:161;;13079:10;13074:3;13070:20;13067:1;13060:31;13114:4;13111:1;13104:15;13142:4;13139:1;13132:15;12996:161;;12783:380;;;:::o;13168:127::-;13229:10;13224:3;13220:20;13217:1;13210:31;13260:4;13257:1;13250:15;13284:4;13281:1;13274:15;13300:168;13373:9;;;13404;;13421:15;;;13415:22;;13401:37;13391:71;;13442:18;;:::i;13473:217::-;13513:1;13539;13529:132;;13583:10;13578:3;13574:20;13571:1;13564:31;13618:4;13615:1;13608:15;13646:4;13643:1;13636:15;13529:132;-1:-1:-1;13675:9:1;;13473:217::o;14339:127::-;14400:10;14395:3;14391:20;14388:1;14381:31;14431:4;14428:1;14421:15;14455:4;14452:1;14445:15;14471:135;14510:3;14531:17;;;14528:43;;14551:18;;:::i;:::-;-1:-1:-1;14598:1:1;14587:13;;14471:135::o;15715:545::-;15817:2;15812:3;15809:11;15806:448;;;15853:1;15878:5;15874:2;15867:17;15923:4;15919:2;15909:19;15993:2;15981:10;15977:19;15974:1;15970:27;15964:4;15960:38;16029:4;16017:10;16014:20;16011:47;;;-1:-1:-1;16052:4:1;16011:47;16107:2;16102:3;16098:12;16095:1;16091:20;16085:4;16081:31;16071:41;;16162:82;16180:2;16173:5;16170:13;16162:82;;;16225:17;;;16206:1;16195:13;16162:82;;16436:1352;16562:3;16556:10;16589:18;16581:6;16578:30;16575:56;;;16611:18;;:::i;:::-;16640:97;16730:6;16690:38;16722:4;16716:11;16690:38;:::i;:::-;16684:4;16640:97;:::i;:::-;16792:4;;16856:2;16845:14;;16873:1;16868:663;;;;17575:1;17592:6;17589:89;;;-1:-1:-1;17644:19:1;;;17638:26;17589:89;-1:-1:-1;;16393:1:1;16389:11;;;16385:24;16381:29;16371:40;16417:1;16413:11;;;16368:57;17691:81;;16838:944;;16868:663;15662:1;15655:14;;;15699:4;15686:18;;-1:-1:-1;;16904:20:1;;;17022:236;17036:7;17033:1;17030:14;17022:236;;;17125:19;;;17119:26;17104:42;;17217:27;;;;17185:1;17173:14;;;;17052:19;;17022:236;;;17026:3;17286:6;17277:7;17274:19;17271:201;;;17347:19;;;17341:26;-1:-1:-1;;17430:1:1;17426:14;;;17442:3;17422:24;17418:37;17414:42;17399:58;17384:74;;17271:201;-1:-1:-1;;;;;17518:1:1;17502:14;;;17498:22;17485:36;;-1:-1:-1;16436:1352:1:o;18558:125::-;18623:9;;;18644:10;;;18641:36;;;18657:18;;:::i;18997:245::-;19064:6;19117:2;19105:9;19096:7;19092:23;19088:32;19085:52;;;19133:1;19130;19123:12;19085:52;19165:9;19159:16;19184:28;19206:5;19184:28;:::i;19247:410::-;19449:2;19431:21;;;19488:2;19468:18;;;19461:30;19527:34;19522:2;19507:18;;19500:62;-1:-1:-1;;;19593:2:1;19578:18;;19571:44;19647:3;19632:19;;19247:410::o;20726:401::-;20928:2;20910:21;;;20967:2;20947:18;;;20940:30;21006:34;21001:2;20986:18;;20979:62;-1:-1:-1;;;21072:2:1;21057:18;;21050:35;21117:3;21102:19;;20726:401::o;21132:406::-;21334:2;21316:21;;;21373:2;21353:18;;;21346:30;21412:34;21407:2;21392:18;;21385:62;-1:-1:-1;;;21478:2:1;21463:18;;21456:40;21528:3;21513:19;;21132:406::o;21543:465::-;21800:2;21789:9;21782:21;21763:4;21826:56;21878:2;21867:9;21863:18;21855:6;21826:56;:::i;:::-;21930:9;21922:6;21918:22;21913:2;21902:9;21898:18;21891:50;21958:44;21995:6;21987;21958:44;:::i;:::-;21950:52;21543:465;-1:-1:-1;;;;;21543:465:1:o;22423:561::-;-1:-1:-1;;;;;22720:15:1;;;22702:34;;22772:15;;22767:2;22752:18;;22745:43;22819:2;22804:18;;22797:34;;;22862:2;22847:18;;22840:34;;;22682:3;22905;22890:19;;22883:32;;;22645:4;;22932:46;;22958:19;;22950:6;22932:46;:::i;:::-;22924:54;22423:561;-1:-1:-1;;;;;;;22423:561:1:o;22989:249::-;23058:6;23111:2;23099:9;23090:7;23086:23;23082:32;23079:52;;;23127:1;23124;23117:12;23079:52;23159:9;23153:16;23178:30;23202:5;23178:30;:::i;23243:179::-;23278:3;23320:1;23302:16;23299:23;23296:120;;;23366:1;23363;23360;23345:23;-1:-1:-1;23403:1:1;23397:8;23392:3;23388:18;23296:120;23243:179;:::o;23427:671::-;23466:3;23508:4;23490:16;23487:26;23484:39;;;23427:671;:::o;23484:39::-;23550:2;23544:9;-1:-1:-1;;23615:16:1;23611:25;;23608:1;23544:9;23587:50;23666:4;23660:11;23690:16;23725:18;23796:2;23789:4;23781:6;23777:17;23774:25;23769:2;23761:6;23758:14;23755:45;23752:58;;;23803:5;;;;;23427:671;:::o;23752:58::-;23840:6;23834:4;23830:17;23819:28;;23876:3;23870:10;23903:2;23895:6;23892:14;23889:27;;;23909:5;;;;;;23427:671;:::o;23889:27::-;23993:2;23974:16;23968:4;23964:27;23960:36;23953:4;23944:6;23939:3;23935:16;23931:27;23928:69;23925:82;;;24000:5;;;;;;23427:671;:::o;23925:82::-;24016:57;24067:4;24058:6;24050;24046:19;24042:30;24036:4;24016:57;:::i;:::-;-1:-1:-1;24089:3:1;;23427:671;-1:-1:-1;;;;;23427:671:1:o;24524:404::-;24726:2;24708:21;;;24765:2;24745:18;;;24738:30;24804:34;24799:2;24784:18;;24777:62;-1:-1:-1;;;24870:2:1;24855:18;;24848:38;24918:3;24903:19;;24524:404::o;24933:827::-;-1:-1:-1;;;;;25330:15:1;;;25312:34;;25382:15;;25377:2;25362:18;;25355:43;25292:3;25429:2;25414:18;;25407:31;;;25255:4;;25461:57;;25498:19;;25490:6;25461:57;:::i;:::-;25566:9;25558:6;25554:22;25549:2;25538:9;25534:18;25527:50;25600:44;25637:6;25629;25600:44;:::i;:::-;25586:58;;25693:9;25685:6;25681:22;25675:3;25664:9;25660:19;25653:51;25721:33;25747:6;25739;25721:33;:::i;:::-;25713:41;24933:827;-1:-1:-1;;;;;;;;24933:827:1:o

Swarm Source

ipfs://95dce71ab206fa617187748c879b9c1a22eabb87fd8b33ebe907766815f4e14c

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