Token

J48BAFORMS (JABBA)

ERC-721

NFT

Overview

Max Total Supply

4,849 JABBA

Holders

1,052

Market

Volume (24H)

0.03 ETH

Min Price (24H)

$105.77 @ 0.029999 ETH

Max Price (24H)

$105.77 @ 0.029999 ETH

Other Info

Token Contract

0xc78337ccbb2d08492ec152e501491d3a76cd5172

Filtered by Token Holder

0xDafCD089794ecfd5e695b9fBb3692503Bb04aeEB

Balance

2 JABBA

0xdafcd089794ecfd5e695b9fbb3692503bb04aeeb

OVERVIEW

J48BAFORMS (Pronounced Jabbaforms) is a multifaceted artistic experiment minting at 0.25ETH a pop. A series of 4848 Works of art are available at random. J48BAFORMS started with 1000 hand-drawn “LEGACYFORMS” produced by the artist, which serves as the foundation for the series.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

JABBAFORMS

Compiler Version

v0.8.0+commit.c7dfd78e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MPL-2.0 license

Contract Source Code (Solidity)

IDE

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

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

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

// SPDX-License-Identifier: MIT



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;





contract JABBAFORMS is ERC721, Ownable {
    using SafeMath for uint256;
    uint public constant MAX_JABBAS = 4849;
    bool public hasSaleStarted = false;
    
    // THE IPFS HASH OF ALL TOKEN DATAS WILL BE ADDED HERE WHEN ALL JABBA FORMS ARE FINALIZED.
    string public METADATA_PROVENANCE_HASH = "";
    
    
    constructor() ERC721("J48BAFORMS","JABBA")  {
        setBaseURI("https://j48baforms.io/api/");
        
		//Givaways
        _safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 0);
        _safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 1);
        _safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 2);
        _safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 3);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 4);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 5);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 6);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 7);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 8);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 9);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 10);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 11);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 12);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 13);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 14);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 15);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 16);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 17);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 18);
		_safeMint(address(0x79004C1a3aCe472d75358ceCeB1d7E47Ef98BF10), 19);

		//sudoscum
		_safeMint(address(0xaA9f066554e18d3a6b660786aaFEA8e9a8630555), 20);
		_safeMint(address(0xaA9f066554e18d3a6b660786aaFEA8e9a8630555), 21);
		_safeMint(address(0xaA9f066554e18d3a6b660786aaFEA8e9a8630555), 22);
		_safeMint(address(0xaA9f066554e18d3a6b660786aaFEA8e9a8630555), 23);
		_safeMint(address(0xaA9f066554e18d3a6b660786aaFEA8e9a8630555), 24);
		
		//PM
		_safeMint(address(0x8af39F909679793D2FA5A78e2766E6EF131ECDE2), 25);
		_safeMint(address(0x8af39F909679793D2FA5A78e2766E6EF131ECDE2), 26);
		_safeMint(address(0x8af39F909679793D2FA5A78e2766E6EF131ECDE2), 27);
		
		//BERK
		_safeMint(address(0xc5E08104c19DAfd00Fe40737490Da9552Db5bfE5), 28);
		
		//Justin
		_safeMint(address(0x84F5DE49Bf77dEC3D6b6D69dc05fa80207262D5A), 29);
		_safeMint(address(0x84F5DE49Bf77dEC3D6b6D69dc05fa80207262D5A), 30);
        
    }
    

    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) {
        require(hasSaleStarted == true, "Sale hasn't started");

        require(totalSupply() < MAX_JABBAS, "Sale has already ended");

        uint currentSupply = totalSupply();
        require(currentSupply < MAX_JABBAS, "Sale has already ended");

        if (currentSupply <= 500) {
            return 80000000000000000; // 0.08 ETH
        } else if (currentSupply <= 1600) {
            return 140000000000000000; // 0.14 ETH
        } else if (currentSupply <= 2648) {
            return 250000000000000000; // 0.25 ETH
        } else if (currentSupply <= 3648) {
            return 330000000000000000; // 0.33 ETH
        } else if (currentSupply <= 4148) {
            return 400000000000000000; // 0.4 ETH
        } else if (currentSupply <= 4648) {
            return 500000000000000000; // 0.5 ETH
        } else if (currentSupply <= 4847) {
            return 600000000000000000; // 0.6 ETH
        } else {
            return 1000000000000000000; // 1 ETH
        }
        
    }

     function calculatePriceTest(uint _id) public view returns (uint256) {


        require(_id < MAX_JABBAS, "Sale has already ended");

        if (_id <= 500) {
            return 80000000000000000; // 0.08 ETH
        } else if (_id <= 1600) {
            return 140000000000000000; // 0.14 ETH
        } else if (_id <= 2648) {
            return 250000000000000000; // 0.25 ETH
        } else if (_id <= 3648) {
            return 330000000000000000; // 0.33 ETH
        } else if (_id <= 4148) {
            return 400000000000000000; // 0.4 ETH
        } else if (_id <= 4648) {
            return 500000000000000000; // 0.5 ETH
        } else if (_id <= 4847) {
            return 600000000000000000; // 0.6 ETH
        } else {
            return 1000000000000000000; // 1 ETH
        }
        
    }
    
   function adoptJABBA(uint256 numJabbas) public payable {
        require(totalSupply() < MAX_JABBAS, "Sale has already ended");
        require(numJabbas > 0 && numJabbas <= 20, "You can adopt minimum 1, maximum 20 jabba forms");
        require(totalSupply().add(numJabbas) <= MAX_JABBAS, "Exceeds MAX_JABBAS");
        require(msg.value >= calculatePrice().mul(numJabbas), "Ether value sent is below the price");

        for (uint i = 0; i < numJabbas; i++) {
            uint mintIndex = totalSupply();
            _safeMint(msg.sender, mintIndex);
        }

    }
    
    // ONLYOWNER FUNCTIONS
    
    function setProvenanceHash(string memory _hash) public onlyOwner {
        METADATA_PROVENANCE_HASH = _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));
    }
    


}

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":"MAX_JABBAS","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":"uint256","name":"numJabbas","type":"uint256"}],"name":"adoptJABBA","outputs":[],"stateMutability":"payable","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":"_id","type":"uint256"}],"name":"calculatePriceTest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":[],"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":"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":"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

