Token

Superlative Mutated Apes (SMAPE)

ERC-721

Overview

Max Total Supply

6,936 SMAPE

Holders

2,584

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x9fb2eeb75754815c5cc9092cd53549cea5dc404f

Filtered by Token Holder

0xE3ab00071a569D2cDd44b83e97027d044a336E71

Balance

3 SMAPE

0xe3ab00071a569d2cdd44b83e97027d044a336e71

OVERVIEW

The Superlative Mutated Apes is a collection of up to 8,888 Mutant Apes that can only be created by exposing an existing Superlative Ape to a Magic Serum or by minting a Mutant Slape in the public sale.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SUPERLATIVEMUTANTS

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, Unlicense license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-02-15
*/

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol


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

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

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

    /**
     * @dev 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++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = _efficientHash(computedHash, proofElement);
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = _efficientHash(proofElement, computedHash);
            }
        }
        return computedHash;
    }

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts v4.4.1 (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 be 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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/ERC1155.sol


// OpenZeppelin Contracts v4.4.1 (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: balance query for the zero address");
        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 owner nor 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: transfer caller is not owner nor 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);

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

        _afterTokenTransfer(operator, from, to, ids, amounts, 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);

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

        _afterTokenTransfer(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);

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

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

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * 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);

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

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

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * 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}.
     *
     * 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 a {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 `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 _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;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC1155/extensions/ERC1155Burnable.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burn(account, id, value);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        _burnBatch(account, ids, values);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/IERC721.sol


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/extensions/IERC721Metadata.sol


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

pragma solidity ^0.8.0;


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

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

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

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

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

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

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

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

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

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

        _balances[to] += 1;
        _owners[tokenId] = to;

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

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

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

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

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: slape.sol

pragma solidity ^0.8.0;



/*
  ______                                 __          _    _                       _                             
.' ____ \                               [  |        / |_ (_)                     / \                            
| (___ \_|__   _  _ .--.   .---.  _ .--. | |  ,--. `| |-'__  _   __  .---.      / _ \    _ .--.   .---.  .--.   
 _.____`.[  | | |[ '/'`\ \/ /__\\[ `/'`\]| | `'_\ : | | [  |[ \ [  ]/ /__\\    / ___ \  [ '/'`\ \/ /__\\( (`\]  
| \____) || \_/ |,| \__/ || \__., | |    | | // | |,| |, | | \ \/ / | \__.,  _/ /   \ \_ | \__/ || \__., `'.'.  
 \______.''.__.'_/| ;.__/  '.__.'[___]  [___]\'-;__/\__/[___] \__/   '.__.' |____| |____|| ;.__/  '.__.'[\__) ) 
                 [__|                                                                   [__|                        
*/


contract SUPERLATIVEAPES is ERC721, Ownable {
   
    using Strings for uint256;
    using Counters for Counters.Counter;

    string public baseURI;
    string public baseExtension = ".json";


    uint256 public maxTx = 5;
    uint256 public maxPreTx = 2;
    uint256 public maxSupply = 4444;
    uint256 public presaleSupply = 2400;
    uint256 public price = 0.069 ether;
   
   
    //December 16th 3AM GMT
    uint256 public presaleTime = 1639623600;
    //December 16th 11PM GMT 
    uint256 public presaleClose = 1639695600;

    //December 17th 3AM GMT
    uint256 public mainsaleTime = 1639710000;
   
    Counters.Counter private _tokenIdTracker;

    mapping (address => bool) public presaleWallets;
    mapping (address => uint256) public presaleWalletLimits;
    mapping (address => uint256) public mainsaleWalletLimits;


    modifier isMainsaleOpen
    {
         require(block.timestamp >= mainsaleTime);
         _;
    }
    modifier isPresaleOpen
    {
         require(block.timestamp >= presaleTime && block.timestamp <= presaleClose, "Presale closed!");
         _;
    }
   
    constructor(string memory _initBaseURI) ERC721("Superlative Apes", "SLAPE")
    {
        setBaseURI(_initBaseURI);
        for(uint256 i=0; i<80; i++)
        {
            _tokenIdTracker.increment();
            _safeMint(msg.sender, totalToken());
        }
        
    }
   
    function setPrice(uint256 newPrice) external onlyOwner  {
        price = newPrice;
    }
   
    function setMaxTx(uint newMax) external onlyOwner {
        maxTx = newMax;
    }

    function totalToken() public view returns (uint256) {
            return _tokenIdTracker.current();
    }

    function mainSale(uint8 mintTotal) public payable isMainsaleOpen
    {
        uint256 totalMinted = mintTotal + mainsaleWalletLimits[msg.sender];
        
        require(mintTotal >= 1 && mintTotal <= maxTx, "Mint Amount Incorrect");
        require(msg.value >= price * mintTotal, "Minting a SLAPE APE Costs 0.069 Ether Each!");
        require(totalToken() <= maxSupply, "SOLD OUT!");
        require(totalMinted <= maxTx, "You'll pass mint limit!");
       
        for(uint i=0;i<mintTotal;i++)
        {
            mainsaleWalletLimits[msg.sender]++;
            _tokenIdTracker.increment();
            require(totalToken() <= maxSupply, "SOLD OUT!");
            _safeMint(msg.sender, totalToken());
        }
    }
   
    function preSale(uint8 mintTotal) public payable isPresaleOpen
    {
        uint256 totalMinted = mintTotal + presaleWalletLimits[msg.sender];

        require(presaleWallets[msg.sender] == true, "You aren't whitelisted!");
        require(mintTotal >= 1 && mintTotal <= maxTx, "Mint Amount Incorrect");
        require(msg.value >= price * mintTotal, "Minting a SLAPE APE Costs 0.069 Ether Each!");
        require(totalToken() <= presaleSupply, "SOLD OUT!");
        require(totalMinted <= maxPreTx, "You'll pass mint limit!");
       
        for(uint i=0; i<mintTotal; i++)
        {
            presaleWalletLimits[msg.sender]++;
            _tokenIdTracker.increment();
            require(totalToken() <= presaleSupply, "SOLD OUT!");
            _safeMint(msg.sender, totalToken());
        }
       
    }
   
    function airdrop(address airdropPatricipent, uint8 tokenID) public payable onlyOwner
    {
        _transfer(address(this), airdropPatricipent, tokenID);
    }
   
    function addWhiteList(address[] memory whiteListedAddresses) public onlyOwner
    {
        for(uint256 i=0; i<whiteListedAddresses.length;i++)
        {
            presaleWallets[whiteListedAddresses[i]] = true;
        }
    }
    function isAddressWhitelisted(address whitelist) public view returns(bool)
    {
        return presaleWallets[whitelist];
    }
       
    function withdrawContractEther(address payable recipient) external onlyOwner
    {
        recipient.transfer(getBalance());
    }
   
    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }
   
    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }
   
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
    {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension)) : "";
    }
    function getBalance() public view returns(uint)
    {
        return address(this).balance;
    }
   

}
// File: serum.sol

pragma solidity 0.8.7;


