Token

The Shrapes (SHRAPE)

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

ERC-721

Overview

Max Total Supply

10,000 SHRAPE

Holders

1,691

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd6e3f957dbf8bf70b910072f09b88b7666806dc6

Filtered by Token Holder

0x0D5Ff1059daAC1992A68C986c7927973897A102B

Balance

1 SHRAPE

0x0d5ff1059daac1992a68c986c7927973897a102b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TheShrapes

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol

/*
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣠⣄⣀⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⠟⠋⠙⠋⠉⠙⢷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣤⣶⣶⣄⠀⠀⠀⢠⣾⣿⣁⡀⠀⠀⠀⠀⠀⠀⢑⣿⡆⠀⠀⠀⢠⣾⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣿⣾⣦⡀⢠⣾⡿⣛⣛⡻⢷⣄⠀⠀⣴⣾⣿⠛⠻⠦⣄⣴⣿⣿⡿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠉⠻⢿⣿⣿⣿⣿⣿⢿⣿⣿⣧⢼⣿⣿⣿⠿⣿⣇⢸⡟⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⠿⢿⣾⣿⣤⠿⠋⠀⠈⠻⢿⣿⣧⣿⠟⣬⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⣿⠃⠀⠀⢀⣴⣖⣶⠀⠀⠀⠀⠀⢀⡈⠀⠀⢘⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⣿⣶⣶⣶⠿⠿⠿⠿⠷⠶⠶⠶⠛⠋⠻⣦⣤⣀⡼⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⡇⠀⣿⠻⢷⣤⣀⠀⠀⠀⠈⠀⠀⠀⣀⣈⡻⢿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⡿⠛⡏⠁⠂⠘⠭⢿⣒⣒⡒⠒⠒⠊⠉⠁⠀⠀⣿⠤⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⠟⠁⡄⠣⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡌⠙⠲⣤⣀⠠⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣏⠀⠀⢿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⠋⠀⠀⠀⠀⠈⠙⠚⠓⠶⢤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣴⣿⣿⣿⣿⣶⣀⡴⠛⢷⣄⣠⣄⡀⠀⠀⠀⠀⠀⠀⠀⠐⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠉⠳⢦⡀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣤⣤⠴⠾⣿⣿⣿⣿⣿⠟⠛⠿⣿⣦⣄⠙⢻⣿⣷⣦⡤⠤⠶⠒⠛⠁⣠⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣆⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⢠⣴⡾⠏⠁⠀⠀⠀⠀⠰⠿⠟⠋⠀⠀⠀⠀⠈⠉⠛⠙⠋⠉⠉⠀⠀⠀⠀⠀⣀⡴⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢧⡀⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⢀⣴⡿⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⠒⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢷⠀⠀⠀⠀
⠀⠀⠀⠀⠀⢀⣾⡿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢉⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⡇⠀⠀⠀
⠀⠀⠀⠀⢄⣾⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⢸⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⣧⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⣧⠀⠀⠀
⠀⠀⠀⠀⣼⣋⣧⣶⠀⠀⠀⢀⡀⣀⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⣼⣿⣿⣟⣤⡀⠀⠀⠀⠀⠀⠀⠘⣦⠀⠀
⠀⠀⠀⠀⣿⡟⡇⣿⣤⣤⣴⣼⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢼⣷⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠏⣴⣿⣿⠋⠉⠉⠛⠋⡄⠂⠀⠀⠀⠀⠈⣇⠀
⠀⠀⠀⢀⣿⣷⣜⢿⣿⣿⣿⣿⣿⣿⣟⢿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣶⠾⣿⣿⣷⠀⠀⠀⠀⠀⠀⠀⠐⠖⣠⣶⣿⣟⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡀
⠀⠀⢀⣾⠋⠻⣿⡶⠍⠙⠛⢿⣿⣿⣿⣮⡙⠿⣿⣶⣤⣄⣀⣤⣤⣤⣤⡀⢀⣈⣁⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇
⠀⠀⣾⠇⠀⠀⠘⢷⡇⠀⠀⠀⢿⣿⣿⣿⣿⣶⣼⣿⣿⣟⣻⣿⣿⣿⣿⡿⠟⠛⠁⠀⠉⠻⢿⣿⣶⣤⣴⣶⣶⣤⣶⣿⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠇
⠀⢸⣿⠀⠀⠀⢠⡞⠀⠀⠀⠀⢾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⣋⣠⣀⠀⠀⠀⠀⠀⠀⠀⢉⣛⢻⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠀⠀⢀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⠀
⠀⢸⡏⠀⠀⠀⣼⠁⠀⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⠛⠿⡿⠛⠉⠉⠉⠁⠀⢀⠀⠀⠀⠀⠀⠉⠰⠿⠿⠛⠻⠟⠉⠁⢩⢹⣿⣿⣄⠀⠸⣆⠀⠀⠀⠀⠀⠀⠀⠀⡇⠀
⠀⣿⢿⠀⠀⣰⠇⠀⠀⠀⠀⠀⣿⡟⢻⣿⣿⣿⣿⣿⡟⠻⢶⣤⠀⠀⠀⠀⠀⠀⠀⢸⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣸⣿⢿⣿⣿⣦⠀⢹⣆⠀⠀⠀⠀⠀⠀⠀⡇⠀
⢀⡟⠺⠀⢐⡿⠀⠀⠀⠀⢀⣼⣿⠁⠀⢻⣿⣿⣿⣿⣿⣷⣤⣿⣤⣤⣤⣤⣶⡄⠀⠀⣿⣇⣤⣤⣀⣀⡀⠀⠀⠀⠀⠀⠈⢿⣷⣿⡾⠁⢿⣿⣷⣿⣿⡷⠀⠀⠀⠀⠀⠀⡇⠀
⢸⡇⠀⠘⣿⡁⠀⠀⢀⣰⣿⣿⠃⠀⠀⠀⢻⣿⣽⠋⠛⢯⢿⣿⠛⠛⠋⠉⠙⠛⠲⣄⠉⠉⠁⠈⠉⠙⠛⠷⣦⣤⣤⣌⠀⠀⢸⡟⠁⠀⠀⠻⣿⣿⣿⣍⠀⠀⠀⠀⠀⠀⢧⠀
⢸⠁⠀⠀⢹⣷⣿⣿⣿⣿⣿⠋⠀⠀⠀⠀⢸⣿⢢⠀⠂⠀⣭⣿⡀⠀⠀⠀⠀⠀⠀⢸⡉⠀⠀⠀⠀⠀⠀⠀⠉⠀⠀⠀⠀⠀⡿⠀⠀⠀⠀⠀⢹⣿⡿⠉⠀⠀⠀⠀⠀⠀⡾⠀
⠀⠀⠀⠀⠀⠋⣿⣿⣿⡟⠁⠀⠀⠀⠀⠀⣼⣏⠈⠁⢰⠀⢨⣿⣧⣀⡀⣠⠀⠀⠀⣸⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⡇⠀⠀⠀⠀⠀⣸⡍⠁⠀⠀⠀⠀⠀⠀⣠⣷⠀
⠀⠀⠀⠀⠀⠀⠙⢿⣿⡇⠀⠀⠀⠀⠀⢠⣿⠟⠇⠀⠈⠑⢦⣿⠿⠿⠿⠿⠶⢀⢀⣸⠿⣶⣦⣠⡖⠀⠀⠀⠀⠀⠀⠀⢀⣿⠀⠀⠀⠀⠀⠀⡿⠀⠀⠀⠀⠀⠀⠀⠀⠘⢻⡆
⠀⠀⠀⠀⠀⠀⠀⠀⣼⡇⠀⠀⠀⠀⠀⣸⡗⠀⠀⠀⠀⠀⠀⠙⠷⡄⣀⠀⠀⠻⠟⠃⠀⠀⠀⠀⠤⠀⠀⠀⠀⠀⠀⠀⣾⡟⠀⠀⠀⠀⠀⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇
⠀⠀⠀⠀⠀⠀⠀⠀⠹⠇⠀⠀⠀⠀⠀⣸⣿⠠⢰⣶⠄⠀⠀⠀⢀⣀⠀⢠⠀⠀⢠⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣙⣿⠁⠀⠀⠀⠀⠀⣸⣷⠀⠀⠀⠀⠀⠀⠀⠀⠀⣾⠇
*/


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

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

        return result;
    }
}