66115:6416:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31852:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43540:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46326:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45856:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71975:116;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71350:579;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45334:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66239:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47216:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72298:79;;;;;;;;;;;;;:::i;:::-;;45096:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72214:78;;;;;;;;;;;;;:::i;:::-;;47592:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45622:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70509:830;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72103:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43296:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44915:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43001:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58399:148;;;;;;;;;;;;;:::i;:::-;;68868:540;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72395:123;;;:::i;:::-;;57748:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43709:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46619:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47814:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43884:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66194:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69420:1080;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46985:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66382:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58702:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;31852:150;31937:4;31961:20;:33;31982:11;31961:33;;;;;;;;;;;;;;;;;;;;;;;;;;;31954:40;;31852:150;;;:::o;43540:100::-;43594:13;43627:5;43620:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43540:100;:::o;46326:221::-;46402:7;46430:16;46438:7;46430;:16::i;:::-;46422:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;46515:15;:24;46531:7;46515:24;;;;;;;;;;;;;;;;;;;;;46508:31;;46326:221;;;:::o;45856:404::-;45937:13;45953:23;45968:7;45953:14;:23::i;:::-;45937:39;;46001:5;45995:11;;:2;:11;;;;45987:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;46081:5;46065:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;46090:44;46114:5;46121:12;:10;:12::i;:::-;46090:23;:44::i;:::-;46065:69;46057:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;46231:21;46240:2;46244:7;46231:8;:21::i;:::-;45856:404;;;:::o;71975:116::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72078:5:::1;72051:24;:32;;;;;;;;;;;;:::i;:::-;;71975:116:::0;:::o;71350:579::-;66228:4;71423:13;:11;:13::i;:::-;:26;71415:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;71507:1;71495:9;:13;:32;;;;;71525:2;71512:9;:15;;71495:32;71487:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;66228:4;71598:28;71616:9;71598:13;:11;:13::i;:::-;:17;;:28;;;;:::i;:::-;:42;;71590:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;71695:31;71716:9;71695:16;:14;:16::i;:::-;:20;;:31;;;;:::i;:::-;71682:9;:44;;71674:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;71784:6;71779:141;71800:9;71796:1;:13;71779:141;;;71831:14;71848:13;:11;:13::i;:::-;71831:30;;71876:32;71886:10;71898:9;71876;:32::i;:::-;71779:141;71811:3;;;;;:::i;:::-;;;;71779:141;;;;71350:579;:::o;45334:211::-;45395:7;45516:21;:12;:19;:21::i;:::-;45509:28;;45334:211;:::o;66239:34::-;;;;;;;;;;;;;:::o;47216:305::-;47377:41;47396:12;:10;:12::i;:::-;47410:7;47377:18;:41::i;:::-;47369:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;47485:28;47495:4;47501:2;47505:7;47485:9;:28::i;:::-;47216:305;;;:::o;72298:79::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72364:5:::1;72347:14;;:22;;;;;;;;;;;;;;;;;;72298:79::o:0;45096:162::-;45193:7;45220:30;45244:5;45220:13;:20;45234:5;45220:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;45213:37;;45096:162;;;;:::o;72214:78::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72280:4:::1;72263:14;;:21;;;;;;;;;;;;;;;;;;72214:78::o:0;47592:151::-;47696:39;47713:4;47719:2;47723:7;47696:39;;;;;;;;;;;;:16;:39::i;:::-;47592:151;;;:::o;45622:172::-;45697:7;45718:15;45739:22;45755:5;45739:12;:15;;:22;;;;:::i;:::-;45717:44;;;45779:7;45772:14;;;45622:172;;;:::o;70509:830::-;70568:7;66228:4;70600:3;:16;70592:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;70667:3;70660;:10;70656:666;;70694:17;70687:24;;;;70656:666;70752:4;70745:3;:11;70741:581;;70780:18;70773:25;;;;70741:581;70839:4;70832:3;:11;70828:494;;70867:18;70860:25;;;;70828:494;70926:4;70919:3;:11;70915:407;;70954:18;70947:25;;;;70915:407;71013:4;71006:3;:11;71002:320;;71041:18;71034:25;;;;71002:320;71099:4;71092:3;:11;71088:234;;71127:18;71120:25;;;;71088:234;71185:4;71178:3;:11;71174:148;;71213:18;71206:25;;;;71174:148;71282:19;71275:26;;70509:830;;;;:::o;72103:99::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72174:20:::1;72186:7;72174:11;:20::i;:::-;72103:99:::0;:::o;43296:177::-;43368:7;43395:70;43412:7;43395:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;43388:77;;43296:177;;;:::o;44915:97::-;44963:13;44996:8;44989:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44915:97;:::o;43001:221::-;43073:7;43118:1;43101:19;;:5;:19;;;;43093:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;43185:29;:13;:20;43199:5;43185:20;;;;;;;;;;;;;;;:27;:29::i;:::-;43178:36;;43001:221;;;:::o;58399:148::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58506:1:::1;58469:40;;58490:6;;;;;;;;;;;58469:40;;;;;;;;;;;;58537:1;58520:6;;:19;;;;;;;;;;;;;;;;;;58399:148::o:0;68868:540::-;68929:16;68959:18;68980:17;68990:6;68980:9;:17::i;:::-;68959:38;;69026:1;69012:10;:15;69008:393;;;69103:1;69089:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69082:23;;;;;69008:393;69138:23;69178:10;69164:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69138:51;;69204:13;69232:130;69256:10;69248:5;:18;69232:130;;;69312:34;69332:6;69340:5;69312:19;:34::i;:::-;69296:6;69303:5;69296:13;;;;;;;;;;;;;;;;;;;;;:50;;;;;69268:7;;;;;:::i;:::-;;;;69232:130;;;69383:6;69376:13;;;;;68868:540;;;;:::o;72395:123::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;72470:10:::1;72462:24;;:47;72487:21;72462:47;;;;;;;;;;;;;;;;;;;;;;;72454:56;;;::::0;::::1;;72395:123::o:0;57748:87::-;57794:7;57821:6;;;;;;;;;;;57814:13;;57748:87;:::o;43709:104::-;43765:13;43798:7;43791:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43709:104;:::o;46619:295::-;46734:12;:10;:12::i;:::-;46722:24;;:8;:24;;;;46714:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;46834:8;46789:18;:32;46808:12;:10;:12::i;:::-;46789:32;;;;;;;;;;;;;;;:42;46822:8;46789:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;46887:8;46858:48;;46873:12;:10;:12::i;:::-;46858:48;;;46897:8;46858:48;;;;;;:::i;:::-;;;;;;;;46619:295;;:::o;47814:285::-;47946:41;47965:12;:10;:12::i;:::-;47979:7;47946:18;:41::i;:::-;47938:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;48052:39;48066:4;48072:2;48076:7;48085:5;48052:13;:39::i;:::-;47814:285;;;;:::o;43884:792::-;43957:13;43991:16;43999:7;43991;:16::i;:::-;43983:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;44072:23;44098:10;:19;44109:7;44098:19;;;;;;;;;;;44072:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44128:18;44149:9;:7;:9::i;:::-;44128:30;;44256:1;44240:4;44234:18;:23;44230:72;;;44281:9;44274:16;;;;;;44230:72;44432:1;44412:9;44406:23;:27;44402:108;;;44481:4;44487:9;44464:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44450:48;;;;;;44402:108;44642:4;44648:18;:7;:16;:18::i;:::-;44625:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44611:57;;;;43884:792;;;;:::o;66194:38::-;66228:4;66194:38;:::o;69420:1080::-;69467:7;69513:4;69495:22;;:14;;;;;;;;;;;:22;;;69487:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;66228:4;69562:13;:11;:13::i;:::-;:26;69554:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;69628:18;69649:13;:11;:13::i;:::-;69628:34;;66228:4;69681:13;:26;69673:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;69768:3;69751:13;:20;69747:736;;69795:17;69788:24;;;;;69747:736;69863:4;69846:13;:21;69842:641;;69891:18;69884:25;;;;;69842:641;69960:4;69943:13;:21;69939:544;;69988:18;69981:25;;;;;69939:544;70057:4;70040:13;:21;70036:447;;70085:18;70078:25;;;;;70036:447;70154:4;70137:13;:21;70133:350;;70182:18;70175:25;;;;;70133:350;70250:4;70233:13;:21;70229:254;;70278:18;70271:25;;;;;70229:254;70346:4;70329:13;:21;70325:158;;70374:18;70367:25;;;;;70325:158;70443:19;70436:26;;;69420:1080;;:::o;46985:164::-;47082:4;47106:18;:25;47125:5;47106:25;;;;;;;;;;;;;;;:35;47132:8;47106:35;;;;;;;;;;;;;;;;;;;;;;;;;47099:42;;46985:164;;;;:::o;66382:43::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58702:244::-;57979:12;:10;:12::i;:::-;57968:23;;:7;:5;:7::i;:::-;:23;;;57960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58811:1:::1;58791:22;;:8;:22;;;;58783:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58901:8;58872:38;;58893:6;;;;;;;;;;;58872:38;;;;;;;;;;;;58930:8;58921:6;;:17;;;;;;;;;;;;;;;;;;58702:244:::0;:::o;20663:131::-;20730:4;20754:32;20759:3;:10;;20779:5;20771:14;;20754:4;:32::i;:::-;20747:39;;20663:131;;;;:::o;9493:185::-;9582:4;9606:64;9611:3;:10;;9631:3;9623:12;;9661:5;9645:23;;9637:32;;9606:4;:64::i;:::-;9599:71;;9493:185;;;;;:::o;22835:422::-;22895:4;23103:12;23214:7;23202:20;23194:28;;23248:1;23241:4;:8;23234:15;;;22835:422;;;:::o;10070:151::-;10154:4;10178:35;10188:3;:10;;10208:3;10200:12;;10178:9;:35::i;:::-;10171:42;;10070:151;;;;:::o;49566:127::-;49631:4;49655:30;49677:7;49655:12;:21;;:30;;;;:::i;:::-;49648:37;;49566:127;;;:::o;40783:98::-;40836:7;40863:10;40856:17;;40783:98;:::o;55712:183::-;55805:2;55778:15;:24;55794:7;55778:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;55861:7;55857:2;55823:46;;55832:23;55847:7;55832:14;:23::i;:::-;55823:46;;;;;;;;;;;;55712:183;;:::o;61788:98::-;61846:7;61877:1;61873;:5;;;;:::i;:::-;61866:12;;61788:98;;;;:::o;62526:::-;62584:7;62615:1;62611;:5;;;;:::i;:::-;62604:12;;62526:98;;;;:::o;50558:110::-;50634:26;50644:2;50648:7;50634:26;;;;;;;;;;;;:9;:26::i;:::-;50558:110;;:::o;10309:123::-;10378:7;10405:19;10413:3;:10;;10405:7;:19::i;:::-;10398:26;;10309:123;;;:::o;49860:355::-;49953:4;49978:16;49986:7;49978;:16::i;:::-;49970:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;50054:13;50070:23;50085:7;50070:14;:23::i;:::-;50054:39;;50123:5;50112:16;;:7;:16;;;:51;;;;50156:7;50132:31;;:20;50144:7;50132:11;:20::i;:::-;:31;;;50112:51;:94;;;;50167:39;50191:5;50198:7;50167:23;:39::i;:::-;50112:94;50104:103;;;49860:355;;;;:::o;52996:599::-;53121:4;53094:31;;:23;53109:7;53094:14;:23::i;:::-;:31;;;53086:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;53222:1;53208:16;;:2;:16;;;;53200:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53278:39;53299:4;53305:2;53309:7;53278:20;:39::i;:::-;53382:29;53399:1;53403:7;53382:8;:29::i;:::-;53424:35;53451:7;53424:13;:19;53438:4;53424:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;53470:30;53492:7;53470:13;:17;53484:2;53470:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;53513:29;53530:7;53539:2;53513:12;:16;;:29;;;;;:::i;:::-;;53579:7;53575:2;53560:27;;53569:4;53560:27;;;;;;;;;;;;52996:599;;;:::o;21883:137::-;21954:7;21989:22;21993:3;:10;;22005:5;21989:3;:22::i;:::-;21981:31;;21974:38;;21883:137;;;;:::o;10771:236::-;10851:7;10860;10881:11;10894:13;10911:22;10915:3;:10;;10927:5;10911:3;:22::i;:::-;10880:53;;;;10960:3;10952:12;;10990:5;10982:14;;10944:55;;;;;;10771:236;;;;;:::o;54196:100::-;54280:8;54269;:19;;;;;;;;;;;;:::i;:::-;;54196:100;:::o;12057:213::-;12164:7;12215:44;12220:3;:10;;12240:3;12232:12;;12246;12215:4;:44::i;:::-;12207:53;;12184:78;;12057:213;;;;;:::o;21425:114::-;21485:7;21512:19;21520:3;:10;;21512:7;:19::i;:::-;21505:26;;21425:114;;;:::o;48981:272::-;49095:28;49105:4;49111:2;49115:7;49095:9;:28::i;:::-;49142:48;49165:4;49171:2;49175:7;49184:5;49142:22;:48::i;:::-;49134:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;48981:272;;;;:::o;453:723::-;509:13;739:1;730:5;:10;726:53;;;757:10;;;;;;;;;;;;;;;;;;;;;726:53;789:12;804:5;789:20;;820:14;845:78;860:1;852:4;:9;845:78;;878:8;;;;;:::i;:::-;;;;909:2;901:10;;;;;:::i;:::-;;;845:78;;;933:19;965:6;955:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;933:39;;983:154;999:1;990:5;:10;983:154;;1027:1;1017:11;;;;;:::i;:::-;;;1094:2;1086:5;:10;;;;:::i;:::-;1073:2;:24;;;;:::i;:::-;1060:39;;1043:6;1050;1043:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;1123:2;1114:11;;;;;:::i;:::-;;;983:154;;;1161:6;1147:21;;;;;453:723;;;;:::o;14033:414::-;14096:4;14118:21;14128:3;14133:5;14118:9;:21::i;:::-;14113:327;;14156:3;:11;;14173:5;14156:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14339:3;:11;;:18;;;;14317:3;:12;;:19;14330:5;14317:19;;;;;;;;;;;:40;;;;14379:4;14372:11;;;;14113:327;14423:5;14416:12;;14033:414;;;;;:::o;4168:692::-;4244:4;4360:16;4379:3;:12;;:17;4392:3;4379:17;;;;;;;;;;;;4360:36;;4425:1;4413:8;:13;4409:444;;;4480:3;:12;;4498:38;;;;;;;;4515:3;4498:38;;;;4528:5;4498:38;;;4480:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4695:3;:12;;:19;;;;4675:3;:12;;:17;4688:3;4675:17;;;;;;;;;;;:39;;;;4736:4;4729:11;;;;;4409:444;4809:5;4773:3;:12;;4797:1;4786:8;:12;;;;:::i;:::-;4773:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;:41;;;;4836:5;4829:12;;;4168:692;;;;;;:::o;6668:125::-;6739:4;6784:1;6763:3;:12;;:17;6776:3;6763:17;;;;;;;;;;;;:22;;6756:29;;6668:125;;;;:::o;50895:250::-;50991:18;50997:2;51001:7;50991:5;:18::i;:::-;51028:54;51059:1;51063:2;51067:7;51076:5;51028:22;:54::i;:::-;51020:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;50895:250;;;:::o;6888:110::-;6944:7;6971:3;:12;;:19;;;;6964:26;;6888:110;;;:::o;56508:93::-;;;;:::o;20970:137::-;21040:4;21064:35;21072:3;:10;;21092:5;21084:14;;21064:7;:35::i;:::-;21057:42;;20970:137;;;;:::o;16921:204::-;16988:7;17037:5;17016:3;:11;;:18;;;;:26;17008:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;17099:3;:11;;17111:5;17099:18;;;;;;;;;;;;;;;;;;;;;;;;17092:25;;16921:204;;;;:::o;7353:279::-;7420:7;7429;7479:5;7457:3;:12;;:19;;;;:27;7449:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7536:22;7561:3;:12;;7574:5;7561:19;;;;;;;;;;;;;;;;;;;;;;;;;;7536:44;;7599:5;:10;;;7611:5;:12;;;7591:33;;;;;7353:279;;;;;:::o;8850:319::-;8944:7;8964:16;8983:3;:12;;:17;8996:3;8983:17;;;;;;;;;;;;8964:36;;9031:1;9019:8;:13;;9034:12;9011:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;9101:3;:12;;9125:1;9114:8;:12;;;;:::i;:::-;9101:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;9094:40;;;8850:319;;;;;:::o;16468:109::-;16524:7;16551:3;:11;;:18;;;;16544:25;;16468:109;;;:::o;54861:843::-;54982:4;55008:15;:2;:13;;;:15::i;:::-;55004:693;;;55060:2;55044:36;;;55081:12;:10;:12::i;:::-;55095:4;55101:7;55110:5;55044:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55040:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55307:1;55290:6;:13;:18;55286:341;;;55333:60;;;;;;;;;;:::i;:::-;;;;;;;;55286:341;55577:6;55571:13;55562:6;55558:2;55554:15;55547:38;55040:602;55177:45;;;55167:55;;;:6;:55;;;;55160:62;;;;;55004:693;55681:4;55674:11;;54861:843;;;;;;;:::o;16253:129::-;16326:4;16373:1;16350:3;:12;;:19;16363:5;16350:19;;;;;;;;;;;;:24;;16343:31;;16253:129;;;;:::o;51481:404::-;51575:1;51561:16;;:2;:16;;;;51553:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;51634:16;51642:7;51634;:16::i;:::-;51633:17;51625:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51696:45;51725:1;51729:2;51733:7;51696:20;:45::i;:::-;51754:30;51776:7;51754:13;:17;51768:2;51754:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;51797:29;51814:7;51823:2;51797:12;:16;;:29;;;;;:::i;:::-;;51869:7;51865:2;51844:33;;51861:1;51844:33;;;;;;;;;;;;51481:404;;:::o;14623:1544::-;14689:4;14807:18;14828:3;:12;;:19;14841:5;14828:19;;;;;;;;;;;;14807:40;;14878:1;14864:10;:15;14860:1300;;15226:21;15263:1;15250:10;:14;;;;:::i;:::-;15226:38;;15279:17;15320:1;15299:3;:11;;:18;;;;:22;;;;:::i;:::-;15279:42;;15566:17;15586:3;:11;;15598:9;15586:22;;;;;;;;;;;;;;;;;;;;;;;;15566:42;;15732:9;15703:3;:11;;15715:13;15703:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;15851:1;15835:13;:17;;;;:::i;:::-;15809:3;:12;;:23;15822:9;15809:23;;;;;;;;;;;:43;;;;15961:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16056:3;:12;;:19;16069:5;16056:19;;;;;;;;;;;16049:26;;;16099:4;16092:11;;;;;;;;14860:1300;16143:5;16136:12;;;14623:1544;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:133::-;;931:6;918:20;909:29;;947:30;971:5;947:30;:::i;:::-;899:84;;;;:::o;989:137::-;;1072:6;1059:20;1050:29;;1088:32;1114:5;1088:32;:::i;:::-;1040:86;;;;:::o;1132:141::-;;1219:6;1213:13;1204:22;;1235:32;1261:5;1235:32;:::i;:::-;1194:79;;;;:::o;1292:271::-;;1396:3;1389:4;1381:6;1377:17;1373:27;1363:2;;1414:1;1411;1404:12;1363:2;1454:6;1441:20;1479:78;1553:3;1545:6;1538:4;1530:6;1526:17;1479:78;:::i;:::-;1470:87;;1353:210;;;;;:::o;1583:273::-;;1688:3;1681:4;1673:6;1669:17;1665:27;1655:2;;1706:1;1703;1696:12;1655:2;1746:6;1733:20;1771:79;1846:3;1838:6;1831:4;1823:6;1819:17;1771:79;:::i;:::-;1762:88;;1645:211;;;;;:::o;1862:139::-;;1946:6;1933:20;1924:29;;1962:33;1989:5;1962:33;:::i;:::-;1914:87;;;;:::o;2007:262::-;;2115:2;2103:9;2094:7;2090:23;2086:32;2083:2;;;2131:1;2128;2121:12;2083:2;2174:1;2199:53;2244:7;2235:6;2224:9;2220:22;2199:53;:::i;:::-;2189:63;;2145:117;2073:196;;;;:::o;2275:407::-;;;2400:2;2388:9;2379:7;2375:23;2371:32;2368:2;;;2416:1;2413;2406:12;2368:2;2459:1;2484:53;2529:7;2520:6;2509:9;2505:22;2484:53;:::i;:::-;2474:63;;2430:117;2586:2;2612:53;2657:7;2648:6;2637:9;2633:22;2612:53;:::i;:::-;2602:63;;2557:118;2358:324;;;;;:::o;2688:552::-;;;;2830:2;2818:9;2809:7;2805:23;2801:32;2798:2;;;2846:1;2843;2836:12;2798:2;2889:1;2914:53;2959:7;2950:6;2939:9;2935:22;2914:53;:::i;:::-;2904:63;;2860:117;3016:2;3042:53;3087:7;3078:6;3067:9;3063:22;3042:53;:::i;:::-;3032:63;;2987:118;3144:2;3170:53;3215:7;3206:6;3195:9;3191:22;3170:53;:::i;:::-;3160:63;;3115:118;2788:452;;;;;:::o;3246:809::-;;;;;3414:3;3402:9;3393:7;3389:23;3385:33;3382:2;;;3431:1;3428;3421:12;3382:2;3474:1;3499:53;3544:7;3535:6;3524:9;3520:22;3499:53;:::i;:::-;3489:63;;3445:117;3601:2;3627:53;3672:7;3663:6;3652:9;3648:22;3627:53;:::i;:::-;3617:63;;3572:118;3729:2;3755:53;3800:7;3791:6;3780:9;3776:22;3755:53;:::i;:::-;3745:63;;3700:118;3885:2;3874:9;3870:18;3857:32;3916:18;3908:6;3905:30;3902:2;;;3948:1;3945;3938:12;3902:2;3976:62;4030:7;4021:6;4010:9;4006:22;3976:62;:::i;:::-;3966:72;;3828:220;3372:683;;;;;;;:::o;4061:401::-;;;4183:2;4171:9;4162:7;4158:23;4154:32;4151:2;;;4199:1;4196;4189:12;4151:2;4242:1;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4213:117;4369:2;4395:50;4437:7;4428:6;4417:9;4413:22;4395:50;:::i;:::-;4385:60;;4340:115;4141:321;;;;;:::o;4468:407::-;;;4593:2;4581:9;4572:7;4568:23;4564:32;4561:2;;;4609:1;4606;4599:12;4561:2;4652:1;4677:53;4722:7;4713:6;4702:9;4698:22;4677:53;:::i;:::-;4667:63;;4623:117;4779:2;4805:53;4850:7;4841:6;4830:9;4826:22;4805:53;:::i;:::-;4795:63;;4750:118;4551:324;;;;;:::o;4881:260::-;;4988:2;4976:9;4967:7;4963:23;4959:32;4956:2;;;5004:1;5001;4994:12;4956:2;5047:1;5072:52;5116:7;5107:6;5096:9;5092:22;5072:52;:::i;:::-;5062:62;;5018:116;4946:195;;;;:::o;5147:282::-;;5265:2;5253:9;5244:7;5240:23;5236:32;5233:2;;;5281:1;5278;5271:12;5233:2;5324:1;5349:63;5404:7;5395:6;5384:9;5380:22;5349:63;:::i;:::-;5339:73;;5295:127;5223:206;;;;:::o;5435:375::-;;5553:2;5541:9;5532:7;5528:23;5524:32;5521:2;;;5569:1;5566;5559:12;5521:2;5640:1;5629:9;5625:17;5612:31;5670:18;5662:6;5659:30;5656:2;;;5702:1;5699;5692:12;5656:2;5730:63;5785:7;5776:6;5765:9;5761:22;5730:63;:::i;:::-;5720:73;;5583:220;5511:299;;;;:::o;5816:262::-;;5924:2;5912:9;5903:7;5899:23;5895:32;5892:2;;;5940:1;5937;5930:12;5892:2;5983:1;6008:53;6053:7;6044:6;6033:9;6029:22;6008:53;:::i;:::-;5998:63;;5954:117;5882:196;;;;:::o;6084:179::-;;6174:46;6216:3;6208:6;6174:46;:::i;:::-;6252:4;6247:3;6243:14;6229:28;;6164:99;;;;:::o;6269:118::-;6356:24;6374:5;6356:24;:::i;:::-;6351:3;6344:37;6334:53;;:::o;6423:732::-;;6571:54;6619:5;6571:54;:::i;:::-;6641:86;6720:6;6715:3;6641:86;:::i;:::-;6634:93;;6751:56;6801:5;6751:56;:::i;:::-;6830:7;6861:1;6846:284;6871:6;6868:1;6865:13;6846:284;;;6947:6;6941:13;6974:63;7033:3;7018:13;6974:63;:::i;:::-;6967:70;;7060:60;7113:6;7060:60;:::i;:::-;7050:70;;6906:224;6893:1;6890;6886:9;6881:14;;6846:284;;;6850:14;7146:3;7139:10;;6547:608;;;;;;;:::o;7161:109::-;7242:21;7257:5;7242:21;:::i;:::-;7237:3;7230:34;7220:50;;:::o;7276:360::-;;7390:38;7422:5;7390:38;:::i;:::-;7444:70;7507:6;7502:3;7444:70;:::i;:::-;7437:77;;7523:52;7568:6;7563:3;7556:4;7549:5;7545:16;7523:52;:::i;:::-;7600:29;7622:6;7600:29;:::i;:::-;7595:3;7591:39;7584:46;;7366:270;;;;;:::o;7642:364::-;;7758:39;7791:5;7758:39;:::i;:::-;7813:71;7877:6;7872:3;7813:71;:::i;:::-;7806:78;;7893:52;7938:6;7933:3;7926:4;7919:5;7915:16;7893:52;:::i;:::-;7970:29;7992:6;7970:29;:::i;:::-;7965:3;7961:39;7954:46;;7734:272;;;;;:::o;8012:377::-;;8146:39;8179:5;8146:39;:::i;:::-;8201:89;8283:6;8278:3;8201:89;:::i;:::-;8194:96;;8299:52;8344:6;8339:3;8332:4;8325:5;8321:16;8299:52;:::i;:::-;8376:6;8371:3;8367:16;8360:23;;8122:267;;;;;:::o;8395:366::-;;8558:67;8622:2;8617:3;8558:67;:::i;:::-;8551:74;;8655:34;8651:1;8646:3;8642:11;8635:55;8721:4;8716:2;8711:3;8707:12;8700:26;8752:2;8747:3;8743:12;8736:19;;8541:220;;;:::o;8767:382::-;;8930:67;8994:2;8989:3;8930:67;:::i;:::-;8923:74;;9027:34;9023:1;9018:3;9014:11;9007:55;9093:20;9088:2;9083:3;9079:12;9072:42;9140:2;9135:3;9131:12;9124:19;;8913:236;;;:::o;9155:370::-;;9318:67;9382:2;9377:3;9318:67;:::i;:::-;9311:74;;9415:34;9411:1;9406:3;9402:11;9395:55;9481:8;9476:2;9471:3;9467:12;9460:30;9516:2;9511:3;9507:12;9500:19;;9301:224;;;:::o;9531:326::-;;9694:67;9758:2;9753:3;9694:67;:::i;:::-;9687:74;;9791:30;9787:1;9782:3;9778:11;9771:51;9848:2;9843:3;9839:12;9832:19;;9677:180;;;:::o;9863:368::-;;10026:67;10090:2;10085:3;10026:67;:::i;:::-;10019:74;;10123:34;10119:1;10114:3;10110:11;10103:55;10189:6;10184:2;10179:3;10175:12;10168:28;10222:2;10217:3;10213:12;10206:19;;10009:222;;;:::o;10237:323::-;;10400:67;10464:2;10459:3;10400:67;:::i;:::-;10393:74;;10497:27;10493:1;10488:3;10484:11;10477:48;10551:2;10546:3;10542:12;10535:19;;10383:177;;;:::o;10566:376::-;;10729:67;10793:2;10788:3;10729:67;:::i;:::-;10722:74;;10826:34;10822:1;10817:3;10813:11;10806:55;10892:14;10887:2;10882:3;10878:12;10871:36;10933:2;10928:3;10924:12;10917:19;;10712:230;;;:::o;10948:379::-;;11111:67;11175:2;11170:3;11111:67;:::i;:::-;11104:74;;11208:34;11204:1;11199:3;11195:11;11188:55;11274:17;11269:2;11264:3;11260:12;11253:39;11318:2;11313:3;11309:12;11302:19;;11094:233;;;:::o;11333:388::-;;11496:67;11560:2;11555:3;11496:67;:::i;:::-;11489:74;;11593:34;11589:1;11584:3;11580:11;11573:55;11659:26;11654:2;11649:3;11645:12;11638:48;11712:2;11707:3;11703:12;11696:19;;11479:242;;;:::o;11727:374::-;;11890:67;11954:2;11949:3;11890:67;:::i;:::-;11883:74;;11987:34;11983:1;11978:3;11974:11;11967:55;12053:12;12048:2;12043:3;12039:12;12032:34;12092:2;12087:3;12083:12;12076:19;;11873:228;;;:::o;12107:367::-;;12270:67;12334:2;12329:3;12270:67;:::i;:::-;12263:74;;12367:34;12363:1;12358:3;12354:11;12347:55;12433:5;12428:2;12423:3;12419:12;12412:27;12465:2;12460:3;12456:12;12449:19;;12253:221;;;:::o;12480:366::-;;12643:67;12707:2;12702:3;12643:67;:::i;:::-;12636:74;;12740:34;12736:1;12731:3;12727:11;12720:55;12806:4;12801:2;12796:3;12792:12;12785:26;12837:2;12832:3;12828:12;12821:19;;12626:220;;;:::o;12852:330::-;;13015:67;13079:2;13074:3;13015:67;:::i;:::-;13008:74;;13112:34;13108:1;13103:3;13099:11;13092:55;13173:2;13168:3;13164:12;13157:19;;12998:184;;;:::o;13188:376::-;;13351:67;13415:2;13410:3;13351:67;:::i;:::-;13344:74;;13448:34;13444:1;13439:3;13435:11;13428:55;13514:14;13509:2;13504:3;13500:12;13493:36;13555:2;13550:3;13546:12;13539:19;;13334:230;;;:::o;13570:330::-;;13733:67;13797:2;13792:3;13733:67;:::i;:::-;13726:74;;13830:34;13826:1;13821:3;13817:11;13810:55;13891:2;13886:3;13882:12;13875:19;;13716:184;;;:::o;13906:373::-;;14069:67;14133:2;14128:3;14069:67;:::i;:::-;14062:74;;14166:34;14162:1;14157:3;14153:11;14146:55;14232:11;14227:2;14222:3;14218:12;14211:33;14270:2;14265:3;14261:12;14254:19;;14052:227;;;:::o;14285:379::-;;14448:67;14512:2;14507:3;14448:67;:::i;:::-;14441:74;;14545:34;14541:1;14536:3;14532:11;14525:55;14611:17;14606:2;14601:3;14597:12;14590:39;14655:2;14650:3;14646:12;14639:19;;14431:233;;;:::o;14670:365::-;;14833:67;14897:2;14892:3;14833:67;:::i;:::-;14826:74;;14930:34;14926:1;14921:3;14917:11;14910:55;14996:3;14991:2;14986:3;14982:12;14975:25;15026:2;15021:3;15017:12;15010:19;;14816:219;;;:::o;15041:320::-;;15204:67;15268:2;15263:3;15204:67;:::i;:::-;15197:74;;15301:24;15297:1;15292:3;15288:11;15281:45;15352:2;15347:3;15343:12;15336:19;;15187:174;;;:::o;15367:381::-;;15530:67;15594:2;15589:3;15530:67;:::i;:::-;15523:74;;15627:34;15623:1;15618:3;15614:11;15607:55;15693:19;15688:2;15683:3;15679:12;15672:41;15739:2;15734:3;15730:12;15723:19;;15513:235;;;:::o;15754:317::-;;15917:67;15981:2;15976:3;15917:67;:::i;:::-;15910:74;;16014:21;16010:1;16005:3;16001:11;15994:42;16062:2;16057:3;16053:12;16046:19;;15900:171;;;:::o;16077:316::-;;16240:67;16304:2;16299:3;16240:67;:::i;:::-;16233:74;;16337:20;16333:1;16328:3;16324:11;16317:41;16384:2;16379:3;16375:12;16368:19;;16223:170;;;:::o;16399:108::-;16476:24;16494:5;16476:24;:::i;:::-;16471:3;16464:37;16454:53;;:::o;16513:118::-;16600:24;16618:5;16600:24;:::i;:::-;16595:3;16588:37;16578:53;;:::o;16637:435::-;;16839:95;16930:3;16921:6;16839:95;:::i;:::-;16832:102;;16951:95;17042:3;17033:6;16951:95;:::i;:::-;16944:102;;17063:3;17056:10;;16821:251;;;;;:::o;17078:222::-;;17209:2;17198:9;17194:18;17186:26;;17222:71;17290:1;17279:9;17275:17;17266:6;17222:71;:::i;:::-;17176:124;;;;:::o;17306:640::-;;17539:3;17528:9;17524:19;17516:27;;17553:71;17621:1;17610:9;17606:17;17597:6;17553:71;:::i;:::-;17634:72;17702:2;17691:9;17687:18;17678:6;17634:72;:::i;:::-;17716;17784:2;17773:9;17769:18;17760:6;17716:72;:::i;:::-;17835:9;17829:4;17825:20;17820:2;17809:9;17805:18;17798:48;17863:76;17934:4;17925:6;17863:76;:::i;:::-;17855:84;;17506:440;;;;;;;:::o;17952:373::-;;18133:2;18122:9;18118:18;18110:26;;18182:9;18176:4;18172:20;18168:1;18157:9;18153:17;18146:47;18210:108;18313:4;18304:6;18210:108;:::i;:::-;18202:116;;18100:225;;;;:::o;18331:210::-;;18456:2;18445:9;18441:18;18433:26;;18469:65;18531:1;18520:9;18516:17;18507:6;18469:65;:::i;:::-;18423:118;;;;:::o;18547:313::-;;18698:2;18687:9;18683:18;18675:26;;18747:9;18741:4;18737:20;18733:1;18722:9;18718:17;18711:47;18775:78;18848:4;18839:6;18775:78;:::i;:::-;18767:86;;18665:195;;;;:::o;18866:419::-;;19070:2;19059:9;19055:18;19047:26;;19119:9;19113:4;19109:20;19105:1;19094:9;19090:17;19083:47;19147:131;19273:4;19147:131;:::i;:::-;19139:139;;19037:248;;;:::o;19291:419::-;;19495:2;19484:9;19480:18;19472:26;;19544:9;19538:4;19534:20;19530:1;19519:9;19515:17;19508:47;19572:131;19698:4;19572:131;:::i;:::-;19564:139;;19462:248;;;:::o;19716:419::-;;19920:2;19909:9;19905:18;19897:26;;19969:9;19963:4;19959:20;19955:1;19944:9;19940:17;19933:47;19997:131;20123:4;19997:131;:::i;:::-;19989:139;;19887:248;;;:::o;20141:419::-;;20345:2;20334:9;20330:18;20322:26;;20394:9;20388:4;20384:20;20380:1;20369:9;20365:17;20358:47;20422:131;20548:4;20422:131;:::i;:::-;20414:139;;20312:248;;;:::o;20566:419::-;;20770:2;20759:9;20755:18;20747:26;;20819:9;20813:4;20809:20;20805:1;20794:9;20790:17;20783:47;20847:131;20973:4;20847:131;:::i;:::-;20839:139;;20737:248;;;:::o;20991:419::-;;21195:2;21184:9;21180:18;21172:26;;21244:9;21238:4;21234:20;21230:1;21219:9;21215:17;21208:47;21272:131;21398:4;21272:131;:::i;:::-;21264:139;;21162:248;;;:::o;21416:419::-;;21620:2;21609:9;21605:18;21597:26;;21669:9;21663:4;21659:20;21655:1;21644:9;21640:17;21633:47;21697:131;21823:4;21697:131;:::i;:::-;21689:139;;21587:248;;;:::o;21841:419::-;;22045:2;22034:9;22030:18;22022:26;;22094:9;22088:4;22084:20;22080:1;22069:9;22065:17;22058:47;22122:131;22248:4;22122:131;:::i;:::-;22114:139;;22012:248;;;:::o;22266:419::-;;22470:2;22459:9;22455:18;22447:26;;22519:9;22513:4;22509:20;22505:1;22494:9;22490:17;22483:47;22547:131;22673:4;22547:131;:::i;:::-;22539:139;;22437:248;;;:::o;22691:419::-;;22895:2;22884:9;22880:18;22872:26;;22944:9;22938:4;22934:20;22930:1;22919:9;22915:17;22908:47;22972:131;23098:4;22972:131;:::i;:::-;22964:139;;22862:248;;;:::o;23116:419::-;;23320:2;23309:9;23305:18;23297:26;;23369:9;23363:4;23359:20;23355:1;23344:9;23340:17;23333:47;23397:131;23523:4;23397:131;:::i;:::-;23389:139;;23287:248;;;:::o;23541:419::-;;23745:2;23734:9;23730:18;23722:26;;23794:9;23788:4;23784:20;23780:1;23769:9;23765:17;23758:47;23822:131;23948:4;23822:131;:::i;:::-;23814:139;;23712:248;;;:::o;23966:419::-;;24170:2;24159:9;24155:18;24147:26;;24219:9;24213:4;24209:20;24205:1;24194:9;24190:17;24183:47;24247:131;24373:4;24247:131;:::i;:::-;24239:139;;24137:248;;;:::o;24391:419::-;;24595:2;24584:9;24580:18;24572:26;;24644:9;24638:4;24634:20;24630:1;24619:9;24615:17;24608:47;24672:131;24798:4;24672:131;:::i;:::-;24664:139;;24562:248;;;:::o;24816:419::-;;25020:2;25009:9;25005:18;24997:26;;25069:9;25063:4;25059:20;25055:1;25044:9;25040:17;25033:47;25097:131;25223:4;25097:131;:::i;:::-;25089:139;;24987:248;;;:::o;25241:419::-;;25445:2;25434:9;25430:18;25422:26;;25494:9;25488:4;25484:20;25480:1;25469:9;25465:17;25458:47;25522:131;25648:4;25522:131;:::i;:::-;25514:139;;25412:248;;;:::o;25666:419::-;;25870:2;25859:9;25855:18;25847:26;;25919:9;25913:4;25909:20;25905:1;25894:9;25890:17;25883:47;25947:131;26073:4;25947:131;:::i;:::-;25939:139;;25837:248;;;:::o;26091:419::-;;26295:2;26284:9;26280:18;26272:26;;26344:9;26338:4;26334:20;26330:1;26319:9;26315:17;26308:47;26372:131;26498:4;26372:131;:::i;:::-;26364:139;;26262:248;;;:::o;26516:419::-;;26720:2;26709:9;26705:18;26697:26;;26769:9;26763:4;26759:20;26755:1;26744:9;26740:17;26733:47;26797:131;26923:4;26797:131;:::i;:::-;26789:139;;26687:248;;;:::o;26941:419::-;;27145:2;27134:9;27130:18;27122:26;;27194:9;27188:4;27184:20;27180:1;27169:9;27165:17;27158:47;27222:131;27348:4;27222:131;:::i;:::-;27214:139;;27112:248;;;:::o;27366:419::-;;27570:2;27559:9;27555:18;27547:26;;27619:9;27613:4;27609:20;27605:1;27594:9;27590:17;27583:47;27647:131;27773:4;27647:131;:::i;:::-;27639:139;;27537:248;;;:::o;27791:419::-;;27995:2;27984:9;27980:18;27972:26;;28044:9;28038:4;28034:20;28030:1;28019:9;28015:17;28008:47;28072:131;28198:4;28072:131;:::i;:::-;28064:139;;27962:248;;;:::o;28216:222::-;;28347:2;28336:9;28332:18;28324:26;;28360:71;28428:1;28417:9;28413:17;28404:6;28360:71;:::i;:::-;28314:124;;;;:::o;28444:283::-;;28510:2;28504:9;28494:19;;28552:4;28544:6;28540:17;28659:6;28647:10;28644:22;28623:18;28611:10;28608:34;28605:62;28602:2;;;28670:18;;:::i;:::-;28602:2;28710:10;28706:2;28699:22;28484:243;;;;:::o;28733:331::-;;28884:18;28876:6;28873:30;28870:2;;;28906:18;;:::i;:::-;28870:2;28991:4;28987:9;28980:4;28972:6;28968:17;28964:33;28956:41;;29052:4;29046;29042:15;29034:23;;28799:265;;;:::o;29070:332::-;;29222:18;29214:6;29211:30;29208:2;;;29244:18;;:::i;:::-;29208:2;29329:4;29325:9;29318:4;29310:6;29306:17;29302:33;29294:41;;29390:4;29384;29380:15;29372:23;;29137:265;;;:::o;29408:132::-;;29498:3;29490:11;;29528:4;29523:3;29519:14;29511:22;;29480:60;;;:::o;29546:114::-;;29647:5;29641:12;29631:22;;29620:40;;;:::o;29666:98::-;;29751:5;29745:12;29735:22;;29724:40;;;:::o;29770:99::-;;29856:5;29850:12;29840:22;;29829:40;;;:::o;29875:113::-;;29977:4;29972:3;29968:14;29960:22;;29950:38;;;:::o;29994:184::-;;30127:6;30122:3;30115:19;30167:4;30162:3;30158:14;30143:29;;30105:73;;;;:::o;30184:168::-;;30301:6;30296:3;30289:19;30341:4;30336:3;30332:14;30317:29;;30279:73;;;;:::o;30358:169::-;;30476:6;30471:3;30464:19;30516:4;30511:3;30507:14;30492:29;;30454:73;;;;:::o;30533:148::-;;30672:3;30657:18;;30647:34;;;;:::o;30687:305::-;;30746:20;30764:1;30746:20;:::i;:::-;30741:25;;30780:20;30798:1;30780:20;:::i;:::-;30775:25;;30934:1;30866:66;30862:74;30859:1;30856:81;30853:2;;;30940:18;;:::i;:::-;30853:2;30984:1;30981;30977:9;30970:16;;30731:261;;;;:::o;30998:185::-;;31055:20;31073:1;31055:20;:::i;:::-;31050:25;;31089:20;31107:1;31089:20;:::i;:::-;31084:25;;31128:1;31118:2;;31133:18;;:::i;:::-;31118:2;31175:1;31172;31168:9;31163:14;;31040:143;;;;:::o;31189:348::-;;31252:20;31270:1;31252:20;:::i;:::-;31247:25;;31286:20;31304:1;31286:20;:::i;:::-;31281:25;;31474:1;31406:66;31402:74;31399:1;31396:81;31391:1;31384:9;31377:17;31373:105;31370:2;;;31481:18;;:::i;:::-;31370:2;31529:1;31526;31522:9;31511:20;;31237:300;;;;:::o;31543:191::-;;31603:20;31621:1;31603:20;:::i;:::-;31598:25;;31637:20;31655:1;31637:20;:::i;:::-;31632:25;;31676:1;31673;31670:8;31667:2;;;31681:18;;:::i;:::-;31667:2;31726:1;31723;31719:9;31711:17;;31588:146;;;;:::o;31740:96::-;;31806:24;31824:5;31806:24;:::i;:::-;31795:35;;31785:51;;;:::o;31842:90::-;;31919:5;31912:13;31905:21;31894:32;;31884:48;;;:::o;31938:149::-;;32014:66;32007:5;32003:78;31992:89;;31982:105;;;:::o;32093:126::-;;32170:42;32163:5;32159:54;32148:65;;32138:81;;;:::o;32225:77::-;;32291:5;32280:16;;32270:32;;;:::o;32308:154::-;32392:6;32387:3;32382;32369:30;32454:1;32445:6;32440:3;32436:16;32429:27;32359:103;;;:::o;32468:307::-;32536:1;32546:113;32560:6;32557:1;32554:13;32546:113;;;32645:1;32640:3;32636:11;32630:18;32626:1;32621:3;32617:11;32610:39;32582:2;32579:1;32575:10;32570:15;;32546:113;;;32677:6;32674:1;32671:13;32668:2;;;32757:1;32748:6;32743:3;32739:16;32732:27;32668:2;32517:258;;;;:::o;32781:320::-;;32862:1;32856:4;32852:12;32842:22;;32909:1;32903:4;32899:12;32930:18;32920:2;;32986:4;32978:6;32974:17;32964:27;;32920:2;33048;33040:6;33037:14;33017:18;33014:38;33011:2;;;33067:18;;:::i;:::-;33011:2;32832:269;;;;:::o;33107:233::-;;33169:24;33187:5;33169:24;:::i;:::-;33160:33;;33215:66;33208:5;33205:77;33202:2;;;33285:18;;:::i;:::-;33202:2;33332:1;33325:5;33321:13;33314:20;;33150:190;;;:::o;33346:176::-;;33395:20;33413:1;33395:20;:::i;:::-;33390:25;;33429:20;33447:1;33429:20;:::i;:::-;33424:25;;33468:1;33458:2;;33473:18;;:::i;:::-;33458:2;33514:1;33511;33507:9;33502:14;;33380:142;;;;:::o;33528:180::-;33576:77;33573:1;33566:88;33673:4;33670:1;33663:15;33697:4;33694:1;33687:15;33714:180;33762:77;33759:1;33752:88;33859:4;33856:1;33849:15;33883:4;33880:1;33873:15;33900:180;33948:77;33945:1;33938:88;34045:4;34042:1;34035:15;34069:4;34066:1;34059:15;34086:180;34134:77;34131:1;34124:88;34231:4;34228:1;34221:15;34255:4;34252:1;34245:15;34272:102;;34364:2;34360:7;34355:2;34348:5;34344:14;34340:28;34330:38;;34320:54;;;:::o;34380:122::-;34453:24;34471:5;34453:24;:::i;:::-;34446:5;34443:35;34433:2;;34492:1;34489;34482:12;34433:2;34423:79;:::o;34508:116::-;34578:21;34593:5;34578:21;:::i;:::-;34571:5;34568:32;34558:2;;34614:1;34611;34604:12;34558:2;34548:76;:::o;34630:120::-;34702:23;34719:5;34702:23;:::i;:::-;34695:5;34692:34;34682:2;;34740:1;34737;34730:12;34682:2;34672:78;:::o;34756:122::-;34829:24;34847:5;34829:24;:::i;:::-;34822:5;34819:35;34809:2;;34868:1;34865;34858:12;34809:2;34799:79;:::o

Swarm Source

ipfs://714a668335f40ce94d94b6689d1c54554b24f75d0b5452cafe3905e1cb9b033f

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