contract SuperlativeMagicLaboratory is ERC1155Burnable, Ownable, ReentrancyGuard {

    using Strings for uint256;
    SUPERLATIVEAPES public slapeContract;

    string public baseURI;
    string public baseExtension = ".json";


    uint256 constant public MagicVialMaxReserve = 3333;
    uint256 constant public MagicHerbsMaxReserve = 1106;
    uint256 constant public MagicPotsMaxReserve = 5;

    uint256 public vialMinted;
    uint256 public herbsMinted;
    uint256 public potsMinted;


    bool public WhitelistOpen = false;

    mapping (address => uint256) public totalPresaleMinted;

    mapping (address => bool) public whitelistClaim;

    constructor(string memory _initBaseURI, address slapesAddress) ERC1155(_initBaseURI)
    {
        setBaseURI(_initBaseURI);
        slapeContract = SUPERLATIVEAPES(slapesAddress);

        vialMinted++;
        _mint(msg.sender, 1, 1, ""); 
    }

    function randomNum(uint256 _mod, uint256 _seed, uint256 _salt) internal view returns(uint256)
    {
        return uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, _seed, _salt))) % _mod;
    }

    modifier onlySender {
        require(msg.sender == tx.origin);
        _;
    }

    modifier isClaimOpen
    {
         require(WhitelistOpen == true);
         _;
    }

    function setClaimOpen() public onlyOwner
    {
        WhitelistOpen = !WhitelistOpen;
    }

    function Whitelist() public nonReentrant onlySender isClaimOpen
    {
        bool skipHerbs = false;
        bool skipPots = false;

        require(whitelistClaim[msg.sender] == false, "You have claimed already!");
        require(slapeContract.balanceOf(msg.sender) >= 1, "You dont have anything to claim");
        require((vialMinted < MagicVialMaxReserve || herbsMinted < MagicHerbsMaxReserve || potsMinted < MagicPotsMaxReserve) , "No serums left!");

        if(potsMinted >= MagicPotsMaxReserve)
        {
            skipPots = true;
        }
        else if(herbsMinted >= MagicHerbsMaxReserve)
        {
            skipHerbs = true;
        }

        for(uint256 i=0; i<slapeContract.balanceOf(msg.sender);i++)
        {      
            bool notMintedYet = false;
            while(!notMintedYet)
            {
                uint256 selectedSerum = randomNum(12, (block.timestamp * randomNum(1000, block.timestamp, block.timestamp) * i), (block.timestamp * randomNum(1000, block.timestamp, block.timestamp) * i));
                
                if(selectedSerum == 0 && !skipPots)
                {
                    notMintedYet = true;
                    potsMinted++;
                    _mint(msg.sender, 3, 1, "");                   
                }
                else if(selectedSerum >= 1 && selectedSerum <= 3 && !skipHerbs)
                {
                    notMintedYet = true;
                    herbsMinted++;
                    _mint(msg.sender, 2, 1, "");                   
                }
                else
                {
                    notMintedYet = true;
                    vialMinted++;
                    _mint(msg.sender, 1, 1, "");                  
                }
            }
        }

        whitelistClaim[msg.sender] = true;

    }

    function _withdraw(address payable address_, uint256 amount_) internal {
        (bool success, ) = payable(address_).call{value: amount_}("");
        require(success, "Transfer failed");
    }

    function withdrawEther() external onlyOwner {
        _withdraw(payable(msg.sender), address(this).balance);
    }

    function withdrawEtherTo(address payable to_) external onlyOwner {
        _withdraw(to_, address(this).balance);
    }

    function _baseURI() internal view virtual returns (string memory) {
        return baseURI;
    }
   
    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }
   
    function uri(uint256 tokenId) public view override virtual returns (string memory)
    {
        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension)) : "";
    }
}
// File: mutant.sol

pragma solidity ^0.8.0;








/// SPDX-License-Identifier: UNLICENSED