// File: contracts/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;


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


pragma solidity ^0.8.13;


contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry constant operatorFilterRegistry =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

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

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


pragma solidity ^0.8.13;


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

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


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

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

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

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


// OpenZeppelin Contracts (last updated v4.8.0) (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`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

pragma solidity ^0.8.0;



interface IERC721Enumerable is IERC721 {
  
    function totalSupply() external view returns (uint256);


    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);


    function tokenByIndex(uint256 index) external view returns (uint256);
}

pragma solidity ^0.8.0;

abstract contract ReentrancyGuard {

    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }


    modifier nonReentrant() {
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        _status = _ENTERED;

        _;

        _status = _NOT_ENTERED;
    }
}


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;




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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable, DefaultOperatorFilterer {
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 internal currentIndex;

    string private _name;

    string private _symbol;

    mapping(uint256 => TokenOwnership) internal _ownerships;

    mapping(address => AddressData) private _addressData;

    mapping(uint256 => address) private _tokenApprovals;

    mapping(address => mapping(address => bool)) private _operatorApprovals;

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

    function totalSupply() public view override returns (uint256) {
        return currentIndex;
    }

    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), "ERC721A: global index out of bounds");
        return index;
    }

    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        revert("ERC721A: unable to get token of owner by index");
    }


    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    function balanceOf(address owner) public view override returns (uint256) {
        require(owner != address(0), "ERC721A: balance query for the zero address");
        return uint256(_addressData[owner].balance);
    }

    function _numberMinted(address owner) internal view returns (uint256) {
        require(owner != address(0), "ERC721A: number minted query for the zero address");
        return uint256(_addressData[owner].numberMinted);
    }

    function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

        unchecked {
            for (uint256 curr = tokenId; curr >= 0; curr--) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (ownership.addr != address(0)) {
                    return ownership;
                }
            }
        }

        revert("ERC721A: unable to determine the owner of token");
    }

    function ownerOf(uint256 tokenId) public view override returns (address) {
        return ownershipOf(tokenId).addr;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    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())) : "";
    }

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

    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        require(to != owner, "ERC721A: approval to current owner");

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

        _approve(to, tokenId, owner);
    }

    function getApproved(uint256 tokenId) public view override returns (address) {
        require(_exists(tokenId), "ERC721A: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    function setApprovalForAll(address operator, bool approved) public override {
        require(operator != _msgSender(), "ERC721A: approve to caller");

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

    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

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

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

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

    function _exists(uint256 tokenId) internal view returns (bool) {
        return tokenId < currentIndex;
    }

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

    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = currentIndex;
        require(to != address(0), "ERC721A: mint to the zero address");
        require(quantity != 0, "ERC721A: quantity must be greater than 0");

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

        unchecked {
            _addressData[to].balance += uint128(quantity);
            _addressData[to].numberMinted += uint128(quantity);

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

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe) {
                    require(
                        _checkOnERC721Received(address(0), to, updatedIndex, _data),
                        "ERC721A: transfer to non ERC721Receiver implementer"
                    );
                }

                updatedIndex++;
            }

            currentIndex = updatedIndex;
        }

        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }
 
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            getApproved(tokenId) == _msgSender() ||
            isApprovedForAll(prevOwnership.addr, _msgSender()));

        require(isApprovedOrOwner, "ERC721A: transfer caller is not owner nor approved");

        require(prevOwnership.addr == from, "ERC721A: transfer from incorrect owner");
        require(to != address(0), "ERC721A: transfer to the zero address");

        _beforeTokenTransfers(from, to, tokenId, 1);

        _approve(address(0), tokenId, prevOwnership.addr);

        
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

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

            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                if (_exists(nextTokenId)) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    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(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721A: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}


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

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

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

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

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

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

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

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

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

// File: contracts/TheShrapes.sol


pragma solidity ^0.8.9;


contract TheShrapes is ERC721A, Ownable, ReentrancyGuard {
    using Strings for uint256;
    
    address private _AdventureContract;
    uint   private _totalStake;
    bool   public QuestPhase = false;
    uint128 internal _burnCounter; 
    uint   public price             = 0.005 ether;
    uint   public maxTx          = 30;
    uint   public maxFreePerWallet  = 1;
    uint   public maxShrapes          = 10000;
    uint256 public reservedSupply = 50;
    string private baseURI;
    bool   public mintEnabled;  
    
    mapping(address => uint256) public _FreeMinted;

    constructor() ERC721A("The Shrapes", "SHRAPE") {}

    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,Strings.toString(_tokenId),".json"))
            : "";
    }

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

    // Public Functions
    function mint(uint256 Amount) external payable {

        if (((totalSupply() + Amount < maxShrapes + 1) && (_FreeMinted[msg.sender] < maxFreePerWallet))) 
        {
        require(totalSupply() + Amount <= maxShrapes, "No more shrapes to be minted");
        require(mintEnabled, "Not live yet, shrapes are coming");
        require(msg.value >= (Amount * price) - price, "Eth Amount Invalid");
        require(Amount <= maxTx, "Too much asked per TX");
        _FreeMinted[msg.sender] += Amount;
        }
        else{
        require(totalSupply() + Amount <= maxShrapes, "No more shrapes to be minted");
        require(mintEnabled, "Not live yet, shrapes are coming");
        require(msg.value >= Amount * price, "Eth Amount Invalid");
        require(Amount <= maxTx, "Too much asked per TX");
        }

        _safeMint(msg.sender, Amount);
        //totalSupply += Amount;
        
    }

    function reservedMint(uint256 Amount) external onlyOwner
    {
        uint256 Remaining = reservedSupply;

        require(totalSupply() + Amount <= maxShrapes, "No more shrapes to be minted");
        require(Remaining >= Amount, "Reserved Supply Minted");
    
        reservedSupply = Remaining - Amount;
        _safeMint(msg.sender, Amount);
       // totalSupply() += Amount;
    }

    // Owner-only functions
    function toggleMinting() external onlyOwner {
      mintEnabled = !mintEnabled;
    }

   function setBaseUri(string memory baseuri_) public onlyOwner {
        baseURI = baseuri_;
    }

    function setCost(uint256 price_) external onlyOwner {
        price = price_;
    }

    function costInspect() public view returns (uint256) {
        return price;
    }

    function setAdventureContract(address _contract) public onlyOwner {
        _AdventureContract = _contract;
    }

    function toggleQuestPhase() public onlyOwner {
        QuestPhase = !QuestPhase;
    }

    function withdraw() external onlyOwner nonReentrant {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "Transfer failed.");
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"QuestPhase","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_FreeMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"costInspect","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFreePerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxShrapes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"Amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"Amount","type":"uint256"}],"name":"reservedMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reservedSupply","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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_contract","type":"address"}],"name":"setAdventureContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseuri_","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"price_","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleQuestPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

