Token

ChainPots (POT)

ERC-721

NFT

Overview

Max Total Supply

1,024 POT

Holders

247

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x03ce4a39dd1146d052934836f73e2d7f82ab5bba

Filtered by Token Holder

0xc55ba66cab0298B3A67e1D0bf6A1613907941B09

Balance

2 POT

0xc55ba66cab0298b3a67e1d0bf6a1613907941b09

OVERVIEW

Generative NFT collection by memorycollect0r (infrastructure and software development) and kusakari (licensed, allowed work) with limited supply and the scripts stored on Ethereum Blockchain. Inspired by on-chain art platform "Art Blocks''.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ChainPots

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-07-16
*/

// ChainPots.com - Generative NFT Collection by memorycollector 
// twitter.com/memorycollect0r
// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/utils/Strings.sol



pragma solidity ^0.8.0;

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

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

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

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

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

}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/utils/EnumerableMap.sol




pragma solidity ^0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

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

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

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

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

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

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

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

   /**
    * @dev Returns the element 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(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/utils/EnumerableSet.sol




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.
 */
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;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            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] = toDeleteIndex + 1; // All indexes are 1-based

            // 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) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // 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);
    }

    // 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))));
    }


    // 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 on 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));
    }
}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/utils/Address.sol




pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/introspection/ERC165.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: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/token/ERC721/IERC721.sol


pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(type(IERC165).interfaceId);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol




pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.0;

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

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/token/ERC721/IERC721Enumerable.sol




pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/token/ERC721/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: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/introspection/IERC165.sol



// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/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 GSN 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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}



// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/token/ERC721/ERC721.sol




pragma solidity ^0.8.0;











/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;
    
    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    
    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

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

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(type(IERC721).interfaceId);
        _registerInterface(type(IERC721Metadata).interfaceId);
        _registerInterface(type(IERC721Enumerable).interfaceId);
    }

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

    
 
    
    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);
        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

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

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

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



// File: http://github.com/OpenZeppelin/openzeppelin-contracts/contracts/access/Ownable.sol




pragma solidity ^0.8.0;

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

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



    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/contracts/utils/math/SafeMath.sol




pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}






pragma solidity ^0.8.0;


// SPDX-License-Identifier: UNLICENSED

contract ChainPots is ERC721, Ownable {
    using SafeMath for uint256;
    using Strings for uint256;
    uint public constant MAX_POTS = 1024;
    bool public hasSaleStarted = false;
    mapping (uint256 => uint256) public creationDates;
    
    
    // these will be set in future
    string public METADATA_PROVENANCE_HASH = "";
    string public GENERATOR_ADDRESS = "https://chainpots.com/generator/";
    string public IPFS_GENERATOR_ADDRESS = "";

    constructor() ERC721("ChainPots","POT")  {
        setBaseURI("https://chainpots.com/api/token/");
        _safeMint(msg.sender, 0);
        creationDates[0] = block.number;
    }
    
    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }
    
    function calculatePrice() public view returns (uint256) {
        return 50000000000000000;
    }
    
   function mintPots(uint256 maxPOTS) public payable {
        require(totalSupply() < MAX_POTS, "Sale has already ended");
        require(maxPOTS > 0 && maxPOTS <= 20, "You can claim minimum 1, maximum 20 stairs");
        require(totalSupply().add(maxPOTS) <= MAX_POTS, "Exceeds MAX_POTS");
        require(msg.value >= calculatePrice().mul(maxPOTS), "Ether value sent is below the price");

        for (uint i = 0; i < maxPOTS; i++) {
            uint mintIndex = totalSupply();
            _safeMint(msg.sender, mintIndex);
            creationDates[mintIndex] = block.number;
        }
    }
    
    // ONLYOWNER FUNCTIONS
    
    function setProvenanceHash(string memory _hash) public onlyOwner {
        METADATA_PROVENANCE_HASH = _hash;
    }
    
    function setGeneratorIPFSHash(string memory _hash) public onlyOwner {
        IPFS_GENERATOR_ADDRESS = _hash;
    }
    
    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }
    
    function startDrop() public onlyOwner {
        hasSaleStarted = true;
    }
    
    function pauseDrop() public onlyOwner {
        hasSaleStarted = false;
    }
    
    function withdrawAll() public payable onlyOwner {
        require(payable(msg.sender).send(address(this).balance));
    }
    
    function tokenHash(uint256 tokenId) public view returns(bytes32){
        require(_exists(tokenId), "DOES NOT EXIST");
        return bytes32(keccak256(abi.encodePacked(address(this), creationDates[tokenId], tokenId)));
    }
    
    function generatorAddress(uint256 tokenId) public view returns (string memory) {
        require(_exists(tokenId), "DOES NOT EXIST");
        return string(abi.encodePacked(GENERATOR_ADDRESS, tokenId.toString()));
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"GENERATOR_ADDRESS","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"IPFS_GENERATOR_ADDRESS","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_POTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"METADATA_PROVENANCE_HASH","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculatePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"creationDates","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"generatorAddress","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hasSaleStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxPOTS","type":"uint256"}],"name":"mintPots","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"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":"string","name":"_hash","type":"string"}],"name":"setGeneratorIPFSHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"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":"withdrawAll","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