contract SUPERLATIVEMUTANTS is ERC721, Ownable, ReentrancyGuard {

    using Strings for uint256;
    using Counters for Counters.Counter;

    string public baseURI;
    string public baseExtension = ".json";

    Counters.Counter private _tokenIdTracker;

    SuperlativeMagicLaboratory public serumContract;
    SUPERLATIVEAPES public slapeContract;

    uint256 public preMaxTx = 5;
    uint256 public publicMaxTx = 10;
    uint256 public price = 0.15 ether;

    uint256 public maxPresaleSupply = 3000;
    uint256 public maxSupply = 4444;
    uint256 public potsUsed = 0;

    bytes32 public whitelistProof = '';

    mapping(address => uint256) totalMintedPre;
    mapping(address => uint256) totalMinted;
    mapping(uint256 => bool) public slapeMutated;


    bool public presaleOpen = false;
    bool public mainsaleOpen = false;
    bool public mutateOpen = false;

    constructor(string memory _initBaseURI, address serumAddress, address slapeAddress) ERC721("Superlative Mutated Apes", "SMAPE")
    {
        slapeContract = SUPERLATIVEAPES(slapeAddress);
        serumContract = SuperlativeMagicLaboratory(serumAddress);
        setBaseURI(_initBaseURI);

        for(uint256 i=0; i<50; i++)
        {
            _tokenIdTracker.increment();
            _safeMint(msg.sender, totalToken());
        }
    }

    modifier onlySender {
        require(msg.sender == tx.origin);
        _;
    }

    modifier isPresaleOpen
    {
         require(presaleOpen == true);
         _;
    }

    modifier isMainsaleOpen
    {
         require(mainsaleOpen == true);
         _;
    }

    modifier isMutateOpen
    {
         require(mutateOpen == true);
         _;
    }

    function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner
    {
        whitelistProof = _merkleRoot;
    }

    function setPresaleOpen() public onlyOwner
    {
        presaleOpen = !presaleOpen;
    }

    function setMainsaleOpen() public onlyOwner
    {
        mainsaleOpen = !mainsaleOpen;
    }

    function setMutateOpen() public onlyOwner
    {
        mutateOpen = !mutateOpen;
    }

    function setPreMaxTx(uint256 _max) public onlyOwner
    {
        preMaxTx = _max;
    }

    function setMainMaxTx(uint256 _max) public onlyOwner
    {
        publicMaxTx = _max;
    }

    function presaleMutant(bytes32[] calldata _merkleProof, uint256 amountToMint) public payable nonReentrant onlySender isPresaleOpen
    {
        require(msg.value >= (price * amountToMint), "Minting a Superlative Mutant 0.15 Ether Each!");
        require(amountToMint <= preMaxTx, "Max mint is 5");
        require((totalMintedPre[msg.sender] + amountToMint) <= preMaxTx, "You already minted 5");
        require((totalToken() + amountToMint) < maxPresaleSupply, "Surpassing presale supply!");

        bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
        require(MerkleProof.verify(_merkleProof, whitelistProof, leaf), "Invalid proof.");

        for(uint256 i=0; i<amountToMint; i++)
        {
            totalMintedPre[msg.sender] += 1;
            _tokenIdTracker.increment();
            _safeMint(msg.sender, totalToken());
        }
    }

    function mainsaleMutant(uint256 amountToMint) public payable nonReentrant onlySender isMainsaleOpen
    {
        require(msg.value >= (price * amountToMint), "Minting a Superlative Mutant 0.15 Ether Each!");
        require(amountToMint <= publicMaxTx, "Max mint is 10");
        require((totalMinted[msg.sender] + amountToMint) <= publicMaxTx);
        require((totalToken() + amountToMint) < maxSupply, "Surpassing supply!");

        for(uint256 i=0; i<amountToMint; i++)
        {
            totalMinted[msg.sender] += 1;
            _tokenIdTracker.increment();
            _safeMint(msg.sender, totalToken());
        }
    }

    function mutateSlape(uint256 slapeID , uint256 serumID) public nonReentrant onlySender isMutateOpen
    {
        require(slapeContract.ownerOf(slapeID) == msg.sender, "You don't own this slape");
        require(serumContract.balanceOf(msg.sender, serumID) >= 1, "You don't own this serum");
        require(slapeMutated[slapeID] == false, "Slape already mutated");


        if(serumID == 1)
        {
            slapeMutated[slapeID] = true;
            serumContract.burn(msg.sender, 1, 1);
            _tokenIdTracker.increment();
            _safeMint(msg.sender, (4444 + slapeID));
        }
        else if(serumID == 2)
        {
            slapeMutated[slapeID] = true;
            serumContract.burn(msg.sender, 2, 1);
            _tokenIdTracker.increment();
            _safeMint(msg.sender, (8888 + slapeID));
        }
        else if(serumID == 3)
        {
            slapeMutated[slapeID] = true;
            serumContract.burn(msg.sender, 3, 1);
            _tokenIdTracker.increment();
            potsUsed += 1;
            _safeMint(msg.sender, (13332 + potsUsed));
        }
    }

    function devMint(uint256 amountToMint) public onlyOwner
    {
        for(uint256 i=0; i<amountToMint; i++)
        {
            _tokenIdTracker.increment();
            _safeMint(msg.sender, totalToken());
        }
    }

    function setPrice(uint256 newPrice) external onlyOwner  {
        price = newPrice;
    }
   

    function totalToken() public view returns (uint256) {
            return _tokenIdTracker.current();
    }

    function totalSupply() public view returns (uint256) {
            return _tokenIdTracker.current();
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }
   
    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }
   
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
    {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

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

    function _withdraw(address payable address_, uint256 amount_) internal {
        (bool success, ) = payable(address_).call{value: amount_}("");
        require(success, "Transfer failed");
    }

    function withdrawEther() external onlyOwner {
        _withdraw(payable(msg.sender), address(this).balance);
    }

    function withdrawEtherTo(address payable to_) external onlyOwner {
        _withdraw(to_, address(this).balance);
    }

    function walletOfOwner(address address_) public virtual view returns (uint256[] memory) {
        uint256 _balance = balanceOf(address_);
        uint256[] memory _tokens = new uint256[] (_balance);
        uint256 _index;
        uint256 _loopThrough = totalSupply();
        for (uint256 i = 0; i < _loopThrough; i++) {
            bool _exists = _exists(i);
            if (_exists) {
                if (ownerOf(i) == address_) { _tokens[_index] = i; _index++; }
            }
            else if (!_exists && _tokens[_balance - 1] == 0) { _loopThrough++; }
        }
        return _tokens;
    }   
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_initBaseURI","type":"string"},{"internalType":"address","name":"serumAddress","type":"address"},{"internalType":"address","name":"slapeAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountToMint","type":"uint256"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountToMint","type":"uint256"}],"name":"mainsaleMutant","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mainsaleOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPresaleSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mutateOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"slapeID","type":"uint256"},{"internalType":"uint256","name":"serumID","type":"uint256"}],"name":"mutateSlape","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"potsUsed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preMaxTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"uint256","name":"amountToMint","type":"uint256"}],"name":"presaleMutant","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"presaleOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMaxTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"serumContract","outputs":[{"internalType":"contract SuperlativeMagicLaboratory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"setMainMaxTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setMainsaleOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setMutateOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"setPreMaxTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPresaleOpen","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"slapeContract","outputs":[{"internalType":"contract SUPERLATIVEAPES","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"slapeMutated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"address_","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistProof","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"to_","type":"address"}],"name":"withdrawEtherTo","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)

0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000c552292732f7a9a4a494da557b47bc01e01722df0000000000000000000000001e87ee9249cc647af9edeecb73d6b76af14d8c27000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d4e51684178456a346b5a6431556e67613544334a75314e5461574a38654e6b4c556b34514b4c6d32484338612f000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _initBaseURI (string): https://gateway.pinata.cloud/ipfs/QmNQhAxEj4kZd1Unga5D3Ju1NTaWJ8eNkLUk4QKLm2HC8a/
Arg [1] : serumAddress (address): 0xc552292732f7a9a4a494da557B47Bc01e01722df
Arg [2] : slapeAddress (address): 0x1e87eE9249Cc647Af9EDEecB73D6b76AF14d8C27

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 000000000000000000000000c552292732f7a9a4a494da557b47bc01e01722df
Arg [2] : 0000000000000000000000001e87ee9249cc647af9edeecb73d6b76af14d8c27
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [4] : 68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066
Arg [5] : 732f516d4e51684178456a346b5a6431556e67613544334a75314e5461574a38
Arg [6] : 654e6b4c556b34514b4c6d32484338612f000000000000000000000000000000

Deployed Bytecode Sourcemap

81186:7328:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57985:305;;;;;;;;;;-1:-1:-1;57985:305:0;;;;;:::i;:::-;;:::i;:::-;;;11395:14:1;;11388:22;11370:41;;11358:2;11343:18;57985:305:0;;;;;;;;58930:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;87765:121::-;;;;;;;;;;-1:-1:-1;87765:121:0;;;;;:::i;:::-;;:::i;:::-;;60490:221;;;;;;;;;;-1:-1:-1;60490:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8679:32:1;;;8661:51;;8649:2;8634:18;60490:221:0;8515:203:1;60013:411:0;;;;;;;;;;-1:-1:-1;60013:411:0;;;;;:::i;:::-;;:::i;81790:34::-;;;;;;;;;;;;;;;;;;;11568:25:1;;;11556:2;11541:18;81790:34:0;11422:177:1;81928:44:0;;;;;;;;;;-1:-1:-1;81928:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;86703:108;;;;;;;;;;;;;:::i;82021:32::-;;;;;;;;;;-1:-1:-1;82021:32:0;;;;;;;;;;;81671:38;;;;;;;;;;;;;;;;61240:339;;;;;;;;;;-1:-1:-1;61240:339:0;;;;;:::i;:::-;;:::i;86246:230::-;;;;;;;;;;-1:-1:-1;86246:230:0;;;;;:::i;:::-;;:::i;61650:185::-;;;;;;;;;;-1:-1:-1;61650:185:0;;;;;:::i;:::-;;:::i;87894:614::-;;;;;;;;;;-1:-1:-1;87894:614:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;81754:27::-;;;;;;;;;;;;;;;;86938:104;;;;;;;;;;-1:-1:-1;86938:104:0;;;;;:::i;:::-;;:::i;81591:31::-;;;;;;;;;;;;;;;;85103:1135;;;;;;;;;;-1:-1:-1;85103:1135:0;;;;;:::i;:::-;;:::i;83567:874::-;;;;;;:::i;:::-;;:::i;58624:239::-;;;;;;;;;;-1:-1:-1;58624:239:0;;;;;:::i;:::-;;:::i;83163:96::-;;;;;;;;;;;;;:::i;82060:30::-;;;;;;;;;;-1:-1:-1;82060:30:0;;;;;;;;;;;81335:21;;;;;;;;;;;;;:::i;58354:208::-;;;;;;;;;;-1:-1:-1;58354:208:0;;;;;:::i;:::-;;:::i;11957:103::-;;;;;;;;;;;;;:::i;87641:116::-;;;;;;;;;;;;;:::i;82941:113::-;;;;;;;;;;-1:-1:-1;82941:113:0;;;;;:::i;:::-;;:::i;83464:95::-;;;;;;;;;;-1:-1:-1;83464:95:0;;;;;:::i;:::-;;:::i;11306:87::-;;;;;;;;;;-1:-1:-1;11379:6:0;;-1:-1:-1;;;;;11379:6:0;11306:87;;86484:91;;;;;;;;;;-1:-1:-1;86484:91:0;;;;;:::i;:::-;;:::i;59099:104::-;;;;;;;;;;;;;:::i;83062:93::-;;;;;;;;;;;;;:::i;81629:33::-;;;;;;;;;;;;;;;;60783:155;;;;;;;;;;-1:-1:-1;60783:155:0;;;;;:::i;:::-;;:::i;61906:328::-;;;;;;;;;;-1:-1:-1;61906:328:0;;;;;:::i;:::-;;:::i;83365:91::-;;;;;;;;;;-1:-1:-1;83365:91:0;;;;;:::i;:::-;;:::i;81983:31::-;;;;;;;;;;-1:-1:-1;81983:31:0;;;;;;;;81557:27;;;;;;;;;;;;;;;;81363:37;;;;;;;;;;;;;:::i;87053:375::-;;;;;;;;;;-1:-1:-1;87053:375:0;;;;;:::i;:::-;;:::i;81716:31::-;;;;;;;;;;;;;;;;61009:164;;;;;;;;;;-1:-1:-1;61009:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;61130:25:0;;;61106:4;61130:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;61009:164;84449:646;;;;;;:::i;:::-;;:::i;81512:36::-;;;;;;;;;;-1:-1:-1;81512:36:0;;;;-1:-1:-1;;;;;81512:36:0;;;12215:201;;;;;;;;;;-1:-1:-1;12215:201:0;;;;;:::i;:::-;;:::i;81458:47::-;;;;;;;;;;-1:-1:-1;81458:47:0;;;;-1:-1:-1;;;;;81458:47:0;;;83267:90;;;;;;;;;;;;;:::i;57985:305::-;58087:4;-1:-1:-1;;;;;;58124:40:0;;-1:-1:-1;;;58124:40:0;;:105;;-1:-1:-1;;;;;;;58181:48:0;;-1:-1:-1;;;58181:48:0;58124:105;:158;;;-1:-1:-1;;;;;;;;;;32029:40:0;;;58246:36;58104:178;57985:305;-1:-1:-1;;57985:305:0:o;58930:100::-;58984:13;59017:5;59010:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58930:100;:::o;87765:121::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;;;;;;;;;87841:37:::1;87851:3;87856:21;87841:9;:37::i;:::-;87765:121:::0;:::o;60490:221::-;60566:7;63833:16;;;:7;:16;;;;;;-1:-1:-1;;;;;63833:16:0;60586:73;;;;-1:-1:-1;;;60586:73:0;;19365:2:1;60586:73:0;;;19347:21:1;19404:2;19384:18;;;19377:30;19443:34;19423:18;;;19416:62;-1:-1:-1;;;19494:18:1;;;19487:42;19546:19;;60586:73:0;19163:408:1;60586:73:0;-1:-1:-1;60679:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;60679:24:0;;60490:221::o;60013:411::-;60094:13;60110:23;60125:7;60110:14;:23::i;:::-;60094:39;;60158:5;-1:-1:-1;;;;;60152:11:0;:2;-1:-1:-1;;;;;60152:11:0;;;60144:57;;;;-1:-1:-1;;;60144:57:0;;20905:2:1;60144:57:0;;;20887:21:1;20944:2;20924:18;;;20917:30;20983:34;20963:18;;;20956:62;-1:-1:-1;;;21034:18:1;;;21027:31;21075:19;;60144:57:0;20703:397:1;60144:57:0;10057:10;-1:-1:-1;;;;;60236:21:0;;;;:62;;-1:-1:-1;60261:37:0;60278:5;10057:10;61009:164;:::i;60261:37::-;60214:168;;;;-1:-1:-1;;;60214:168:0;;17411:2:1;60214:168:0;;;17393:21:1;17450:2;17430:18;;;17423:30;17489:34;17469:18;;;17462:62;17560:26;17540:18;;;17533:54;17604:19;;60214:168:0;17209:420:1;60214:168:0;60395:21;60404:2;60408:7;60395:8;:21::i;:::-;60083:341;60013:411;;:::o;86703:108::-;86747:7;86778:25;:15;6567:14;;6475:114;86778:25;86771:32;;86703:108;:::o;61240:339::-;61435:41;10057:10;61468:7;61435:18;:41::i;:::-;61427:103;;;;-1:-1:-1;;;61427:103:0;;;;;;;:::i;:::-;61543:28;61553:4;61559:2;61563:7;61543:9;:28::i;86246:230::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;86322:9:::1;86318:151;86337:12;86335:1;:14;86318:151;;;86380:27;:15;6686:19:::0;;6704:1;6686:19;;;6597:127;86380:27:::1;86422:35;86432:10;86444:12;:10;:12::i;:::-;86422:9;:35::i;:::-;86351:3:::0;::::1;::::0;::::1;:::i;:::-;;;;86318:151;;;;86246:230:::0;:::o;61650:185::-;61788:39;61805:4;61811:2;61815:7;61788:39;;;;;;;;;;;;:16;:39::i;87894:614::-;87964:16;87993;88012:19;88022:8;88012:9;:19::i;:::-;87993:38;;88042:24;88084:8;88069:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;88069:24:0;;88042:51;;88104:14;88129:20;88152:13;:11;:13::i;:::-;88129:36;;88181:9;88176:300;88200:12;88196:1;:16;88176:300;;;88234:12;63833:16;;;:7;:16;;;;;;-1:-1:-1;;;;;63833:16:0;:30;;;;88274:191;;88324:8;-1:-1:-1;;;;;88310:22:0;:10;88318:1;88310:7;:10::i;:::-;-1:-1:-1;;;;;88310:22:0;;88306:62;;;88354:1;88336:7;88344:6;88336:15;;;;;;;;:::i;:::-;;;;;;;;;;:19;88357:8;;;;:::i;:::-;;;;88306:62;88274:191;;;88407:7;88406:8;:38;;;;-1:-1:-1;88418:7:0;88426:12;88437:1;88426:8;:12;:::i;:::-;88418:21;;;;;;;;:::i;:::-;;;;;;;88443:1;88418:26;88406:38;88402:63;;;88448:14;;;;:::i;:::-;;;;88402:63;-1:-1:-1;88214:3:0;;;;:::i;:::-;;;;88176:300;;;-1:-1:-1;88493:7:0;;87894:614;-1:-1:-1;;;;;87894:614:0:o;86938:104::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;87013:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;85103:1135::-:0;1865:1;2463:7;;:19;;2455:63;;;;-1:-1:-1;;;2455:63:0;;;;;;;:::i;:::-;1865:1;2596:7;:18;82598:10:::1;82612:9;82598:23;82590:32;;;::::0;::::1;;82893:10:::2;::::0;;;::::2;;;:18;;82907:4;82893:18;82885:27;;;::::0;::::2;;85227:13:::3;::::0;:30:::3;::::0;-1:-1:-1;;;85227:30:0;;::::3;::::0;::::3;11568:25:1::0;;;85261:10:0::3;::::0;-1:-1:-1;;;;;85227:13:0::3;::::0;:21:::3;::::0;11541:18:1;;85227:30:0::3;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;85227:44:0::3;;85219:81;;;::::0;-1:-1:-1;;;85219:81:0;;22428:2:1;85219:81:0::3;::::0;::::3;22410:21:1::0;22467:2;22447:18;;;22440:30;22506:26;22486:18;;;22479:54;22550:18;;85219:81:0::3;22226:348:1::0;85219:81:0::3;85319:13;::::0;:44:::3;::::0;-1:-1:-1;;;85319:44:0;;85343:10:::3;85319:44;::::0;::::3;10488:51:1::0;10555:18;;;10548:34;;;85367:1:0::3;::::0;-1:-1:-1;;;;;85319:13:0::3;::::0;:23:::3;::::0;10461:18:1;;85319:44:0::3;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;85311:86;;;::::0;-1:-1:-1;;;85311:86:0;;17058:2:1;85311:86:0::3;::::0;::::3;17040:21:1::0;17097:2;17077:18;;;17070:30;17136:26;17116:18;;;17109:54;17180:18;;85311:86:0::3;16856:348:1::0;85311:86:0::3;85416:21;::::0;;;:12:::3;:21;::::0;;;;;::::3;;:30;85408:64;;;::::0;-1:-1:-1;;;85408:64:0;;20555:2:1;85408:64:0::3;::::0;::::3;20537:21:1::0;20594:2;20574:18;;;20567:30;-1:-1:-1;;;20613:18:1;;;20606:51;20674:18;;85408:64:0::3;20353:345:1::0;85408:64:0::3;85490:7;85501:1;85490:12;85487:744;;;85528:21;::::0;;;:12:::3;:21;::::0;;;;;;:28;;-1:-1:-1;;85528:28:0::3;85552:4;85528:28:::0;;::::3;::::0;;;85571:13:::3;::::0;:36;;-1:-1:-1;;;85571:36:0;;85590:10:::3;85571:36;::::0;::::3;9434:51:1::0;9501:18;;;9494:34;;;9544:18;;;9537:34;;;;-1:-1:-1;;;;;85571:13:0;;::::3;::::0;:18:::3;::::0;9407::1;;85571:36:0::3;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;85622:27;:15;6686:19:::0;;6704:1;6686:19;;;6597:127;85622:27:::3;85664:39;85674:10;85687:14;85694:7:::0;85687:4:::3;:14;:::i;85664:39::-;85487:744;;;85733:7;85744:1;85733:12;85730:501;;;85771:21;::::0;;;:12:::3;:21;::::0;;;;;;:28;;-1:-1:-1;;85771:28:0::3;85795:4;85771:28:::0;;::::3;::::0;;;85814:13:::3;::::0;:36;;-1:-1:-1;;;85814:36:0;;85833:10:::3;85814:36;::::0;::::3;9434:51:1::0;85845:1:0::3;9501:18:1::0;;;9494:34;9544:18;;;9537:34;;;;-1:-1:-1;;;;;85814:13:0;;::::3;::::0;:18:::3;::::0;9407::1;;85814:36:0::3;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;85865:27;:15;6686:19:::0;;6704:1;6686:19;;;6597:127;85865:27:::3;85907:39;85917:10;85930:14;85937:7:::0;85930:4:::3;:14;:::i;85730:501::-;85976:7;85987:1;85976:12;85973:258;;;86014:21;::::0;;;:12:::3;:21;::::0;;;;;;:28;;-1:-1:-1;;86014:28:0::3;86038:4;86014:28:::0;;::::3;::::0;;;86057:13:::3;::::0;:36;;-1:-1:-1;;;86057:36:0;;86076:10:::3;86057:36;::::0;::::3;9434:51:1::0;86088:1:0::3;9501:18:1::0;;;9494:34;9544:18;;;9537:34;;;;-1:-1:-1;;;;;86057:13:0;;::::3;::::0;:18:::3;::::0;9407::1;;86057:36:0::3;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;::::0;::::3;;;;;;;;;86108:27;:15;6686:19:::0;;6704:1;6686:19;;;6597:127;86108:27:::3;86162:1;86150:8;;:13;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;86209:8:0::3;::::0;86178:41:::3;::::0;86188:10:::3;::::0;86201:16:::3;::::0;:5:::3;:16;:::i;86178:41::-;-1:-1:-1::0;;1821:1:0;2775:7;:22;85103:1135::o;83567:874::-;1865:1;2463:7;;:19;;2455:63;;;;-1:-1:-1;;;2455:63:0;;;;;;;:::i;:::-;1865:1;2596:7;:18;82598:10:::1;82612:9;82598:23;82590:32;;;::::0;::::1;;82698:11:::2;::::0;::::2;;:19;;:11:::0;:19:::2;82690:28;;;::::0;::::2;;83744:12:::3;83736:5;;:20;;;;:::i;:::-;83722:9;:35;;83714:93;;;;-1:-1:-1::0;;;83714:93:0::3;;;;;;;:::i;:::-;83842:8;;83826:12;:24;;83818:50;;;::::0;-1:-1:-1;;;83818:50:0;;12505:2:1;83818:50:0::3;::::0;::::3;12487:21:1::0;12544:2;12524:18;;;12517:30;-1:-1:-1;;;12563:18:1;;;12556:43;12616:18;;83818:50:0::3;12303:337:1::0;83818:50:0::3;83934:8;::::0;83903:10:::3;83888:26;::::0;;;:14:::3;:26;::::0;;;;;:41:::3;::::0;83917:12;;83888:41:::3;:::i;:::-;83887:55;;83879:88;;;::::0;-1:-1:-1;;;83879:88:0;;16709:2:1;83879:88:0::3;::::0;::::3;16691:21:1::0;16748:2;16728:18;;;16721:30;-1:-1:-1;;;16767:18:1;;;16760:50;16827:18;;83879:88:0::3;16507:344:1::0;83879:88:0::3;84018:16;;84002:12;83987;:10;:12::i;:::-;:27;;;;:::i;:::-;83986:48;83978:87;;;::::0;-1:-1:-1;;;83978:87:0;;22781:2:1;83978:87:0::3;::::0;::::3;22763:21:1::0;22820:2;22800:18;;;22793:30;22859:28;22839:18;;;22832:56;22905:18;;83978:87:0::3;22579:350:1::0;83978:87:0::3;84103:28;::::0;-1:-1:-1;;84120:10:0::3;6688:2:1::0;6684:15;6680:53;84103:28:0::3;::::0;::::3;6668:66:1::0;84078:12:0::3;::::0;6750::1;;84103:28:0::3;;;;;;;;;;;;84093:39;;;;;;84078:54;;84151;84170:12;;84151:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::3;::::0;;;;-1:-1:-1;;84184:14:0::3;::::0;;-1:-1:-1;84200:4:0;;-1:-1:-1;84151:18:0::3;:54::i;:::-;84143:81;;;::::0;-1:-1:-1;;;84143:81:0;;21725:2:1;84143:81:0::3;::::0;::::3;21707:21:1::0;21764:2;21744:18;;;21737:30;-1:-1:-1;;;21783:18:1;;;21776:44;21837:18;;84143:81:0::3;21523:338:1::0;84143:81:0::3;84241:9;84237:197;84256:12;84254:1;:14;84237:197;;;84314:10;84299:26;::::0;;;:14:::3;:26;::::0;;;;:31;;84329:1:::3;::::0;84299:26;:31:::3;::::0;84329:1;;84299:31:::3;:::i;:::-;::::0;;;-1:-1:-1;;84345:15:0::3;6686:19:::0;;6704:1;6686:19;;;84387:35:::3;84397:10;84409:12;:10;:12::i;84387:35::-;84270:3:::0;::::3;::::0;::::3;:::i;:::-;;;;84237:197;;;-1:-1:-1::0;;1821:1:0;2775:7;:22;-1:-1:-1;;;83567:874:0:o;58624:239::-;58696:7;58732:16;;;:7;:16;;;;;;-1:-1:-1;;;;;58732:16:0;58767:19;58759:73;;;;-1:-1:-1;;;58759:73:0;;18247:2:1;58759:73:0;;;18229:21:1;18286:2;18266:18;;;18259:30;18325:34;18305:18;;;18298:62;-1:-1:-1;;;18376:18:1;;;18369:39;18425:19;;58759:73:0;18045:405:1;83163:96:0;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83239:12:::1;::::0;;-1:-1:-1;;83223:28:0;::::1;83239:12;::::0;;;::::1;;;83238:13;83223:28:::0;;::::1;;::::0;;83163:96::o;81335:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58354:208::-;58426:7;-1:-1:-1;;;;;58454:19:0;;58446:74;;;;-1:-1:-1;;;58446:74:0;;17836:2:1;58446:74:0;;;17818:21:1;17875:2;17855:18;;;17848:30;17914:34;17894:18;;;17887:62;-1:-1:-1;;;17965:18:1;;;17958:40;18015:19;;58446:74:0;17634:406:1;58446:74:0;-1:-1:-1;;;;;;58538:16:0;;;;;:9;:16;;;;;;;58354:208::o;11957:103::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;12022:30:::1;12049:1;12022:18;:30::i;:::-;11957:103::o:0;87641:116::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;87696:53:::1;87714:10;87727:21;87696:9;:53::i;82941:113::-:0;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83018:14:::1;:28:::0;82941:113::o;83464:95::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83533:11:::1;:18:::0;83464:95::o;86484:91::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;86551:5:::1;:16:::0;86484:91::o;59099:104::-;59155:13;59188:7;59181:14;;;;;:::i;83062:93::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83136:11:::1;::::0;;-1:-1:-1;;83121:26:0;::::1;83136:11;::::0;;::::1;83135:12;83121:26;::::0;;83062:93::o;60783:155::-;60878:52;10057:10;60911:8;60921;60878:18;:52::i;61906:328::-;62081:41;10057:10;62114:7;62081:18;:41::i;:::-;62073:103;;;;-1:-1:-1;;;62073:103:0;;;;;;;:::i;:::-;62187:39;62201:4;62207:2;62211:7;62220:5;62187:13;:39::i;:::-;61906:328;;;;:::o;83365:91::-;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83433:8:::1;:15:::0;83365:91::o;81363:37::-;;;;;;;:::i;87053:375::-;63809:4;63833:16;;;:7;:16;;;;;;87126:13;;-1:-1:-1;;;;;63833:16:0;87157:76;;;;-1:-1:-1;;;87157:76:0;;20139:2:1;87157:76:0;;;20121:21:1;20178:2;20158:18;;;20151:30;20217:34;20197:18;;;20190:62;-1:-1:-1;;;20268:18:1;;;20261:45;20323:19;;87157:76:0;19937:411:1;87157:76:0;87246:28;87277:10;:8;:10::i;:::-;87246:41;;87336:1;87311:14;87305:28;:32;:115;;;;;;;;;;;;;;;;;87364:14;87380:18;:7;:16;:18::i;:::-;87400:13;87347:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;87305:115;87298:122;87053:375;-1:-1:-1;;;87053:375:0:o;84449:646::-;1865:1;2463:7;;:19;;2455:63;;;;-1:-1:-1;;;2455:63:0;;;;;;;:::i;:::-;1865:1;2596:7;:18;82598:10:::1;82612:9;82598:23;82590:32;;;::::0;::::1;;82796:12:::2;::::0;::::2;;::::0;;::::2;;:20;;:12;:20;82788:29;;;::::0;::::2;;84595:12:::3;84587:5;;:20;;;;:::i;:::-;84573:9;:35;;84565:93;;;;-1:-1:-1::0;;;84565:93:0::3;;;;;;;:::i;:::-;84693:11;;84677:12;:27;;84669:54;;;::::0;-1:-1:-1;;;84669:54:0;;14780:2:1;84669:54:0::3;::::0;::::3;14762:21:1::0;14819:2;14799:18;;;14792:30;-1:-1:-1;;;14838:18:1;;;14831:44;14892:18;;84669:54:0::3;14578:338:1::0;84669:54:0::3;84786:11;::::0;84755:10:::3;84743:23;::::0;;;:11:::3;:23;::::0;;;;;:38:::3;::::0;84769:12;;84743:38:::3;:::i;:::-;84742:55;;84734:64;;;::::0;::::3;;84849:9;;84833:12;84818;:10;:12::i;:::-;:27;;;;:::i;:::-;84817:41;84809:72;;;::::0;-1:-1:-1;;;84809:72:0;;18657:2:1;84809:72:0::3;::::0;::::3;18639:21:1::0;18696:2;18676:18;;;18669:30;-1:-1:-1;;;18715:18:1;;;18708:48;18773:18;;84809:72:0::3;18455:342:1::0;84809:72:0::3;84898:9;84894:194;84913:12;84911:1;:14;84894:194;;;84968:10;84956:23;::::0;;;:11:::3;:23;::::0;;;;:28;;84983:1:::3;::::0;84956:23;:28:::3;::::0;84983:1;;84956:28:::3;:::i;:::-;::::0;;;-1:-1:-1;;84999:15:0::3;6686:19:::0;;6704:1;6686:19;;;85041:35:::3;85051:10;85063:12;:10;:12::i;85041:35::-;84927:3:::0;::::3;::::0;::::3;:::i;:::-;;;;84894:194;;12215:201:::0;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12304:22:0;::::1;12296:73;;;::::0;-1:-1:-1;;;12296:73:0;;13266:2:1;12296:73:0::1;::::0;::::1;13248:21:1::0;13305:2;13285:18;;;13278:30;13344:34;13324:18;;;13317:62;-1:-1:-1;;;13395:18:1;;;13388:36;13441:19;;12296:73:0::1;13064:402:1::0;12296:73:0::1;12380:28;12399:8;12380:18;:28::i;83267:90::-:0;11379:6;;-1:-1:-1;;;;;11379:6:0;10057:10;11526:23;11518:68;;;;-1:-1:-1;;;11518:68:0;;;;;;;:::i;:::-;83339:10:::1;::::0;;-1:-1:-1;;83325:24:0;::::1;83339:10:::0;;;;::::1;;;83338:11;83325:24:::0;;::::1;;::::0;;83267:90::o;6597:127::-;6686:19;;6704:1;6686:19;;;6597:127::o;6475:114::-;6567:14;;6475:114::o;14060:326::-;-1:-1:-1;;;;;14355:19:0;;:23;;;14060:326::o;87436:197::-;87519:12;87545:8;-1:-1:-1;;;;;87537:22:0;87567:7;87537:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87518:61;;;87598:7;87590:35;;;;-1:-1:-1;;;87590:35:0;;13673:2:1;87590:35:0;;;13655:21:1;13712:2;13692:18;;;13685:30;-1:-1:-1;;;13731:18:1;;;13724:45;13786:18;;87590:35:0;13471:339:1;67890:174:0;67965:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;67965:29:0;-1:-1:-1;;;;;67965:29:0;;;;;;;;:24;;68019:23;67965:24;68019:14;:23::i;:::-;-1:-1:-1;;;;;68010:46:0;;;;;;;;;;;67890:174;;:::o;64038:348::-;64131:4;63833:16;;;:7;:16;;;;;;-1:-1:-1;;;;;63833:16:0;64148:73;;;;-1:-1:-1;;;64148:73:0;;16296:2:1;64148:73:0;;;16278:21:1;16335:2;16315:18;;;16308:30;16374:34;16354:18;;;16347:62;-1:-1:-1;;;16425:18:1;;;16418:42;16477:19;;64148:73:0;16094:408:1;64148:73:0;64232:13;64248:23;64263:7;64248:14;:23::i;:::-;64232:39;;64301:5;-1:-1:-1;;;;;64290:16:0;:7;-1:-1:-1;;;;;64290:16:0;;:51;;;;64334:7;-1:-1:-1;;;;;64310:31:0;:20;64322:7;64310:11;:20::i;:::-;-1:-1:-1;;;;;64310:31:0;;64290:51;:87;;;-1:-1:-1;;;;;;61130:25:0;;;61106:4;61130:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;64345:32;64282:96;64038:348;-1:-1:-1;;;;64038:348:0:o;67147:625::-;67306:4;-1:-1:-1;;;;;67279:31:0;:23;67294:7;67279:14;:23::i;:::-;-1:-1:-1;;;;;67279:31:0;;67271:81;;;;-1:-1:-1;;;67271:81:0;;14017:2:1;67271:81:0;;;13999:21:1;14056:2;14036:18;;;14029:30;14095:34;14075:18;;;14068:62;-1:-1:-1;;;14146:18:1;;;14139:35;14191:19;;67271:81:0;13815:401:1;67271:81:0;-1:-1:-1;;;;;67371:16:0;;67363:65;;;;-1:-1:-1;;;67363:65:0;;15123:2:1;67363:65:0;;;15105:21:1;15162:2;15142:18;;;15135:30;15201:34;15181:18;;;15174:62;-1:-1:-1;;;15252:18:1;;;15245:34;15296:19;;67363:65:0;14921:400:1;67363:65:0;67545:29;67562:1;67566:7;67545:8;:29::i;:::-;-1:-1:-1;;;;;67587:15:0;;;;;;:9;:15;;;;;:20;;67606:1;;67587:15;:20;;67606:1;;67587:20;:::i;:::-;;;;-1:-1:-1;;;;;;;67618:13:0;;;;;;:9;:13;;;;;:18;;67635:1;;67618:13;:18;;67635:1;;67618:18;:::i;:::-;;;;-1:-1:-1;;67647:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;67647:21:0;-1:-1:-1;;;;;67647:21:0;;;;;;;;;67686:27;;67647:16;;67686:27;;;;;;;60083:341;60013:411;;:::o;64728:110::-;64804:26;64814:2;64818:7;64804:26;;;;;;;;;;;;:9;:26::i;4085:190::-;4210:4;4263;4234:25;4247:5;4254:4;4234:12;:25::i;:::-;:33;;4085:190;-1:-1:-1;;;;4085:190:0:o;12576:191::-;12669:6;;;-1:-1:-1;;;;;12686:17:0;;;-1:-1:-1;;;;;;12686:17:0;;;;;;;12719:40;;12669:6;;;12686:17;12669:6;;12719:40;;12650:16;;12719:40;12639:128;12576:191;:::o;68206:315::-;68361:8;-1:-1:-1;;;;;68352:17:0;:5;-1:-1:-1;;;;;68352:17:0;;;68344:55;;;;-1:-1:-1;;;68344:55:0;;15528:2:1;68344:55:0;;;15510:21:1;15567:2;15547:18;;;15540:30;15606:27;15586:18;;;15579:55;15651:18;;68344:55:0;15326:349:1;68344:55:0;-1:-1:-1;;;;;68410:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;68410:46:0;;;;;;;;;;68472:41;;11370::1;;;68472::0;;11343:18:1;68472:41:0;;;;;;;68206:315;;;:::o;63116:::-;63273:28;63283:4;63289:2;63293:7;63273:9;:28::i;:::-;63320:48;63343:4;63349:2;63353:7;63362:5;63320:22;:48::i;:::-;63312:111;;;;-1:-1:-1;;;63312:111:0;;;;;;;:::i;86819:108::-;86879:13;86912:7;86905:14;;;;;:::i;7486:723::-;7542:13;7763:10;7759:53;;-1:-1:-1;;7790:10:0;;;;;;;;;;;;-1:-1:-1;;;7790:10:0;;;;;7486:723::o;7759:53::-;7837:5;7822:12;7878:78;7885:9;;7878:78;;7911:8;;;;:::i;:::-;;-1:-1:-1;7934:10:0;;-1:-1:-1;7942:2:0;7934:10;;:::i;:::-;;;7878:78;;;7966:19;7998:6;7988:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7988:17:0;;7966:39;;8016:154;8023:10;;8016:154;;8050:11;8060:1;8050:11;;:::i;:::-;;-1:-1:-1;8119:10:0;8127:2;8119:5;:10;:::i;:::-;8106:24;;:2;:24;:::i;:::-;8093:39;;8076:6;8083;8076:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;8076:56:0;;;;;;;;-1:-1:-1;8147:11:0;8156:2;8147:11;;:::i;:::-;;;8016:154;;65065:321;65195:18;65201:2;65205:7;65195:5;:18::i;:::-;65246:54;65277:1;65281:2;65285:7;65294:5;65246:22;:54::i;:::-;65224:154;;;;-1:-1:-1;;;65224:154:0;;;;;;;:::i;4636:675::-;4719:7;4762:4;4719:7;4777:497;4801:5;:12;4797:1;:16;4777:497;;;4835:20;4858:5;4864:1;4858:8;;;;;;;;:::i;:::-;;;;;;;4835:31;;4901:12;4885;:28;4881:382;;5387:13;5437:15;;;5473:4;5466:15;;;5520:4;5504:21;;5013:57;;4881:382;;;5387:13;5437:15;;;5473:4;5466:15;;;5520:4;5504:21;;5190:57;;4881:382;-1:-1:-1;4815:3:0;;;;:::i;:::-;;;;4777:497;;;-1:-1:-1;5291:12:0;4636:675;-1:-1:-1;;;4636:675:0:o;69086:799::-;69241:4;-1:-1:-1;;;;;69262:13:0;;14355:19;:23;69258:620;;69298:72;;-1:-1:-1;;;69298:72:0;;-1:-1:-1;;;;;69298:36:0;;;;;:72;;10057:10;;69349:4;;69355:7;;69364:5;;69298:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69298:72:0;;;;;;;;-1:-1:-1;;69298:72:0;;;;;;;;;;;;:::i;:::-;;;69294:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69540:13:0;;69536:272;;69583:60;;-1:-1:-1;;;69583:60:0;;;;;;;:::i;69536:272::-;69758:6;69752:13;69743:6;69739:2;69735:15;69728:38;69294:529;-1:-1:-1;;;;;;69421:51:0;-1:-1:-1;;;69421:51:0;;-1:-1:-1;69414:58:0;;69258:620;-1:-1:-1;69862:4:0;69086:799;;;;;;:::o;65722:439::-;-1:-1:-1;;;;;65802:16:0;;65794:61;;;;-1:-1:-1;;;65794:61:0;;19004:2:1;65794:61:0;;;18986:21:1;;;19023:18;;;19016:30;19082:34;19062:18;;;19055:62;19134:18;;65794:61:0;18802:356:1;65794:61:0;63809:4;63833:16;;;:7;:16;;;;;;-1:-1:-1;;;;;63833:16:0;:30;65866:58;;;;-1:-1:-1;;;65866:58:0;;14423:2:1;65866:58:0;;;14405:21:1;14462:2;14442:18;;;14435:30;14501;14481:18;;;14474:58;14549:18;;65866:58:0;14221:352:1;65866:58:0;-1:-1:-1;;;;;65995:13:0;;;;;;:9;:13;;;;;:18;;66012:1;;65995:13;:18;;66012:1;;65995:18;:::i;:::-;;;;-1:-1:-1;;66024:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;66024:21:0;-1:-1:-1;;;;;66024:21:0;;;;;;;;66063:33;;66024:16;;;66063:33;;66024:16;;66063:33;86318:151:::1;86246:230:::0;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:247::-;709:6;762:2;750:9;741:7;737:23;733:32;730:52;;;778:1;775;768:12;730:52;817:9;804:23;836:31;861:5;836:31;:::i;902:251::-;972:6;1025:2;1013:9;1004:7;1000:23;996:32;993:52;;;1041:1;1038;1031:12;993:52;1073:9;1067:16;1092:31;1117:5;1092:31;:::i;1418:388::-;1486:6;1494;1547:2;1535:9;1526:7;1522:23;1518:32;1515:52;;;1563:1;1560;1553:12;1515:52;1602:9;1589:23;1621:31;1646:5;1621:31;:::i;:::-;1671:5;-1:-1:-1;1728:2:1;1713:18;;1700:32;1741:33;1700:32;1741:33;:::i;:::-;1793:7;1783:17;;;1418:388;;;;;:::o;1811:456::-;1888:6;1896;1904;1957:2;1945:9;1936:7;1932:23;1928:32;1925:52;;;1973:1;1970;1963:12;1925:52;2012:9;1999:23;2031:31;2056:5;2031:31;:::i;:::-;2081:5;-1:-1:-1;2138:2:1;2123:18;;2110:32;2151:33;2110:32;2151:33;:::i;:::-;1811:456;;2203:7;;-1:-1:-1;;;2257:2:1;2242:18;;;;2229:32;;1811:456::o;2272:794::-;2367:6;2375;2383;2391;2444:3;2432:9;2423:7;2419:23;2415:33;2412:53;;;2461:1;2458;2451:12;2412:53;2500:9;2487:23;2519:31;2544:5;2519:31;:::i;:::-;2569:5;-1:-1:-1;2626:2:1;2611:18;;2598:32;2639:33;2598:32;2639:33;:::i;:::-;2691:7;-1:-1:-1;2745:2:1;2730:18;;2717:32;;-1:-1:-1;2800:2:1;2785:18;;2772:32;2827:18;2816:30;;2813:50;;;2859:1;2856;2849:12;2813:50;2882:22;;2935:4;2927:13;;2923:27;-1:-1:-1;2913:55:1;;2964:1;2961;2954:12;2913:55;2987:73;3052:7;3047:2;3034:16;3029:2;3025;3021:11;2987:73;:::i;:::-;2977:83;;;2272:794;;;;;;;:::o;3071:416::-;3136:6;3144;3197:2;3185:9;3176:7;3172:23;3168:32;3165:52;;;3213:1;3210;3203:12;3165:52;3252:9;3239:23;3271:31;3296:5;3271:31;:::i;:::-;3321:5;-1:-1:-1;3378:2:1;3363:18;;3350:32;3420:15;;3413:23;3401:36;;3391:64;;3451:1;3448;3441:12;3492:315;3560:6;3568;3621:2;3609:9;3600:7;3596:23;3592:32;3589:52;;;3637:1;3634;3627:12;3589:52;3676:9;3663:23;3695:31;3720:5;3695:31;:::i;:::-;3745:5;3797:2;3782:18;;;;3769:32;;-1:-1:-1;;;3492:315:1:o;3812:689::-;3907:6;3915;3923;3976:2;3964:9;3955:7;3951:23;3947:32;3944:52;;;3992:1;3989;3982:12;3944:52;4032:9;4019:23;4061:18;4102:2;4094:6;4091:14;4088:34;;;4118:1;4115;4108:12;4088:34;4156:6;4145:9;4141:22;4131:32;;4201:7;4194:4;4190:2;4186:13;4182:27;4172:55;;4223:1;4220;4213:12;4172:55;4263:2;4250:16;4289:2;4281:6;4278:14;4275:34;;;4305:1;4302;4295:12;4275:34;4360:7;4353:4;4343:6;4340:1;4336:14;4332:2;4328:23;4324:34;4321:47;4318:67;;;4381:1;4378;4371:12;4318:67;4412:4;4404:13;;;;4436:6;;-1:-1:-1;4474:20:1;;;;4461:34;;3812:689;-1:-1:-1;;;;3812:689:1:o;4506:180::-;4565:6;4618:2;4606:9;4597:7;4593:23;4589:32;4586:52;;;4634:1;4631;4624:12;4586:52;-1:-1:-1;4657:23:1;;4506:180;-1:-1:-1;4506:180:1:o;4691:245::-;4749:6;4802:2;4790:9;4781:7;4777:23;4773:32;4770:52;;;4818:1;4815;4808:12;4770:52;4857:9;4844:23;4876:30;4900:5;4876:30;:::i;4941:249::-;5010:6;5063:2;5051:9;5042:7;5038:23;5034:32;5031:52;;;5079:1;5076;5069:12;5031:52;5111:9;5105:16;5130:30;5154:5;5130:30;:::i;5195:450::-;5264:6;5317:2;5305:9;5296:7;5292:23;5288:32;5285:52;;;5333:1;5330;5323:12;5285:52;5373:9;5360:23;5406:18;5398:6;5395:30;5392:50;;;5438:1;5435;5428:12;5392:50;5461:22;;5514:4;5506:13;;5502:27;-1:-1:-1;5492:55:1;;5543:1;5540;5533:12;5492:55;5566:73;5631:7;5626:2;5613:16;5608:2;5604;5600:11;5566:73;:::i;5835:184::-;5905:6;5958:2;5946:9;5937:7;5933:23;5929:32;5926:52;;;5974:1;5971;5964:12;5926:52;-1:-1:-1;5997:16:1;;5835:184;-1:-1:-1;5835:184:1:o;6024:248::-;6092:6;6100;6153:2;6141:9;6132:7;6128:23;6124:32;6121:52;;;6169:1;6166;6159:12;6121:52;-1:-1:-1;;6192:23:1;;;6262:2;6247:18;;;6234:32;;-1:-1:-1;6024:248:1:o;6277:257::-;6318:3;6356:5;6350:12;6383:6;6378:3;6371:19;6399:63;6455:6;6448:4;6443:3;6439:14;6432:4;6425:5;6421:16;6399:63;:::i;:::-;6516:2;6495:15;-1:-1:-1;;6491:29:1;6482:39;;;;6523:4;6478:50;;6277:257;-1:-1:-1;;6277:257:1:o;6773:1527::-;6997:3;7035:6;7029:13;7061:4;7074:51;7118:6;7113:3;7108:2;7100:6;7096:15;7074:51;:::i;:::-;7188:13;;7147:16;;;;7210:55;7188:13;7147:16;7232:15;;;7210:55;:::i;:::-;7354:13;;7287:20;;;7327:1;;7414;7436:18;;;;7489;;;;7516:93;;7594:4;7584:8;7580:19;7568:31;;7516:93;7657:2;7647:8;7644:16;7624:18;7621:40;7618:167;;;-1:-1:-1;;;7684:33:1;;7740:4;7737:1;7730:15;7770:4;7691:3;7758:17;7618:167;7801:18;7828:110;;;;7952:1;7947:328;;;;7794:481;;7828:110;-1:-1:-1;;7863:24:1;;7849:39;;7908:20;;;;-1:-1:-1;7828:110:1;;7947:328;23189:1;23182:14;;;23226:4;23213:18;;8042:1;8056:169;8070:8;8067:1;8064:15;8056:169;;;8152:14;;8137:13;;;8130:37;8195:16;;;;8087:10;;8056:169;;;8060:3;;8256:8;8249:5;8245:20;8238:27;;7794:481;-1:-1:-1;8291:3:1;;6773:1527;-1:-1:-1;;;;;;;;;;;6773:1527:1:o;8723:488::-;-1:-1:-1;;;;;8992:15:1;;;8974:34;;9044:15;;9039:2;9024:18;;9017:43;9091:2;9076:18;;9069:34;;;9139:3;9134:2;9119:18;;9112:31;;;8917:4;;9160:45;;9185:19;;9177:6;9160:45;:::i;:::-;9152:53;8723:488;-1:-1:-1;;;;;;8723:488:1:o;10593:632::-;10764:2;10816:21;;;10886:13;;10789:18;;;10908:22;;;10735:4;;10764:2;10987:15;;;;10961:2;10946:18;;;10735:4;11030:169;11044:6;11041:1;11038:13;11030:169;;;11105:13;;11093:26;;11174:15;;;;11139:12;;;;11066:1;11059:9;11030:169;;;-1:-1:-1;11216:3:1;;10593:632;-1:-1:-1;;;;;;10593:632:1:o;12079:219::-;12228:2;12217:9;12210:21;12191:4;12248:44;12288:2;12277:9;12273:18;12265:6;12248:44;:::i;12645:414::-;12847:2;12829:21;;;12886:2;12866:18;;;12859:30;12925:34;12920:2;12905:18;;12898:62;-1:-1:-1;;;12991:2:1;12976:18;;12969:48;13049:3;13034:19;;12645:414::o;15680:409::-;15882:2;15864:21;;;15921:2;15901:18;;;15894:30;15960:34;15955:2;15940:18;;15933:62;-1:-1:-1;;;16026:2:1;16011:18;;16004:43;16079:3;16064:19;;15680:409::o;19576:356::-;19778:2;19760:21;;;19797:18;;;19790:30;19856:34;19851:2;19836:18;;19829:62;19923:2;19908:18;;19576:356::o;21105:413::-;21307:2;21289:21;;;21346:2;21326:18;;;21319:30;21385:34;21380:2;21365:18;;21358:62;-1:-1:-1;;;21451:2:1;21436:18;;21429:47;21508:3;21493:19;;21105:413::o;21866:355::-;22068:2;22050:21;;;22107:2;22087:18;;;22080:30;22146:33;22141:2;22126:18;;22119:61;22212:2;22197:18;;21866:355::o;23242:128::-;23282:3;23313:1;23309:6;23306:1;23303:13;23300:39;;;23319:18;;:::i;:::-;-1:-1:-1;23355:9:1;;23242:128::o;23375:120::-;23415:1;23441;23431:35;;23446:18;;:::i;:::-;-1:-1:-1;23480:9:1;;23375:120::o;23500:168::-;23540:7;23606:1;23602;23598:6;23594:14;23591:1;23588:21;23583:1;23576:9;23569:17;23565:45;23562:71;;;23613:18;;:::i;:::-;-1:-1:-1;23653:9:1;;23500:168::o;23673:125::-;23713:4;23741:1;23738;23735:8;23732:34;;;23746:18;;:::i;:::-;-1:-1:-1;23783:9:1;;23673:125::o;23803:258::-;23875:1;23885:113;23899:6;23896:1;23893:13;23885:113;;;23975:11;;;23969:18;23956:11;;;23949:39;23921:2;23914:10;23885:113;;;24016:6;24013:1;24010:13;24007:48;;;-1:-1:-1;;24051:1:1;24033:16;;24026:27;23803:258::o;24066:380::-;24145:1;24141:12;;;;24188;;;24209:61;;24263:4;24255:6;24251:17;24241:27;;24209:61;24316:2;24308:6;24305:14;24285:18;24282:38;24279:161;;;24362:10;24357:3;24353:20;24350:1;24343:31;24397:4;24394:1;24387:15;24425:4;24422:1;24415:15;24279:161;;24066:380;;;:::o;24451:135::-;24490:3;-1:-1:-1;;24511:17:1;;24508:43;;;24531:18;;:::i;:::-;-1:-1:-1;24578:1:1;24567:13;;24451:135::o;24591:112::-;24623:1;24649;24639:35;;24654:18;;:::i;:::-;-1:-1:-1;24688:9:1;;24591:112::o;24708:127::-;24769:10;24764:3;24760:20;24757:1;24750:31;24800:4;24797:1;24790:15;24824:4;24821:1;24814:15;24840:127;24901:10;24896:3;24892:20;24889:1;24882:31;24932:4;24929:1;24922:15;24956:4;24953:1;24946:15;24972:127;25033:10;25028:3;25024:20;25021:1;25014:31;25064:4;25061:1;25054:15;25088:4;25085:1;25078:15;25104:127;25165:10;25160:3;25156:20;25153:1;25146:31;25196:4;25193:1;25186:15;25220:4;25217:1;25210:15;25236:131;-1:-1:-1;;;;;25311:31:1;;25301:42;;25291:70;;25357:1;25354;25347:12;25372:131;-1:-1:-1;;;;;;25446:32:1;;25436:43;;25426:71;;25493:1;25490;25483:12

Swarm Source

ipfs://113eb237e59c949c1e67d1acaca6b0283da764c32eafb7b99404cec392b5163a

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