72471:3356:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61479:372;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63002:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64088:214;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63667:413;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60280:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64777:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60583:886;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75638:186;;;;;;;;;;;;;:::i;:::-;;64936:159;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75234:85;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72647:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72905:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72857:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60388:187;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75419:115;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62870:124;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61859:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71586:103;;;;;;;;;;;;;:::i;:::-;;72775:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73015:46;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75034:87;;;;;;;;;;;;;:::i;:::-;;74599:398;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70938:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63110:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72723:45;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73671:920;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75128:98;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64310:288;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75542:88;;;;;;;;;;;;;:::i;:::-;;72815:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65103:216;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75327:84;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73127:395;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72975:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64606:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71844:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61479:372;61581:4;61633:25;61618:40;;;:11;:40;;;;:105;;;;61690:33;61675:48;;;:11;:48;;;;61618:105;:172;;;;61755:35;61740:50;;;:11;:50;;;;61618:172;:225;;;;61807:36;61831:11;61807:23;:36::i;:::-;61618:225;61598:245;;61479:372;;;:::o;63002:100::-;63056:13;63089:5;63082:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63002:100;:::o;64088:214::-;64156:7;64184:16;64192:7;64184;:16::i;:::-;64176:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;64270:15;:24;64286:7;64270:24;;;;;;;;;;;;;;;;;;;;;64263:31;;64088:214;;;:::o;63667:413::-;63740:13;63756:24;63772:7;63756:15;:24::i;:::-;63740:40;;63805:5;63799:11;;:2;:11;;;63791:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;63900:5;63884:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;63909:37;63926:5;63933:12;:10;:12::i;:::-;63909:16;:37::i;:::-;63884:62;63862:169;;;;;;;;;;;;:::i;:::-;;;;;;;;;64044:28;64053:2;64057:7;64066:5;64044:8;:28::i;:::-;63729:351;63667:413;;:::o;60280:100::-;60333:7;60360:12;;60353:19;;60280:100;:::o;64777:151::-;23380:1;22206:42;23334:43;;;:47;23330:225;;;22206:42;23403:40;;;23452:4;23459:10;23403:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23398:146;;23517:10;23498:30;;;;;;;;;;;:::i;:::-;;;;;;;;23398:146;23330:225;64889:31:::1;64902:4;64908:2;64912:7;64889:12;:31::i;:::-;64777:151:::0;;;:::o;60583:886::-;60672:7;60708:16;60718:5;60708:9;:16::i;:::-;60700:5;:24;60692:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;60774:22;60799:13;:11;:13::i;:::-;60774:38;;60823:19;60853:25;60921:9;60916:466;60936:14;60932:1;:18;60916:466;;;60976:31;61010:11;:14;61022:1;61010:14;;;;;;;;;;;60976:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61073:1;61047:28;;:9;:14;;;:28;;;61043:111;;61120:9;:14;;;61100:34;;61043:111;61197:5;61176:26;;:17;:26;;;61172:195;;61246:5;61231:11;:20;61227:85;;61287:1;61280:8;;;;;;;;;61227:85;61334:13;;;;;;;61172:195;60957:425;60952:3;;;;;;;60916:466;;;;61405:56;;;;;;;;;;:::i;:::-;;;;;;;;60583:886;;;;;:::o;75638:186::-;70824:13;:11;:13::i;:::-;57962:1:::1;58112:7;;:19:::0;58104:63:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;57962:1;58180:7;:18;;;;75702:12:::2;75720:10;:15;;75743:21;75720:49;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75701:68;;;75788:7;75780:36;;;;;;;;;;;;:::i;:::-;;;;;;;;;75690:134;57918:1:::1;58225:7;:22;;;;75638:186::o:0;64936:159::-;23380:1;22206:42;23334:43;;;:47;23330:225;;;22206:42;23403:40;;;23452:4;23459:10;23403:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23398:146;;23517:10;23498:30;;;;;;;;;;;:::i;:::-;;;;;;;;23398:146;23330:225;65052:35:::1;65069:4;65075:2;65079:7;65052:16;:35::i;:::-;64936:159:::0;;;:::o;75234:85::-;70824:13;:11;:13::i;:::-;75305:6:::1;75297:5;:14;;;;75234:85:::0;:::o;72647:32::-;;;;;;;;;;;;;:::o;72905:34::-;;;;:::o;72857:41::-;;;;:::o;60388:187::-;60455:7;60491:13;:11;:13::i;:::-;60483:5;:21;60475:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;60562:5;60555:12;;60388:187;;;:::o;75419:115::-;70824:13;:11;:13::i;:::-;75517:9:::1;75496:18;;:30;;;;;;;;;;;;;;;;;;75419:115:::0;:::o;62870:124::-;62934:7;62961:20;62973:7;62961:11;:20::i;:::-;:25;;;62954:32;;62870:124;;;:::o;61859:221::-;61923:7;61968:1;61951:19;;:5;:19;;;61943:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;62044:12;:19;62057:5;62044:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;62036:36;;62029:43;;61859:221;;;:::o;71586:103::-;70824:13;:11;:13::i;:::-;71651:30:::1;71678:1;71651:18;:30::i;:::-;71586:103::o:0;72775:33::-;;;;:::o;73015:46::-;;;;;;;;;;;;;;;;;:::o;75034:87::-;70824:13;:11;:13::i;:::-;75102:11:::1;;;;;;;;;;;75101:12;75087:11;;:26;;;;;;;;;;;;;;;;;;75034:87::o:0;74599:398::-;70824:13;:11;:13::i;:::-;74672:17:::1;74692:14;;74672:34;;74753:10;;74743:6;74727:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:36;;74719:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;74828:6;74815:9;:19;;74807:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;74907:6;74895:9;:18;;;;:::i;:::-;74878:14;:35;;;;74924:29;74934:10;74946:6;74924:9;:29::i;:::-;74661:336;74599:398:::0;:::o;70938:87::-;70984:7;71011:6;;;;;;;;;;;71004:13;;70938:87;:::o;63110:104::-;63166:13;63199:7;63192:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63110:104;:::o;72723:45::-;;;;:::o;73671:920::-;73775:1;73762:10;;:14;;;;:::i;:::-;73753:6;73737:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:39;73736:89;;;;;73808:16;;73782:11;:23;73794:10;73782:23;;;;;;;;;;;;;;;;:42;73736:89;73731:767;;;73883:10;;73873:6;73857:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:36;;73849:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;73945:11;;;;;;;;;;;73937:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;74044:5;;74035;;74026:6;:14;;;;:::i;:::-;74025:24;;;;:::i;:::-;74012:9;:37;;74004:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74101:5;;74091:6;:15;;74083:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;74170:6;74143:11;:23;74155:10;74143:23;;;;;;;;;;;;;;;;:33;;;;;;;:::i;:::-;;;;;;;;73731:767;;;74247:10;;74237:6;74221:13;:11;:13::i;:::-;:22;;;;:::i;:::-;:36;;74213:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;74309:11;;;;;;;;;;;74301:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;74398:5;;74389:6;:14;;;;:::i;:::-;74376:9;:27;;74368:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;74455:5;;74445:6;:15;;74437:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;73731:767;74510:29;74520:10;74532:6;74510:9;:29::i;:::-;73671:920;:::o;75128:98::-;70824:13;:11;:13::i;:::-;75210:8:::1;75200:7;:18;;;;;;:::i;:::-;;75128:98:::0;:::o;64310:288::-;64417:12;:10;:12::i;:::-;64405:24;;:8;:24;;;64397:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;64518:8;64473:18;:32;64492:12;:10;:12::i;:::-;64473:32;;;;;;;;;;;;;;;:42;64506:8;64473:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;64571:8;64542:48;;64557:12;:10;:12::i;:::-;64542:48;;;64581:8;64542:48;;;;;;:::i;:::-;;;;;;;;64310:288;;:::o;75542:88::-;70824:13;:11;:13::i;:::-;75612:10:::1;;;;;;;;;;;75611:11;75598:10;;:24;;;;;;;;;;;;;;;;;;75542:88::o:0;72815:35::-;;;;:::o;65103:216::-;23380:1;22206:42;23334:43;;;:47;23330:225;;;22206:42;23403:40;;;23452:4;23459:10;23403:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23398:146;;23517:10;23498:30;;;;;;;;;;;:::i;:::-;;;;;;;;23398:146;23330:225;65270:41:::1;65287:4;65293:2;65297:7;65306:4;65270:16;:41::i;:::-;65103:216:::0;;;;:::o;75327:84::-;75371:7;75398:5;;75391:12;;75327:84;:::o;73127:395::-;73201:13;73235:17;73243:8;73235:7;:17::i;:::-;73227:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;73314:28;73345:10;:8;:10::i;:::-;73314:41;;73404:1;73379:14;73373:28;:32;:141;;;;;;;;;;;;;;;;;73445:14;73460:26;73477:8;73460:16;:26::i;:::-;73428:67;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73373:141;73366:148;;;73127:395;;;:::o;72975:25::-;;;;;;;;;;;;;:::o;64606:164::-;64703:4;64727:18;:25;64746:5;64727:25;;;;;;;;;;;;;;;:35;64753:8;64727:35;;;;;;;;;;;;;;;;;;;;;;;;;64720:42;;64606:164;;;;:::o;71844:201::-;70824:13;:11;:13::i;:::-;71953:1:::1;71933:22;;:8;:22;;::::0;71925:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;72009:28;72028:8;72009:18;:28::i;:::-;71844:201:::0;:::o;51350:157::-;51435:4;51474:25;51459:40;;;:11;:40;;;;51452:47;;51350:157;;;:::o;65327:111::-;65384:4;65418:12;;65408:7;:22;65401:29;;65327:111;;;:::o;58887:98::-;58940:7;58967:10;58960:17;;58887:98;:::o;68511:196::-;68653:2;68626:15;:24;68642:7;68626:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;68691:7;68687:2;68671:28;;68680:5;68671:28;;;;;;;;;;;;68511:196;;;:::o;71103:132::-;71178:12;:10;:12::i;:::-;71167:23;;:7;:5;:7::i;:::-;:23;;;71159:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;71103:132::o;62325:537::-;62386:21;;:::i;:::-;62428:16;62436:7;62428;:16::i;:::-;62420:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;62534:12;62549:7;62534:22;;62529:245;62566:1;62558:4;:9;62529:245;;62596:31;62630:11;:17;62642:4;62630:17;;;;;;;;;;;62596:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62696:1;62670:28;;:9;:14;;;:28;;;62666:93;;62730:9;62723:16;;;;;;62666:93;62577:197;62569:6;;;;;;;;62529:245;;;;62797:57;;;;;;;;;;:::i;:::-;;;;;;;;62325:537;;;;:::o;72205:191::-;72279:16;72298:6;;;;;;;;;;;72279:25;;72324:8;72315:6;;:17;;;;;;;;;;;;;;;;;;72379:8;72348:40;;72369:8;72348:40;;;;;;;;;;;;72268:128;72205:191;:::o;65446:104::-;65515:27;65525:2;65529:8;65515:27;;;;;;;;;;;;:9;:27::i;:::-;65446:104;;:::o;73530:108::-;73590:13;73623:7;73616:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73530:108;:::o;37192:716::-;37248:13;37299:14;37336:1;37316:17;37327:5;37316:10;:17::i;:::-;:21;37299:38;;37352:20;37386:6;37375:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37352:41;;37408:11;37537:6;37533:2;37529:15;37521:6;37517:28;37510:35;;37574:288;37581:4;37574:288;;;37606:5;;;;;;;;37748:8;37743:2;37736:5;37732:14;37727:30;37722:3;37714:44;37804:2;37795:11;;;;;;:::i;:::-;;;;;37838:1;37829:5;:10;37574:288;37825:21;37574:288;37883:6;37876:13;;;;;37192:716;;;:::o;65558:163::-;65681:32;65687:2;65691:8;65701:5;65708:4;65681:5;:32::i;:::-;65558:163;;;:::o;34058:922::-;34111:7;34131:14;34148:1;34131:18;;34198:6;34189:5;:15;34185:102;;34234:6;34225:15;;;;;;:::i;:::-;;;;;34269:2;34259:12;;;;34185:102;34314:6;34305:5;:15;34301:102;;34350:6;34341:15;;;;;;:::i;:::-;;;;;34385:2;34375:12;;;;34301:102;34430:6;34421:5;:15;34417:102;;34466:6;34457:15;;;;;;:::i;:::-;;;;;34501:2;34491:12;;;;34417:102;34546:5;34537;:14;34533:99;;34581:5;34572:14;;;;;;:::i;:::-;;;;;34615:1;34605:11;;;;34533:99;34659:5;34650;:14;34646:99;;34694:5;34685:14;;;;;;:::i;:::-;;;;;34728:1;34718:11;;;;34646:99;34772:5;34763;:14;34759:99;;34807:5;34798:14;;;;;;:::i;:::-;;;;;34841:1;34831:11;;;;34759:99;34885:5;34876;:14;34872:66;;34921:1;34911:11;;;;34872:66;34966:6;34959:13;;;34058:922;;;:::o;65729:1298::-;65868:20;65891:12;;65868:35;;65936:1;65922:16;;:2;:16;;;65914:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;66007:1;65995:8;:13;65987:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;66066:61;66096:1;66100:2;66104:12;66118:8;66066:21;:61::i;:::-;66201:8;66165:12;:16;66178:2;66165:16;;;;;;;;;;;;;;;:24;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66266:8;66225:12;:16;66238:2;66225:16;;;;;;;;;;;;;;;:29;;;:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66325:2;66292:11;:25;66304:12;66292:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;66392:15;66342:11;:25;66354:12;66342:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;66425:20;66448:12;66425:35;;66482:9;66477:415;66497:8;66493:1;:12;66477:415;;;66561:12;66557:2;66536:38;;66553:1;66536:38;;;;;;;;;;;;66597:4;66593:249;;;66660:59;66691:1;66695:2;66699:12;66713:5;66660:22;:59::i;:::-;66626:196;;;;;;;;;;;;:::i;:::-;;;;;;;;;66593:249;66862:14;;;;;;;66507:3;;;;;;;66477:415;;;;66923:12;66908;:27;;;;66140:807;66959:60;66988:1;66992:2;66996:12;67010:8;66959:20;:60::i;:::-;65857:1170;65729:1298;;;;:::o;69527:159::-;;;;;:::o;68715:804::-;68870:4;68891:15;:2;:13;;;:15::i;:::-;68887:625;;;68943:2;68927:36;;;68964:12;:10;:12::i;:::-;68978:4;68984:7;68993:5;68927:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;68923:534;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69190:1;69173:6;:13;:18;69169:273;;69216:61;;;;;;;;;;:::i;:::-;;;;;;;;69169:273;69392:6;69386:13;69377:6;69373:2;69369:15;69362:38;68923:534;69060:45;;;69050:55;;;:6;:55;;;;69043:62;;;;;68887:625;69496:4;69489:11;;68715:804;;;;;;;:::o;69694:158::-;;;;;:::o;40319:326::-;40379:4;40636:1;40614:7;:19;;;:23;40607:30;;40319:326;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:329::-;5926:6;5975:2;5963:9;5954:7;5950:23;5946:32;5943:119;;;5981:79;;:::i;:::-;5943:119;6101:1;6126:53;6171:7;6162:6;6151:9;6147:22;6126:53;:::i;:::-;6116:63;;6072:117;5867:329;;;;:::o;6202:117::-;6311:1;6308;6301:12;6325:117;6434:1;6431;6424:12;6448:180;6496:77;6493:1;6486:88;6593:4;6590:1;6583:15;6617:4;6614:1;6607:15;6634:281;6717:27;6739:4;6717:27;:::i;:::-;6709:6;6705:40;6847:6;6835:10;6832:22;6811:18;6799:10;6796:34;6793:62;6790:88;;;6858:18;;:::i;:::-;6790:88;6898:10;6894:2;6887:22;6677:238;6634:281;;:::o;6921:129::-;6955:6;6982:20;;:::i;:::-;6972:30;;7011:33;7039:4;7031:6;7011:33;:::i;:::-;6921:129;;;:::o;7056:308::-;7118:4;7208:18;7200:6;7197:30;7194:56;;;7230:18;;:::i;:::-;7194:56;7268:29;7290:6;7268:29;:::i;:::-;7260:37;;7352:4;7346;7342:15;7334:23;;7056:308;;;:::o;7370:146::-;7467:6;7462:3;7457;7444:30;7508:1;7499:6;7494:3;7490:16;7483:27;7370:146;;;:::o;7522:425::-;7600:5;7625:66;7641:49;7683:6;7641:49;:::i;:::-;7625:66;:::i;:::-;7616:75;;7714:6;7707:5;7700:21;7752:4;7745:5;7741:16;7790:3;7781:6;7776:3;7772:16;7769:25;7766:112;;;7797:79;;:::i;:::-;7766:112;7887:54;7934:6;7929:3;7924;7887:54;:::i;:::-;7606:341;7522:425;;;;;:::o;7967:340::-;8023:5;8072:3;8065:4;8057:6;8053:17;8049:27;8039:122;;8080:79;;:::i;:::-;8039:122;8197:6;8184:20;8222:79;8297:3;8289:6;8282:4;8274:6;8270:17;8222:79;:::i;:::-;8213:88;;8029:278;7967:340;;;;:::o;8313:509::-;8382:6;8431:2;8419:9;8410:7;8406:23;8402:32;8399:119;;;8437:79;;:::i;:::-;8399:119;8585:1;8574:9;8570:17;8557:31;8615:18;8607:6;8604:30;8601:117;;;8637:79;;:::i;:::-;8601:117;8742:63;8797:7;8788:6;8777:9;8773:22;8742:63;:::i;:::-;8732:73;;8528:287;8313:509;;;;:::o;8828:116::-;8898:21;8913:5;8898:21;:::i;:::-;8891:5;8888:32;8878:60;;8934:1;8931;8924:12;8878:60;8828:116;:::o;8950:133::-;8993:5;9031:6;9018:20;9009:29;;9047:30;9071:5;9047:30;:::i;:::-;8950:133;;;;:::o;9089:468::-;9154:6;9162;9211:2;9199:9;9190:7;9186:23;9182:32;9179:119;;;9217:79;;:::i;:::-;9179:119;9337:1;9362:53;9407:7;9398:6;9387:9;9383:22;9362:53;:::i;:::-;9352:63;;9308:117;9464:2;9490:50;9532:7;9523:6;9512:9;9508:22;9490:50;:::i;:::-;9480:60;;9435:115;9089:468;;;;;:::o;9563:307::-;9624:4;9714:18;9706:6;9703:30;9700:56;;;9736:18;;:::i;:::-;9700:56;9774:29;9796:6;9774:29;:::i;:::-;9766:37;;9858:4;9852;9848:15;9840:23;;9563:307;;;:::o;9876:423::-;9953:5;9978:65;9994:48;10035:6;9994:48;:::i;:::-;9978:65;:::i;:::-;9969:74;;10066:6;10059:5;10052:21;10104:4;10097:5;10093:16;10142:3;10133:6;10128:3;10124:16;10121:25;10118:112;;;10149:79;;:::i;:::-;10118:112;10239:54;10286:6;10281:3;10276;10239:54;:::i;:::-;9959:340;9876:423;;;;;:::o;10318:338::-;10373:5;10422:3;10415:4;10407:6;10403:17;10399:27;10389:122;;10430:79;;:::i;:::-;10389:122;10547:6;10534:20;10572:78;10646:3;10638:6;10631:4;10623:6;10619:17;10572:78;:::i;:::-;10563:87;;10379:277;10318:338;;;;:::o;10662:943::-;10757:6;10765;10773;10781;10830:3;10818:9;10809:7;10805:23;10801:33;10798:120;;;10837:79;;:::i;:::-;10798:120;10957:1;10982:53;11027:7;11018:6;11007:9;11003:22;10982:53;:::i;:::-;10972:63;;10928:117;11084:2;11110:53;11155:7;11146:6;11135:9;11131:22;11110:53;:::i;:::-;11100:63;;11055:118;11212:2;11238:53;11283:7;11274:6;11263:9;11259:22;11238:53;:::i;:::-;11228:63;;11183:118;11368:2;11357:9;11353:18;11340:32;11399:18;11391:6;11388:30;11385:117;;;11421:79;;:::i;:::-;11385:117;11526:62;11580:7;11571:6;11560:9;11556:22;11526:62;:::i;:::-;11516:72;;11311:287;10662:943;;;;;;;:::o;11611:474::-;11679:6;11687;11736:2;11724:9;11715:7;11711:23;11707:32;11704:119;;;11742:79;;:::i;:::-;11704:119;11862:1;11887:53;11932:7;11923:6;11912:9;11908:22;11887:53;:::i;:::-;11877:63;;11833:117;11989:2;12015:53;12060:7;12051:6;12040:9;12036:22;12015:53;:::i;:::-;12005:63;;11960:118;11611:474;;;;;:::o;12091:180::-;12139:77;12136:1;12129:88;12236:4;12233:1;12226:15;12260:4;12257:1;12250:15;12277:320;12321:6;12358:1;12352:4;12348:12;12338:22;;12405:1;12399:4;12395:12;12426:18;12416:81;;12482:4;12474:6;12470:17;12460:27;;12416:81;12544:2;12536:6;12533:14;12513:18;12510:38;12507:84;;12563:18;;:::i;:::-;12507:84;12328:269;12277:320;;;:::o;12603:232::-;12743:34;12739:1;12731:6;12727:14;12720:58;12812:15;12807:2;12799:6;12795:15;12788:40;12603:232;:::o;12841:366::-;12983:3;13004:67;13068:2;13063:3;13004:67;:::i;:::-;12997:74;;13080:93;13169:3;13080:93;:::i;:::-;13198:2;13193:3;13189:12;13182:19;;12841:366;;;:::o;13213:419::-;13379:4;13417:2;13406:9;13402:18;13394:26;;13466:9;13460:4;13456:20;13452:1;13441:9;13437:17;13430:47;13494:131;13620:4;13494:131;:::i;:::-;13486:139;;13213:419;;;:::o;13638:221::-;13778:34;13774:1;13766:6;13762:14;13755:58;13847:4;13842:2;13834:6;13830:15;13823:29;13638:221;:::o;13865:366::-;14007:3;14028:67;14092:2;14087:3;14028:67;:::i;:::-;14021:74;;14104:93;14193:3;14104:93;:::i;:::-;14222:2;14217:3;14213:12;14206:19;;13865:366;;;:::o;14237:419::-;14403:4;14441:2;14430:9;14426:18;14418:26;;14490:9;14484:4;14480:20;14476:1;14465:9;14461:17;14454:47;14518:131;14644:4;14518:131;:::i;:::-;14510:139;;14237:419;;;:::o;14662:244::-;14802:34;14798:1;14790:6;14786:14;14779:58;14871:27;14866:2;14858:6;14854:15;14847:52;14662:244;:::o;14912:366::-;15054:3;15075:67;15139:2;15134:3;15075:67;:::i;:::-;15068:74;;15151:93;15240:3;15151:93;:::i;:::-;15269:2;15264:3;15260:12;15253:19;;14912:366;;;:::o;15284:419::-;15450:4;15488:2;15477:9;15473:18;15465:26;;15537:9;15531:4;15527:20;15523:1;15512:9;15508:17;15501:47;15565:131;15691:4;15565:131;:::i;:::-;15557:139;;15284:419;;;:::o;15709:332::-;15830:4;15868:2;15857:9;15853:18;15845:26;;15881:71;15949:1;15938:9;15934:17;15925:6;15881:71;:::i;:::-;15962:72;16030:2;16019:9;16015:18;16006:6;15962:72;:::i;:::-;15709:332;;;;;:::o;16047:137::-;16101:5;16132:6;16126:13;16117:22;;16148:30;16172:5;16148:30;:::i;:::-;16047:137;;;;:::o;16190:345::-;16257:6;16306:2;16294:9;16285:7;16281:23;16277:32;16274:119;;;16312:79;;:::i;:::-;16274:119;16432:1;16457:61;16510:7;16501:6;16490:9;16486:22;16457:61;:::i;:::-;16447:71;;16403:125;16190:345;;;;:::o;16541:221::-;16681:34;16677:1;16669:6;16665:14;16658:58;16750:4;16745:2;16737:6;16733:15;16726:29;16541:221;:::o;16768:366::-;16910:3;16931:67;16995:2;16990:3;16931:67;:::i;:::-;16924:74;;17007:93;17096:3;17007:93;:::i;:::-;17125:2;17120:3;17116:12;17109:19;;16768:366;;;:::o;17140:419::-;17306:4;17344:2;17333:9;17329:18;17321:26;;17393:9;17387:4;17383:20;17379:1;17368:9;17364:17;17357:47;17421:131;17547:4;17421:131;:::i;:::-;17413:139;;17140:419;;;:::o;17565:233::-;17705:34;17701:1;17693:6;17689:14;17682:58;17774:16;17769:2;17761:6;17757:15;17750:41;17565:233;:::o;17804:366::-;17946:3;17967:67;18031:2;18026:3;17967:67;:::i;:::-;17960:74;;18043:93;18132:3;18043:93;:::i;:::-;18161:2;18156:3;18152:12;18145:19;;17804:366;;;:::o;18176:419::-;18342:4;18380:2;18369:9;18365:18;18357:26;;18429:9;18423:4;18419:20;18415:1;18404:9;18400:17;18393:47;18457:131;18583:4;18457:131;:::i;:::-;18449:139;;18176:419;;;:::o;18601:181::-;18741:33;18737:1;18729:6;18725:14;18718:57;18601:181;:::o;18788:366::-;18930:3;18951:67;19015:2;19010:3;18951:67;:::i;:::-;18944:74;;19027:93;19116:3;19027:93;:::i;:::-;19145:2;19140:3;19136:12;19129:19;;18788:366;;;:::o;19160:419::-;19326:4;19364:2;19353:9;19349:18;19341:26;;19413:9;19407:4;19403:20;19399:1;19388:9;19384:17;19377:47;19441:131;19567:4;19441:131;:::i;:::-;19433:139;;19160:419;;;:::o;19585:147::-;19686:11;19723:3;19708:18;;19585:147;;;;:::o;19738:114::-;;:::o;19858:398::-;20017:3;20038:83;20119:1;20114:3;20038:83;:::i;:::-;20031:90;;20130:93;20219:3;20130:93;:::i;:::-;20248:1;20243:3;20239:11;20232:18;;19858:398;;;:::o;20262:379::-;20446:3;20468:147;20611:3;20468:147;:::i;:::-;20461:154;;20632:3;20625:10;;20262:379;;;:::o;20647:166::-;20787:18;20783:1;20775:6;20771:14;20764:42;20647:166;:::o;20819:366::-;20961:3;20982:67;21046:2;21041:3;20982:67;:::i;:::-;20975:74;;21058:93;21147:3;21058:93;:::i;:::-;21176:2;21171:3;21167:12;21160:19;;20819:366;;;:::o;21191:419::-;21357:4;21395:2;21384:9;21380:18;21372:26;;21444:9;21438:4;21434:20;21430:1;21419:9;21415:17;21408:47;21472:131;21598:4;21472:131;:::i;:::-;21464:139;;21191:419;;;:::o;21616:222::-;21756:34;21752:1;21744:6;21740:14;21733:58;21825:5;21820:2;21812:6;21808:15;21801:30;21616:222;:::o;21844:366::-;21986:3;22007:67;22071:2;22066:3;22007:67;:::i;:::-;22000:74;;22083:93;22172:3;22083:93;:::i;:::-;22201:2;22196:3;22192:12;22185:19;;21844:366;;;:::o;22216:419::-;22382:4;22420:2;22409:9;22405:18;22397:26;;22469:9;22463:4;22459:20;22455:1;22444:9;22440:17;22433:47;22497:131;22623:4;22497:131;:::i;:::-;22489:139;;22216:419;;;:::o;22641:230::-;22781:34;22777:1;22769:6;22765:14;22758:58;22850:13;22845:2;22837:6;22833:15;22826:38;22641:230;:::o;22877:366::-;23019:3;23040:67;23104:2;23099:3;23040:67;:::i;:::-;23033:74;;23116:93;23205:3;23116:93;:::i;:::-;23234:2;23229:3;23225:12;23218:19;;22877:366;;;:::o;23249:419::-;23415:4;23453:2;23442:9;23438:18;23430:26;;23502:9;23496:4;23492:20;23488:1;23477:9;23473:17;23466:47;23530:131;23656:4;23530:131;:::i;:::-;23522:139;;23249:419;;;:::o;23674:180::-;23722:77;23719:1;23712:88;23819:4;23816:1;23809:15;23843:4;23840:1;23833:15;23860:191;23900:3;23919:20;23937:1;23919:20;:::i;:::-;23914:25;;23953:20;23971:1;23953:20;:::i;:::-;23948:25;;23996:1;23993;23989:9;23982:16;;24017:3;24014:1;24011:10;24008:36;;;24024:18;;:::i;:::-;24008:36;23860:191;;;;:::o;24057:178::-;24197:30;24193:1;24185:6;24181:14;24174:54;24057:178;:::o;24241:366::-;24383:3;24404:67;24468:2;24463:3;24404:67;:::i;:::-;24397:74;;24480:93;24569:3;24480:93;:::i;:::-;24598:2;24593:3;24589:12;24582:19;;24241:366;;;:::o;24613:419::-;24779:4;24817:2;24806:9;24802:18;24794:26;;24866:9;24860:4;24856:20;24852:1;24841:9;24837:17;24830:47;24894:131;25020:4;24894:131;:::i;:::-;24886:139;;24613:419;;;:::o;25038:172::-;25178:24;25174:1;25166:6;25162:14;25155:48;25038:172;:::o;25216:366::-;25358:3;25379:67;25443:2;25438:3;25379:67;:::i;:::-;25372:74;;25455:93;25544:3;25455:93;:::i;:::-;25573:2;25568:3;25564:12;25557:19;;25216:366;;;:::o;25588:419::-;25754:4;25792:2;25781:9;25777:18;25769:26;;25841:9;25835:4;25831:20;25827:1;25816:9;25812:17;25805:47;25869:131;25995:4;25869:131;:::i;:::-;25861:139;;25588:419;;;:::o;26013:194::-;26053:4;26073:20;26091:1;26073:20;:::i;:::-;26068:25;;26107:20;26125:1;26107:20;:::i;:::-;26102:25;;26151:1;26148;26144:9;26136:17;;26175:1;26169:4;26166:11;26163:37;;;26180:18;;:::i;:::-;26163:37;26013:194;;;;:::o;26213:182::-;26353:34;26349:1;26341:6;26337:14;26330:58;26213:182;:::o;26401:366::-;26543:3;26564:67;26628:2;26623:3;26564:67;:::i;:::-;26557:74;;26640:93;26729:3;26640:93;:::i;:::-;26758:2;26753:3;26749:12;26742:19;;26401:366;;;:::o;26773:419::-;26939:4;26977:2;26966:9;26962:18;26954:26;;27026:9;27020:4;27016:20;27012:1;27001:9;26997:17;26990:47;27054:131;27180:4;27054:131;:::i;:::-;27046:139;;26773:419;;;:::o;27198:410::-;27238:7;27261:20;27279:1;27261:20;:::i;:::-;27256:25;;27295:20;27313:1;27295:20;:::i;:::-;27290:25;;27350:1;27347;27343:9;27372:30;27390:11;27372:30;:::i;:::-;27361:41;;27551:1;27542:7;27538:15;27535:1;27532:22;27512:1;27505:9;27485:83;27462:139;;27581:18;;:::i;:::-;27462:139;27246:362;27198:410;;;;:::o;27614:168::-;27754:20;27750:1;27742:6;27738:14;27731:44;27614:168;:::o;27788:366::-;27930:3;27951:67;28015:2;28010:3;27951:67;:::i;:::-;27944:74;;28027:93;28116:3;28027:93;:::i;:::-;28145:2;28140:3;28136:12;28129:19;;27788:366;;;:::o;28160:419::-;28326:4;28364:2;28353:9;28349:18;28341:26;;28413:9;28407:4;28403:20;28399:1;28388:9;28384:17;28377:47;28441:131;28567:4;28441:131;:::i;:::-;28433:139;;28160:419;;;:::o;28585:171::-;28725:23;28721:1;28713:6;28709:14;28702:47;28585:171;:::o;28762:366::-;28904:3;28925:67;28989:2;28984:3;28925:67;:::i;:::-;28918:74;;29001:93;29090:3;29001:93;:::i;:::-;29119:2;29114:3;29110:12;29103:19;;28762:366;;;:::o;29134:419::-;29300:4;29338:2;29327:9;29323:18;29315:26;;29387:9;29381:4;29377:20;29373:1;29362:9;29358:17;29351:47;29415:131;29541:4;29415:131;:::i;:::-;29407:139;;29134:419;;;:::o;29559:141::-;29608:4;29631:3;29623:11;;29654:3;29651:1;29644:14;29688:4;29685:1;29675:18;29667:26;;29559:141;;;:::o;29706:93::-;29743:6;29790:2;29785;29778:5;29774:14;29770:23;29760:33;;29706:93;;;:::o;29805:107::-;29849:8;29899:5;29893:4;29889:16;29868:37;;29805:107;;;;:::o;29918:393::-;29987:6;30037:1;30025:10;30021:18;30060:97;30090:66;30079:9;30060:97;:::i;:::-;30178:39;30208:8;30197:9;30178:39;:::i;:::-;30166:51;;30250:4;30246:9;30239:5;30235:21;30226:30;;30299:4;30289:8;30285:19;30278:5;30275:30;30265:40;;29994:317;;29918:393;;;;;:::o;30317:60::-;30345:3;30366:5;30359:12;;30317:60;;;:::o;30383:142::-;30433:9;30466:53;30484:34;30493:24;30511:5;30493:24;:::i;:::-;30484:34;:::i;:::-;30466:53;:::i;:::-;30453:66;;30383:142;;;:::o;30531:75::-;30574:3;30595:5;30588:12;;30531:75;;;:::o;30612:269::-;30722:39;30753:7;30722:39;:::i;:::-;30783:91;30832:41;30856:16;30832:41;:::i;:::-;30824:6;30817:4;30811:11;30783:91;:::i;:::-;30777:4;30770:105;30688:193;30612:269;;;:::o;30887:73::-;30932:3;30887:73;:::o;30966:189::-;31043:32;;:::i;:::-;31084:65;31142:6;31134;31128:4;31084:65;:::i;:::-;31019:136;30966:189;;:::o;31161:186::-;31221:120;31238:3;31231:5;31228:14;31221:120;;;31292:39;31329:1;31322:5;31292:39;:::i;:::-;31265:1;31258:5;31254:13;31245:22;;31221:120;;;31161:186;;:::o;31353:543::-;31454:2;31449:3;31446:11;31443:446;;;31488:38;31520:5;31488:38;:::i;:::-;31572:29;31590:10;31572:29;:::i;:::-;31562:8;31558:44;31755:2;31743:10;31740:18;31737:49;;;31776:8;31761:23;;31737:49;31799:80;31855:22;31873:3;31855:22;:::i;:::-;31845:8;31841:37;31828:11;31799:80;:::i;:::-;31458:431;;31443:446;31353:543;;;:::o;31902:117::-;31956:8;32006:5;32000:4;31996:16;31975:37;;31902:117;;;;:::o;32025:169::-;32069:6;32102:51;32150:1;32146:6;32138:5;32135:1;32131:13;32102:51;:::i;:::-;32098:56;32183:4;32177;32173:15;32163:25;;32076:118;32025:169;;;;:::o;32199:295::-;32275:4;32421:29;32446:3;32440:4;32421:29;:::i;:::-;32413:37;;32483:3;32480:1;32476:11;32470:4;32467:21;32459:29;;32199:295;;;;:::o;32499:1395::-;32616:37;32649:3;32616:37;:::i;:::-;32718:18;32710:6;32707:30;32704:56;;;32740:18;;:::i;:::-;32704:56;32784:38;32816:4;32810:11;32784:38;:::i;:::-;32869:67;32929:6;32921;32915:4;32869:67;:::i;:::-;32963:1;32987:4;32974:17;;33019:2;33011:6;33008:14;33036:1;33031:618;;;;33693:1;33710:6;33707:77;;;33759:9;33754:3;33750:19;33744:26;33735:35;;33707:77;33810:67;33870:6;33863:5;33810:67;:::i;:::-;33804:4;33797:81;33666:222;33001:887;;33031:618;33083:4;33079:9;33071:6;33067:22;33117:37;33149:4;33117:37;:::i;:::-;33176:1;33190:208;33204:7;33201:1;33198:14;33190:208;;;33283:9;33278:3;33274:19;33268:26;33260:6;33253:42;33334:1;33326:6;33322:14;33312:24;;33381:2;33370:9;33366:18;33353:31;;33227:4;33224:1;33220:12;33215:17;;33190:208;;;33426:6;33417:7;33414:19;33411:179;;;33484:9;33479:3;33475:19;33469:26;33527:48;33569:4;33561:6;33557:17;33546:9;33527:48;:::i;:::-;33519:6;33512:64;33434:156;33411:179;33636:1;33632;33624:6;33620:14;33616:22;33610:4;33603:36;33038:611;;;33001:887;;32591:1303;;;32499:1395;;:::o;33900:176::-;34040:28;34036:1;34028:6;34024:14;34017:52;33900:176;:::o;34082:366::-;34224:3;34245:67;34309:2;34304:3;34245:67;:::i;:::-;34238:74;;34321:93;34410:3;34321:93;:::i;:::-;34439:2;34434:3;34430:12;34423:19;;34082:366;;;:::o;34454:419::-;34620:4;34658:2;34647:9;34643:18;34635:26;;34707:9;34701:4;34697:20;34693:1;34682:9;34678:17;34671:47;34735:131;34861:4;34735:131;:::i;:::-;34727:139;;34454:419;;;:::o;34879:234::-;35019:34;35015:1;35007:6;35003:14;34996:58;35088:17;35083:2;35075:6;35071:15;35064:42;34879:234;:::o;35119:366::-;35261:3;35282:67;35346:2;35341:3;35282:67;:::i;:::-;35275:74;;35358:93;35447:3;35358:93;:::i;:::-;35476:2;35471:3;35467:12;35460:19;;35119:366;;;:::o;35491:419::-;35657:4;35695:2;35684:9;35680:18;35672:26;;35744:9;35738:4;35734:20;35730:1;35719:9;35715:17;35708:47;35772:131;35898:4;35772:131;:::i;:::-;35764:139;;35491:419;;;:::o;35916:148::-;36018:11;36055:3;36040:18;;35916:148;;;;:::o;36070:390::-;36176:3;36204:39;36237:5;36204:39;:::i;:::-;36259:89;36341:6;36336:3;36259:89;:::i;:::-;36252:96;;36357:65;36415:6;36410:3;36403:4;36396:5;36392:16;36357:65;:::i;:::-;36447:6;36442:3;36438:16;36431:23;;36180:280;36070:390;;;;:::o;36466:155::-;36606:7;36602:1;36594:6;36590:14;36583:31;36466:155;:::o;36627:400::-;36787:3;36808:84;36890:1;36885:3;36808:84;:::i;:::-;36801:91;;36901:93;36990:3;36901:93;:::i;:::-;37019:1;37014:3;37010:11;37003:18;;36627:400;;;:::o;37033:701::-;37314:3;37336:95;37427:3;37418:6;37336:95;:::i;:::-;37329:102;;37448:95;37539:3;37530:6;37448:95;:::i;:::-;37441:102;;37560:148;37704:3;37560:148;:::i;:::-;37553:155;;37725:3;37718:10;;37033:701;;;;;:::o;37740:225::-;37880:34;37876:1;37868:6;37864:14;37857:58;37949:8;37944:2;37936:6;37932:15;37925:33;37740:225;:::o;37971:366::-;38113:3;38134:67;38198:2;38193:3;38134:67;:::i;:::-;38127:74;;38210:93;38299:3;38210:93;:::i;:::-;38328:2;38323:3;38319:12;38312:19;;37971:366;;;:::o;38343:419::-;38509:4;38547:2;38536:9;38532:18;38524:26;;38596:9;38590:4;38586:20;38582:1;38571:9;38567:17;38560:47;38624:131;38750:4;38624:131;:::i;:::-;38616:139;;38343:419;;;:::o;38768:182::-;38908:34;38904:1;38896:6;38892:14;38885:58;38768:182;:::o;38956:366::-;39098:3;39119:67;39183:2;39178:3;39119:67;:::i;:::-;39112:74;;39195:93;39284:3;39195:93;:::i;:::-;39313:2;39308:3;39304:12;39297:19;;38956:366;;;:::o;39328:419::-;39494:4;39532:2;39521:9;39517:18;39509:26;;39581:9;39575:4;39571:20;39567:1;39556:9;39552:17;39545:47;39609:131;39735:4;39609:131;:::i;:::-;39601:139;;39328:419;;;:::o;39753:229::-;39893:34;39889:1;39881:6;39877:14;39870:58;39962:12;39957:2;39949:6;39945:15;39938:37;39753:229;:::o;39988:366::-;40130:3;40151:67;40215:2;40210:3;40151:67;:::i;:::-;40144:74;;40227:93;40316:3;40227:93;:::i;:::-;40345:2;40340:3;40336:12;40329:19;;39988:366;;;:::o;40360:419::-;40526:4;40564:2;40553:9;40549:18;40541:26;;40613:9;40607:4;40603:20;40599:1;40588:9;40584:17;40577:47;40641:131;40767:4;40641:131;:::i;:::-;40633:139;;40360:419;;;:::o;40785:234::-;40925:34;40921:1;40913:6;40909:14;40902:58;40994:17;40989:2;40981:6;40977:15;40970:42;40785:234;:::o;41025:366::-;41167:3;41188:67;41252:2;41247:3;41188:67;:::i;:::-;41181:74;;41264:93;41353:3;41264:93;:::i;:::-;41382:2;41377:3;41373:12;41366:19;;41025:366;;;:::o;41397:419::-;41563:4;41601:2;41590:9;41586:18;41578:26;;41650:9;41644:4;41640:20;41636:1;41625:9;41621:17;41614:47;41678:131;41804:4;41678:131;:::i;:::-;41670:139;;41397:419;;;:::o;41822:180::-;41870:77;41867:1;41860:88;41967:4;41964:1;41957:15;41991:4;41988:1;41981:15;42008:220;42148:34;42144:1;42136:6;42132:14;42125:58;42217:3;42212:2;42204:6;42200:15;42193:28;42008:220;:::o;42234:366::-;42376:3;42397:67;42461:2;42456:3;42397:67;:::i;:::-;42390:74;;42473:93;42562:3;42473:93;:::i;:::-;42591:2;42586:3;42582:12;42575:19;;42234:366;;;:::o;42606:419::-;42772:4;42810:2;42799:9;42795:18;42787:26;;42859:9;42853:4;42849:20;42845:1;42834:9;42830:17;42823:47;42887:131;43013:4;42887:131;:::i;:::-;42879:139;;42606:419;;;:::o;43031:227::-;43171:34;43167:1;43159:6;43155:14;43148:58;43240:10;43235:2;43227:6;43223:15;43216:35;43031:227;:::o;43264:366::-;43406:3;43427:67;43491:2;43486:3;43427:67;:::i;:::-;43420:74;;43503:93;43592:3;43503:93;:::i;:::-;43621:2;43616:3;43612:12;43605:19;;43264:366;;;:::o;43636:419::-;43802:4;43840:2;43829:9;43825:18;43817:26;;43889:9;43883:4;43879:20;43875:1;43864:9;43860:17;43853:47;43917:131;44043:4;43917:131;:::i;:::-;43909:139;;43636:419;;;:::o;44061:238::-;44201:34;44197:1;44189:6;44185:14;44178:58;44270:21;44265:2;44257:6;44253:15;44246:46;44061:238;:::o;44305:366::-;44447:3;44468:67;44532:2;44527:3;44468:67;:::i;:::-;44461:74;;44544:93;44633:3;44544:93;:::i;:::-;44662:2;44657:3;44653:12;44646:19;;44305:366;;;:::o;44677:419::-;44843:4;44881:2;44870:9;44866:18;44858:26;;44930:9;44924:4;44920:20;44916:1;44905:9;44901:17;44894:47;44958:131;45084:4;44958:131;:::i;:::-;44950:139;;44677:419;;;:::o;45102:98::-;45153:6;45187:5;45181:12;45171:22;;45102:98;;;:::o;45206:168::-;45289:11;45323:6;45318:3;45311:19;45363:4;45358:3;45354:14;45339:29;;45206:168;;;;:::o;45380:373::-;45466:3;45494:38;45526:5;45494:38;:::i;:::-;45548:70;45611:6;45606:3;45548:70;:::i;:::-;45541:77;;45627:65;45685:6;45680:3;45673:4;45666:5;45662:16;45627:65;:::i;:::-;45717:29;45739:6;45717:29;:::i;:::-;45712:3;45708:39;45701:46;;45470:283;45380:373;;;;:::o;45759:640::-;45954:4;45992:3;45981:9;45977:19;45969:27;;46006:71;46074:1;46063:9;46059:17;46050:6;46006:71;:::i;:::-;46087:72;46155:2;46144:9;46140:18;46131:6;46087:72;:::i;:::-;46169;46237:2;46226:9;46222:18;46213:6;46169:72;:::i;:::-;46288:9;46282:4;46278:20;46273:2;46262:9;46258:18;46251:48;46316:76;46387:4;46378:6;46316:76;:::i;:::-;46308:84;;45759:640;;;;;;;:::o;46405:141::-;46461:5;46492:6;46486:13;46477:22;;46508:32;46534:5;46508:32;:::i;:::-;46405:141;;;;:::o;46552:349::-;46621:6;46670:2;46658:9;46649:7;46645:23;46641:32;46638:119;;;46676:79;;:::i;:::-;46638:119;46796:1;46821:63;46876:7;46867:6;46856:9;46852:22;46821:63;:::i;:::-;46811:73;;46767:127;46552:349;;;;:::o

Swarm Source

ipfs://c4d37466d2e67862193025f9d85b9e13044911213c626f5dfac30d042a0e107f

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