66178:3131:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31844:150;;;;;;;;;;-1:-1:-1;31844:150:0;;;;;:::i;:::-;-1:-1:-1;;;;;;31953:33:0;31929:4;31953:33;;;;;;;;;;;;;;31844:150;;;;8173:14:1;;8166:22;8148:41;;8136:2;8121:18;31844:150:0;;;;;;;;43557:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46343:221::-;;;;;;;;;;-1:-1:-1;46343:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;6831:32:1;;;6813:51;;6801:2;6786:18;46343:221:0;6768:102:1;45873:404:0;;;;;;;;;;-1:-1:-1;45873:404:0;;;;;:::i;:::-;;:::i;:::-;;68160:116;;;;;;;;;;-1:-1:-1;68160:116:0;;;;;:::i;:::-;;:::i;45351:211::-;;;;;;;;;;;;;:::i;:::-;;;8346:25:1;;;8334:2;8319:18;45351:211:0;8301:76:1;66331:34:0;;;;;;;;;;-1:-1:-1;66331:34:0;;;;-1:-1:-1;;;66331:34:0;;;;;;47233:305;;;;;;;;;;-1:-1:-1;47233:305:0;;;;;:::i;:::-;;:::i;68618:79::-;;;;;;;;;;;;;:::i;66526:68::-;;;;;;;;;;;;;:::i;45113:162::-;;;;;;;;;;-1:-1:-1;45113:162:0;;;;;:::i;:::-;;:::i;68528:78::-;;;;;;;;;;;;;:::i;47609:151::-;;;;;;;;;;-1:-1:-1;47609:151:0;;;;;:::i;:::-;;:::i;45639:172::-;;;;;;;;;;-1:-1:-1;45639:172:0;;;;;:::i;:::-;;:::i;68417:99::-;;;;;;;;;;-1:-1:-1;68417:99:0;;;;;:::i;:::-;;:::i;43313:177::-;;;;;;;;;;-1:-1:-1;43313:177:0;;;;;:::i;:::-;;:::i;69084:222::-;;;;;;;;;;-1:-1:-1;69084:222:0;;;;;:::i;:::-;;:::i;44932:97::-;;;;;;;;;;;;;:::i;43003:221::-;;;;;;;;;;-1:-1:-1;43003:221:0;;;;;:::i;:::-;;:::i;58418:148::-;;;;;;;;;;;;;:::i;66601:41::-;;;;;;;;;;;;;:::i;66846:540::-;;;;;;;;;;-1:-1:-1;66846:540:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;68709:123::-;;;:::i;68288:117::-;;;;;;;;;;-1:-1:-1;68288:117:0;;;;;:::i;:::-;;:::i;57767:87::-;;;;;;;;;;-1:-1:-1;57840:6:0;;-1:-1:-1;;;;;57840:6:0;57767:87;;43726:104;;;;;;;;;;;;;:::i;46636:295::-;;;;;;;;;;-1:-1:-1;46636:295:0;;;;;:::i;:::-;;:::i;68844:228::-;;;;;;;;;;-1:-1:-1;68844:228:0;;;;;:::i;:::-;;:::i;47831:285::-;;;;;;;;;;-1:-1:-1;47831:285:0;;;;;:::i;:::-;;:::i;43901:792::-;;;;;;;;;;-1:-1:-1;43901:792:0;;;;;:::i;:::-;;:::i;66372:49::-;;;;;;;;;;-1:-1:-1;66372:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;67398:99;;;;;;;;;;-1:-1:-1;67472:17:0;67398:99;;67508:606;;;;;;:::i;:::-;;:::i;47002:164::-;;;;;;;;;;-1:-1:-1;47002:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;47123:25:0;;;47099:4;47123:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47002:164;66476:43;;;;;;;;;;;;;:::i;58721:244::-;;;;;;;;;;-1:-1:-1;58721:244:0;;;;;:::i;:::-;;:::i;66288:36::-;;;;;;;;;;;;66320:4;66288:36;;43557:100;43611:13;43644:5;43637:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43557:100;:::o;46343:221::-;46419:7;46447:16;46455:7;46447;:16::i;:::-;46439:73;;;;-1:-1:-1;;;46439:73:0;;13570:2:1;46439:73:0;;;13552:21:1;13609:2;13589:18;;;13582:30;13648:34;13628:18;;;13621:62;-1:-1:-1;;;13699:18:1;;;13692:42;13751:19;;46439:73:0;;;;;;;;;-1:-1:-1;46532:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46532:24:0;;46343:221::o;45873:404::-;45954:13;45970:23;45985:7;45970:14;:23::i;:::-;45954:39;;46018:5;-1:-1:-1;;;;;46012:11:0;:2;-1:-1:-1;;;;;46012:11:0;;;46004:57;;;;-1:-1:-1;;;46004:57:0;;15926:2:1;46004:57:0;;;15908:21:1;15965:2;15945:18;;;15938:30;16004:34;15984:18;;;15977:62;-1:-1:-1;;;16055:18:1;;;16048:31;16096:19;;46004:57:0;15898:223:1;46004:57:0;40855:10;-1:-1:-1;;;;;46082:21:0;;;;:69;;-1:-1:-1;46107:44:0;46131:5;40855:10;47002:164;:::i;46107:44::-;46074:161;;;;-1:-1:-1;;;46074:161:0;;11566:2:1;46074:161:0;;;11548:21:1;11605:2;11585:18;;;11578:30;11644:34;11624:18;;;11617:62;11715:26;11695:18;;;11688:54;11759:19;;46074:161:0;11538:246:1;46074:161:0;46248:21;46257:2;46261:7;46248:8;:21::i;:::-;45873:404;;;:::o;68160:116::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68236:32;;::::1;::::0;:24:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;:::-;;68160:116:::0;:::o;45351:211::-;45412:7;45533:21;:12;:19;:21::i;:::-;45526:28;;45351:211;:::o;47233:305::-;47394:41;40855:10;47427:7;47394:18;:41::i;:::-;47386:103;;;;-1:-1:-1;;;47386:103:0;;;;;;;:::i;:::-;47502:28;47512:4;47518:2;47522:7;47502:9;:28::i;68618:79::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68667:14:::1;:22:::0;;-1:-1:-1;;;;68667:22:0::1;::::0;;68618:79::o;66526:68::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45113:162::-;-1:-1:-1;;;;;45237:20:0;;45210:7;45237:20;;;:13;:20;;;;;:30;;45261:5;45237:23;:30::i;:::-;45230:37;;45113:162;;;;;:::o;68528:78::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68577:14:::1;:21:::0;;-1:-1:-1;;;;68577:21:0::1;-1:-1:-1::0;;;68577:21:0::1;::::0;;68528:78::o;47609:151::-;47713:39;47730:4;47736:2;47740:7;47713:39;;;;;;;;;;;;:16;:39::i;45639:172::-;45714:7;;45756:22;:12;45772:5;45756:15;:22::i;:::-;-1:-1:-1;45734:44:0;45639:172;-1:-1:-1;;;45639:172:0:o;68417:99::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68488:20:::1;68500:7;68488:11;:20::i;:::-;68417:99:::0;:::o;43313:177::-;43385:7;43412:70;43429:7;43412:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;69084:222::-;69148:13;69182:16;69190:7;69182;:16::i;:::-;69174:43;;;;-1:-1:-1;;;69174:43:0;;17097:2:1;69174:43:0;;;17079:21:1;17136:2;17116:18;;;17109:30;-1:-1:-1;;;17155:18:1;;;17148:44;17209:18;;69174:43:0;17069:164:1;69174:43:0;69259:17;69278:18;:7;:16;:18::i;:::-;69242:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;69228:70;;69084:222;;;:::o;44932:97::-;44980:13;45013:8;45006:15;;;;;:::i;43003:221::-;43075:7;-1:-1:-1;;;;;43103:19:0;;43095:74;;;;-1:-1:-1;;;43095:74:0;;11991:2:1;43095:74:0;;;11973:21:1;12030:2;12010:18;;;12003:30;12069:34;12049:18;;;12042:62;-1:-1:-1;;;12120:18:1;;;12113:40;12170:19;;43095:74:0;11963:232:1;43095:74:0;-1:-1:-1;;;;;43187:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;58418:148::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;58509:6:::1;::::0;58488:40:::1;::::0;58525:1:::1;::::0;-1:-1:-1;;;;;58509:6:0::1;::::0;58488:40:::1;::::0;58525:1;;58488:40:::1;58539:6;:19:::0;;-1:-1:-1;;;;;;58539:19:0::1;::::0;;58418:148::o;66601:41::-;;;;;;;:::i;66846:540::-;66907:16;66937:18;66958:17;66968:6;66958:9;:17::i;:::-;66937:38;-1:-1:-1;66990:15:0;66986:393;;67067:16;;;67081:1;67067:16;;;;;;;;;;;;66986:393;67116:23;67156:10;67142:25;;;;;;-1:-1:-1;;;67142:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67142:25:0;;67116:51;;67182:13;67210:130;67234:10;67226:5;:18;67210:130;;;67290:34;67310:6;67318:5;67290:19;:34::i;:::-;67274:6;67281:5;67274:13;;;;;;-1:-1:-1;;;67274:13:0;;;;;;;;;;;;;;;;;;:50;67246:7;;;;:::i;:::-;;;;67210:130;;66986:393;66846:540;;;;:::o;68709:123::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68776:47:::1;::::0;68784:10:::1;::::0;68801:21:::1;68776:47:::0;::::1;;;::::0;::::1;::::0;;;68801:21;68784:10;68776:47;::::1;;;;;;68768:56;;;::::0;::::1;;68709:123::o:0;68288:117::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;68367:30;;::::1;::::0;:22:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;43726:104::-:0;43782:13;43815:7;43808:14;;;;;:::i;46636:295::-;-1:-1:-1;;;;;46739:24:0;;40855:10;46739:24;;46731:62;;;;-1:-1:-1;;;46731:62:0;;10799:2:1;46731:62:0;;;10781:21:1;10838:2;10818:18;;;10811:30;10877:27;10857:18;;;10850:55;10922:18;;46731:62:0;10771:175:1;46731:62:0;40855:10;46806:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;46806:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;46806:53:0;;;;;;;;;;46875:48;;8148:41:1;;;46806:42:0;;40855:10;46875:48;;8121:18:1;46875:48:0;;;;;;;46636:295;;:::o;68844:228::-;68900:7;68927:16;68935:7;68927;:16::i;:::-;68919:43;;;;-1:-1:-1;;;68919:43:0;;17097:2:1;68919:43:0;;;17079:21:1;17136:2;17116:18;;;17109:30;-1:-1:-1;;;17155:18:1;;;17148:44;17209:18;;68919:43:0;17069:164:1;68919:43:0;-1:-1:-1;69030:22:0;;;;:13;:22;;;;;;;;;;68998:64;;69023:4;4850:2:1;4846:15;-1:-1:-1;;4842:53:1;68998:64:0;;;4830:66:1;4912:12;;;4905:28;;;;4949:12;;;;4942:28;;;;68998:64:0;;;;;;;;;;4986:12:1;;68998:64:0;;;68988:75;;;;;;68844:228::o;47831:285::-;47963:41;40855:10;47996:7;47963:18;:41::i;:::-;47955:103;;;;-1:-1:-1;;;47955:103:0;;;;;;;:::i;:::-;48069:39;48083:4;48089:2;48093:7;48102:5;48069:13;:39::i;:::-;47831:285;;;;:::o;43901:792::-;43974:13;44008:16;44016:7;44008;:16::i;:::-;44000:76;;;;-1:-1:-1;;;44000:76:0;;15510:2:1;44000:76:0;;;15492:21:1;15549:2;15529:18;;;15522:30;15588:34;15568:18;;;15561:62;-1:-1:-1;;;15639:18:1;;;15632:45;15694:19;;44000:76:0;15482:237:1;44000:76:0;44089:23;44115:19;;;:10;:19;;;;;44089:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44145:18;44166:9;:7;:9::i;:::-;44145:30;;44257:4;44251:18;44273:1;44251:23;44247:72;;;-1:-1:-1;44298:9:0;43901:792;-1:-1:-1;;43901:792:0:o;44247:72::-;44423:23;;:27;44419:108;;44498:4;44504:9;44481:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44467:48;;;;43901:792;;;:::o;44419:108::-;44659:4;44665:18;:7;:16;:18::i;:::-;44642:42;;;;;;;;;:::i;67508:606::-;66320:4;67577:13;:11;:13::i;:::-;:24;67569:59;;;;-1:-1:-1;;;67569:59:0;;16328:2:1;67569:59:0;;;16310:21:1;16367:2;16347:18;;;16340:30;-1:-1:-1;;;16386:18:1;;;16379:52;16448:18;;67569:59:0;16300:172:1;67569:59:0;67657:1;67647:7;:11;:28;;;;;67673:2;67662:7;:13;;67647:28;67639:83;;;;-1:-1:-1;;;67639:83:0;;14689:2:1;67639:83:0;;;14671:21:1;14728:2;14708:18;;;14701:30;14767:34;14747:18;;;14740:62;-1:-1:-1;;;14818:18:1;;;14811:40;14868:19;;67639:83:0;14661:232:1;67639:83:0;66320:4;67741:26;67759:7;67741:13;:11;:13::i;:::-;:17;;:26::i;:::-;:38;;67733:67;;;;-1:-1:-1;;;67733:67:0;;13983:2:1;67733:67:0;;;13965:21:1;14022:2;14002:18;;;13995:30;-1:-1:-1;;;14041:18:1;;;14034:46;14097:18;;67733:67:0;13955:166:1;67733:67:0;67832:29;67472:17;67853:7;67832:20;:29::i;:::-;67819:9;:42;;67811:90;;;;-1:-1:-1;;;67811:90:0;;12402:2:1;67811:90:0;;;12384:21:1;12441:2;12421:18;;;12414:30;12480:34;12460:18;;;12453:62;-1:-1:-1;;;12531:18:1;;;12524:33;12574:19;;67811:90:0;12374:225:1;67811:90:0;67919:6;67914:193;67935:7;67931:1;:11;67914:193;;;67964:14;67981:13;:11;:13::i;:::-;67964:30;;68009:32;68019:10;68031:9;68009;:32::i;:::-;68056:24;;;;:13;:24;;;;;68083:12;68056:39;;67944:3;;;;:::i;:::-;;;;67914:193;;66476:43;;;;;;;:::i;58721:244::-;57840:6;;-1:-1:-1;;;;;57840:6:0;40855:10;57987:23;57979:68;;;;-1:-1:-1;;;57979:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;58810:22:0;::::1;58802:73;;;::::0;-1:-1:-1;;;58802:73:0;;9630:2:1;58802:73:0::1;::::0;::::1;9612:21:1::0;9669:2;9649:18;;;9642:30;9708:34;9688:18;;;9681:62;-1:-1:-1;;;9759:18:1;;;9752:36;9805:19;;58802:73:0::1;9602:228:1::0;58802:73:0::1;58912:6;::::0;58891:38:::1;::::0;-1:-1:-1;;;;;58891:38:0;;::::1;::::0;58912:6:::1;::::0;58891:38:::1;::::0;58912:6:::1;::::0;58891:38:::1;58940:6;:17:::0;;-1:-1:-1;;;;;;58940:17:0::1;-1:-1:-1::0;;;;;58940:17:0;;;::::1;::::0;;;::::1;::::0;;58721:244::o;20655:131::-;20722:4;20746:32;20751:3;20771:5;20746:4;:32::i;9485:185::-;9574:4;9598:64;9603:3;9623;-1:-1:-1;;;;;9637:23:0;;9598:4;:64::i;:::-;9591:71;;9485:185;;;;;;:::o;22827:422::-;23194:20;23233:8;;;22827:422::o;10062:151::-;10146:4;6755:17;;;:12;;;:17;;;;;;:22;;10170:35;6660:125;49583:127;49648:4;49672:30;:12;49694:7;49672:21;:30::i;55727:183::-;55793:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;55793:29:0;-1:-1:-1;;;;;55793:29:0;;;;;;;;:24;;55847:23;55793:24;55847:14;:23::i;:::-;-1:-1:-1;;;;;55838:46:0;;;;;;;;;;;55727:183;;:::o;10301:123::-;10370:7;10397:19;10405:3;6963:19;;6880:110;49877:355;49970:4;49995:16;50003:7;49995;:16::i;:::-;49987:73;;;;-1:-1:-1;;;49987:73:0;;11153:2:1;49987:73:0;;;11135:21:1;11192:2;11172:18;;;11165:30;11231:34;11211:18;;;11204:62;-1:-1:-1;;;11282:18:1;;;11275:42;11334:19;;49987:73:0;11125:234:1;49987:73:0;50071:13;50087:23;50102:7;50087:14;:23::i;:::-;50071:39;;50140:5;-1:-1:-1;;;;;50129:16:0;:7;-1:-1:-1;;;;;50129:16:0;;:51;;;;50173:7;-1:-1:-1;;;;;50149:31:0;:20;50161:7;50149:11;:20::i;:::-;-1:-1:-1;;;;;50149:31:0;;50129:51;:94;;;-1:-1:-1;;;;;;47123:25:0;;;47099:4;47123:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;50184:39;50121:103;49877:355;-1:-1:-1;;;;49877:355:0:o;53013:597::-;53138:4;-1:-1:-1;;;;;53111:31:0;:23;53126:7;53111:14;:23::i;:::-;-1:-1:-1;;;;;53111:31:0;;53103:85;;;;-1:-1:-1;;;53103:85:0;;15100:2:1;53103:85:0;;;15082:21:1;15139:2;15119:18;;;15112:30;15178:34;15158:18;;;15151:62;-1:-1:-1;;;15229:18:1;;;15222:39;15278:19;;53103:85:0;15072:231:1;53103:85:0;-1:-1:-1;;;;;53225:16:0;;53217:65;;;;-1:-1:-1;;;53217:65:0;;10394:2:1;53217:65:0;;;10376:21:1;10433:2;10413:18;;;10406:30;10472:34;10452:18;;;10445:62;-1:-1:-1;;;10523:18:1;;;10516:34;10567:19;;53217:65:0;10366:226:1;53217:65:0;53399:29;53416:1;53420:7;53399:8;:29::i;:::-;-1:-1:-1;;;;;53441:19:0;;;;;;:13;:19;;;;;:35;;53468:7;53441:26;:35::i;:::-;-1:-1:-1;;;;;;53487:17:0;;;;;;:13;:17;;;;;:30;;53509:7;53487:21;:30::i;:::-;-1:-1:-1;53530:29:0;:12;53547:7;53556:2;53530:16;:29::i;:::-;;53594:7;53590:2;-1:-1:-1;;;;;53575:27:0;53584:4;-1:-1:-1;;;;;53575:27:0;;;;;;;;;;;53013:597;;;:::o;21875:137::-;21946:7;21981:22;21985:3;21997:5;21981:3;:22::i;10763:236::-;10843:7;;;;10903:22;10907:3;10919:5;10903:3;:22::i;:::-;10872:53;;;;-1:-1:-1;10763:236:0;-1:-1:-1;;;;;10763:236:0:o;54211:100::-;54284:19;;;;:8;;:19;;;;;:::i;12049:213::-;12156:7;12207:44;12212:3;12232;12238:12;12207:4;:44::i;445:723::-;501:13;722:10;718:53;;-1:-1:-1;;749:10:0;;;;;;;;;;;;-1:-1:-1;;;749:10:0;;;;;445:723::o;718:53::-;796:5;781:12;837:78;844:9;;837:78;;870:8;;;;:::i;:::-;;-1:-1:-1;893:10:0;;-1:-1:-1;901:2:0;893:10;;:::i;:::-;;;837:78;;;925:19;957:6;947:17;;;;;;-1:-1:-1;;;947:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;947:17:0;;925:39;;975:154;982:10;;975:154;;1009:11;1019:1;1009:11;;:::i;:::-;;-1:-1:-1;1078:10:0;1086:2;1078:5;:10;:::i;:::-;1065:24;;:2;:24;:::i;:::-;1052:39;;1035:6;1042;1035:14;;;;;;-1:-1:-1;;;1035:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;1035:56:0;;;;;;;;-1:-1:-1;1106:11:0;1115:2;1106:11;;:::i;:::-;;;975:154;;48998:272;49112:28;49122:4;49128:2;49132:7;49112:9;:28::i;:::-;49159:48;49182:4;49188:2;49192:7;49201:5;49159:22;:48::i;:::-;49151:111;;;;-1:-1:-1;;;49151:111:0;;;;;;;:::i;61807:98::-;61865:7;61892:5;61896:1;61892;:5;:::i;62545:98::-;62603:7;62630:5;62634:1;62630;:5;:::i;50575:110::-;50651:26;50661:2;50665:7;50651:26;;;;;;;;;;;;:9;:26::i;14025:414::-;14088:4;6755:17;;;:12;;;:17;;;;;;14105:327;;-1:-1:-1;14148:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;14331:18;;14309:19;;;:12;;;:19;;;;;;:40;;;;14364:11;;14105:327;-1:-1:-1;14415:5:0;14408:12;;4160:692;4236:4;4371:17;;;:12;;;:17;;;;;;4405:13;4401:444;;-1:-1:-1;;4490:38:0;;;;;;;;;;;;;;;;;;4472:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;4687:19;;4667:17;;;:12;;;:17;;;;;;;:39;4721:11;;4401:444;4801:5;4765:3;4778:12;4789:1;4778:8;:12;:::i;:::-;4765:26;;;;;;-1:-1:-1;;;4765:26:0;;;;;;;;;;;;;;;;;;;:33;;:41;;;;4828:5;4821:12;;;;;20962:137;21032:4;21056:35;21064:3;21084:5;21056:7;:35::i;16913:204::-;17008:18;;16980:7;;17008:26;-1:-1:-1;17000:73:0;;;;-1:-1:-1;;;17000:73:0;;8808:2:1;17000:73:0;;;8790:21:1;8847:2;8827:18;;;8820:30;8886:34;8866:18;;;8859:62;-1:-1:-1;;;8937:18:1;;;8930:32;8979:19;;17000:73:0;8780:224:1;17000:73:0;17091:3;:11;;17103:5;17091:18;;;;;;-1:-1:-1;;;17091:18:0;;;;;;;;;;;;;;;;;17084:25;;16913:204;;;;:::o;7345:279::-;7449:19;;7412:7;;;;7449:27;-1:-1:-1;7441:74:0;;;;-1:-1:-1;;;7441:74:0;;12806:2:1;7441:74:0;;;12788:21:1;12845:2;12825:18;;;12818:30;12884:34;12864:18;;;12857:62;-1:-1:-1;;;12935:18:1;;;12928:32;12977:19;;7441:74:0;12778:224:1;7441:74:0;7528:22;7553:3;:12;;7566:5;7553:19;;;;;;-1:-1:-1;;;7553:19:0;;;;;;;;;;;;;;;;;;;7528:44;;7591:5;:10;;;7603:5;:12;;;7583:33;;;;;7345:279;;;;;:::o;8842:319::-;8936:7;8975:17;;;:12;;;:17;;;;;;9026:12;9011:13;9003:36;;;;-1:-1:-1;;;9003:36:0;;;;;;;;:::i;:::-;-1:-1:-1;9093:3:0;9106:12;9117:1;9106:8;:12;:::i;:::-;9093:26;;;;;;-1:-1:-1;;;9093:26:0;;;;;;;;;;;;;;;;;;;:33;;;9086:40;;;8842:319;;;;;:::o;54876:843::-;54997:4;-1:-1:-1;;;;;55023:13:0;;23194:20;23233:8;55019:693;;55059:72;;-1:-1:-1;;;55059:72:0;;-1:-1:-1;;;;;55059:36:0;;;;;:72;;40855:10;;55110:4;;55116:7;;55125:5;;55059:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55059:72:0;;;;;;;;-1:-1:-1;;55059:72:0;;;;;;;;;;;;:::i;:::-;;;55055:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55305:13:0;;55301:341;;55348:60;;-1:-1:-1;;;55348:60:0;;;;;;;:::i;55301:341::-;55592:6;55586:13;55577:6;55573:2;55569:15;55562:38;55055:602;-1:-1:-1;;;;;;55182:55:0;-1:-1:-1;;;55182:55:0;;-1:-1:-1;55175:62:0;;55019:693;-1:-1:-1;55696:4:0;54876:843;;;;;;:::o;50912:250::-;51008:18;51014:2;51018:7;51008:5;:18::i;:::-;51045:54;51076:1;51080:2;51084:7;51093:5;51045:22;:54::i;:::-;51037:117;;;;-1:-1:-1;;;51037:117:0;;;;;;;:::i;14615:1544::-;14681:4;14820:19;;;:12;;;:19;;;;;;14856:15;;14852:1300;;15218:21;15242:14;15255:1;15242:10;:14;:::i;:::-;15291:18;;15218:38;;-1:-1:-1;15271:17:0;;15291:22;;15312:1;;15291:22;:::i;:::-;15271:42;;15558:17;15578:3;:11;;15590:9;15578:22;;;;;;-1:-1:-1;;;15578:22:0;;;;;;;;;;;;;;;;;15558:42;;15724:9;15695:3;:11;;15707:13;15695:26;;;;;;-1:-1:-1;;;15695:26:0;;;;;;;;;;;;;;;;;;:38;15827:17;:13;15843:1;15827:17;:::i;:::-;15801:23;;;;:12;;;:23;;;;;:43;15953:17;;15801:3;;15953:17;;;-1:-1:-1;;;15953:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;16048:3;:12;;:19;16061:5;16048:19;;;;;;;;;;;16041:26;;;16091:4;16084:11;;;;;;;;14852:1300;16135:5;16128:12;;;;;51498:404;-1:-1:-1;;;;;51578:16:0;;51570:61;;;;-1:-1:-1;;;51570:61:0;;13209:2:1;51570:61:0;;;13191:21:1;;;13228:18;;;13221:30;13287:34;13267:18;;;13260:62;13339:18;;51570:61:0;13181:182:1;51570:61:0;51651:16;51659:7;51651;:16::i;:::-;51650:17;51642:58;;;;-1:-1:-1;;;51642:58:0;;10037:2:1;51642:58:0;;;10019:21:1;10076:2;10056:18;;;10049:30;10115;10095:18;;;10088:58;10163:18;;51642:58:0;10009:178:1;51642:58:0;-1:-1:-1;;;;;51771:17:0;;;;;;:13;:17;;;;;:30;;51793:7;51771:21;:30::i;:::-;-1:-1:-1;51814:29:0;:12;51831:7;51840:2;51814:16;:29::i;:::-;-1:-1:-1;51861:33:0;;51886:7;;-1:-1:-1;;;;;51861:33:0;;;51878:1;;51861:33;;51878:1;;51861:33;51498:404;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:2;;813:1;810;803:12;747:2;699:124;;;:::o;828:196::-;887:6;940:2;928:9;919:7;915:23;911:32;908:2;;;961:6;953;946:22;908:2;989:29;1008:9;989:29;:::i;1029:270::-;1097:6;1105;1158:2;1146:9;1137:7;1133:23;1129:32;1126:2;;;1179:6;1171;1164:22;1126:2;1207:29;1226:9;1207:29;:::i;:::-;1197:39;;1255:38;1289:2;1278:9;1274:18;1255:38;:::i;:::-;1245:48;;1116:183;;;;;:::o;1304:338::-;1381:6;1389;1397;1450:2;1438:9;1429:7;1425:23;1421:32;1418:2;;;1471:6;1463;1456:22;1418:2;1499:29;1518:9;1499:29;:::i;:::-;1489:39;;1547:38;1581:2;1570:9;1566:18;1547:38;:::i;:::-;1537:48;;1632:2;1621:9;1617:18;1604:32;1594:42;;1408:234;;;;;:::o;1647:696::-;1742:6;1750;1758;1766;1819:3;1807:9;1798:7;1794:23;1790:33;1787:2;;;1841:6;1833;1826:22;1787:2;1869:29;1888:9;1869:29;:::i;:::-;1859:39;;1917:38;1951:2;1940:9;1936:18;1917:38;:::i;:::-;1907:48;;2002:2;1991:9;1987:18;1974:32;1964:42;;2057:2;2046:9;2042:18;2029:32;2084:18;2076:6;2073:30;2070:2;;;2121:6;2113;2106:22;2070:2;2149:22;;2202:4;2194:13;;2190:27;-1:-1:-1;2180:2:1;;2236:6;2228;2221:22;2180:2;2264:73;2329:7;2324:2;2311:16;2306:2;2302;2298:11;2264:73;:::i;:::-;2254:83;;;1777:566;;;;;;;:::o;2348:367::-;2413:6;2421;2474:2;2462:9;2453:7;2449:23;2445:32;2442:2;;;2495:6;2487;2480:22;2442:2;2523:29;2542:9;2523:29;:::i;:::-;2513:39;;2602:2;2591:9;2587:18;2574:32;2649:5;2642:13;2635:21;2628:5;2625:32;2615:2;;2676:6;2668;2661:22;2615:2;2704:5;2694:15;;;2432:283;;;;;:::o;2720:264::-;2788:6;2796;2849:2;2837:9;2828:7;2824:23;2820:32;2817:2;;;2870:6;2862;2855:22;2817:2;2898:29;2917:9;2898:29;:::i;:::-;2888:39;2974:2;2959:18;;;;2946:32;;-1:-1:-1;;;2807:177:1:o;2989:255::-;3047:6;3100:2;3088:9;3079:7;3075:23;3071:32;3068:2;;;3121:6;3113;3106:22;3068:2;3165:9;3152:23;3184:30;3208:5;3184:30;:::i;3249:259::-;3318:6;3371:2;3359:9;3350:7;3346:23;3342:32;3339:2;;;3392:6;3384;3377:22;3339:2;3429:9;3423:16;3448:30;3472:5;3448:30;:::i;3513:480::-;3582:6;3635:2;3623:9;3614:7;3610:23;3606:32;3603:2;;;3656:6;3648;3641:22;3603:2;3701:9;3688:23;3734:18;3726:6;3723:30;3720:2;;;3771:6;3763;3756:22;3720:2;3799:22;;3852:4;3844:13;;3840:27;-1:-1:-1;3830:2:1;;3886:6;3878;3871:22;3830:2;3914:73;3979:7;3974:2;3961:16;3956:2;3952;3948:11;3914:73;:::i;3998:190::-;4057:6;4110:2;4098:9;4089:7;4085:23;4081:32;4078:2;;;4131:6;4123;4116:22;4078:2;-1:-1:-1;4159:23:1;;4068:120;-1:-1:-1;4068:120:1:o;4193:257::-;4234:3;4272:5;4266:12;4299:6;4294:3;4287:19;4315:63;4371:6;4364:4;4359:3;4355:14;4348:4;4341:5;4337:16;4315:63;:::i;:::-;4432:2;4411:15;-1:-1:-1;;4407:29:1;4398:39;;;;4439:4;4394:50;;4242:208;-1:-1:-1;;4242:208:1:o;4455:185::-;4497:3;4535:5;4529:12;4550:52;4595:6;4590:3;4583:4;4576:5;4572:16;4550:52;:::i;:::-;4618:16;;;;;4505:135;-1:-1:-1;;4505:135:1:o;5009:470::-;5188:3;5226:6;5220:13;5242:53;5288:6;5283:3;5276:4;5268:6;5264:17;5242:53;:::i;:::-;5358:13;;5317:16;;;;5380:57;5358:13;5317:16;5414:4;5402:17;;5380:57;:::i;:::-;5453:20;;5196:283;-1:-1:-1;;;;5196:283:1:o;5484:1178::-;5660:3;5689;5724:6;5718:13;5754:3;5776:1;5804:9;5800:2;5796:18;5786:28;;5864:2;5853:9;5849:18;5886;5876:2;;5930:4;5922:6;5918:17;5908:27;;5876:2;5956;6004;5996:6;5993:14;5973:18;5970:38;5967:2;;;-1:-1:-1;;;6031:33:1;;6087:4;6084:1;6077:15;6117:4;6038:3;6105:17;5967:2;6148:18;6175:104;;;;6293:1;6288:322;;;;6141:469;;6175:104;-1:-1:-1;;6208:24:1;;6196:37;;6253:16;;;;-1:-1:-1;6175:104:1;;6288:322;17467:4;17486:17;;;17536:4;17520:21;;6383:3;6399:165;6413:6;6410:1;6407:13;6399:165;;;6491:14;;6478:11;;;6471:35;6534:16;;;;6428:10;;6399:165;;;6403:3;;6593:6;6588:3;6584:16;6577:23;;6141:469;;;;;;;6626:30;6652:3;6644:6;6626:30;:::i;:::-;6619:37;5668:994;-1:-1:-1;;;;;5668:994:1:o;6875:488::-;-1:-1:-1;;;;;7144:15:1;;;7126:34;;7196:15;;7191:2;7176:18;;7169:43;7243:2;7228:18;;7221:34;;;7291:3;7286:2;7271:18;;7264:31;;;7069:4;;7312:45;;7337:19;;7329:6;7312:45;:::i;:::-;7304:53;7078:285;-1:-1:-1;;;;;;7078:285:1:o;7368:635::-;7539:2;7591:21;;;7661:13;;7564:18;;;7683:22;;;7510:4;;7539:2;7762:15;;;;7736:2;7721:18;;;7510:4;7808:169;7822:6;7819:1;7816:13;7808:169;;;7883:13;;7871:26;;7952:15;;;;7917:12;;;;7844:1;7837:9;7808:169;;;-1:-1:-1;7994:3:1;;7519:484;-1:-1:-1;;;;;;7519:484:1:o;8382:219::-;8531:2;8520:9;8513:21;8494:4;8551:44;8591:2;8580:9;8576:18;8568:6;8551:44;:::i;9009:414::-;9211:2;9193:21;;;9250:2;9230:18;;;9223:30;9289:34;9284:2;9269:18;;9262:62;-1:-1:-1;;;9355:2:1;9340:18;;9333:48;9413:3;9398:19;;9183:240::o;14126:356::-;14328:2;14310:21;;;14347:18;;;14340:30;14406:34;14401:2;14386:18;;14379:62;14473:2;14458:18;;14300:182::o;16477:413::-;16679:2;16661:21;;;16718:2;16698:18;;;16691:30;16757:34;16752:2;16737:18;;16730:62;-1:-1:-1;;;16823:2:1;16808:18;;16801:47;16880:3;16865:19;;16651:239::o;17552:128::-;17592:3;17623:1;17619:6;17616:1;17613:13;17610:2;;;17629:18;;:::i;:::-;-1:-1:-1;17665:9:1;;17600:80::o;17685:120::-;17725:1;17751;17741:2;;17756:18;;:::i;:::-;-1:-1:-1;17790:9:1;;17731:74::o;17810:168::-;17850:7;17916:1;17912;17908:6;17904:14;17901:1;17898:21;17893:1;17886:9;17879:17;17875:45;17872:2;;;17923:18;;:::i;:::-;-1:-1:-1;17963:9:1;;17862:116::o;17983:125::-;18023:4;18051:1;18048;18045:8;18042:2;;;18056:18;;:::i;:::-;-1:-1:-1;18093:9:1;;18032:76::o;18113:258::-;18185:1;18195:113;18209:6;18206:1;18203:13;18195:113;;;18285:11;;;18279:18;18266:11;;;18259:39;18231:2;18224:10;18195:113;;;18326:6;18323:1;18320:13;18317:2;;;-1:-1:-1;;18361:1:1;18343:16;;18336:27;18166:205::o;18376:380::-;18455:1;18451:12;;;;18498;;;18519:2;;18573:4;18565:6;18561:17;18551:27;;18519:2;18626;18618:6;18615:14;18595:18;18592:38;18589:2;;;18672:10;18667:3;18663:20;18660:1;18653:31;18707:4;18704:1;18697:15;18735:4;18732:1;18725:15;18761:135;18800:3;-1:-1:-1;;18821:17:1;;18818:2;;;18841:18;;:::i;:::-;-1:-1:-1;18888:1:1;18877:13;;18808:88::o;18901:112::-;18933:1;18959;18949:2;;18964:18;;:::i;:::-;-1:-1:-1;18998:9:1;;18939:74::o;19018:127::-;19079:10;19074:3;19070:20;19067:1;19060:31;19110:4;19107:1;19100:15;19134:4;19131:1;19124:15;19150:127;19211:10;19206:3;19202:20;19199:1;19192:31;19242:4;19239:1;19232:15;19266:4;19263:1;19256:15;19282:127;19343:10;19338:3;19334:20;19331:1;19324:31;19374:4;19371:1;19364:15;19398:4;19395:1;19388:15;19414:131;-1:-1:-1;;;;;;19488:32:1;;19478:43;;19468:2;;19535:1;19532;19525:12

Swarm Source

ipfs://d4bd11a4d828a37695caa47cf2f52562f48071e3d3f22e7ff716061d7c61d590

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