Token Avaxtars

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

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

    struct Price {
        uint256 tokenId;
        uint256 price;
        TokenState state;
    }
    enum TokenState {Pending, ForSale, Sold, Transferred, Neutral}
    mapping(uint256 => Price) public Bazaar;
    event Bought(uint256 tokenId, uint256 value);
    event ForSale(uint256 id, uint256 price);
    address payable feeReceiver;
    // 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();
    }


    function _cancelSale(uint256 id) internal {
        delete Bazaar[id].price;
        Bazaar[id].state = TokenState.Neutral;
    }





    /**
     * @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);
        _cancelSale(tokenId);
        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 Avaxtars is ERC721, Ownable {
    using SafeMath for uint256;
    uint public constant MAX_AVATARS = 10000;
    bool public hasSaleStarted = false;
    address public feeAddress1 = 0x7B9c08898B60345671BaC9091F438382A1Fc4799;
    address public feeAddress2 = 0x341B7Cb6aD822CD6b2B18D3a42b5DA1A721468fE;
    address public feeAddress3 = 0xf369FF2f36BA46cC37cf125eC62D3638Ad378A58;
    address payable feeReceiver2;
    address payable feeReceiver3;

    string public METADATA_PROVENANCE_HASH = "";
    struct Bid {
        address bidder;
        uint256 highestBid;
    }
    mapping(uint256 => Bid) public Bids;


    constructor() ERC721("Avaxtars","AVXT")  {
        setBaseURI("https://us.avaxtars.com/api/avatar/");
        feeReceiver = payable(feeAddress1);
        feeReceiver2 = payable(feeAddress2);
        feeReceiver3 = payable(feeAddress3);

        _safeMint(msg.sender,0);
    }

    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_AVATARS, "Sale has already ended");

        uint currentSupply = totalSupply();

        if (currentSupply >= 8500) {
            return 3000000000000000000;
        } else if (currentSupply >= 6500) {
            return 2000000000000000000;
        }  else if (currentSupply >= 4500) {
            return 1500000000000000000;
        } else if (currentSupply >= 3500) {
            return 1250000000000000000;
        } else if (currentSupply >= 2500) {
            return 1000000000000000000;
        }  else if (currentSupply >= 2000) {
            return 850000000000000000;
        }  else if (currentSupply >= 1500) {
            return 800000000000000000;
        } else if (currentSupply >= 1250) {
            return 600000000000000000;
        } else if (currentSupply >= 1000) {
            return 500000000000000000;
        } else if (currentSupply >= 750) {
            return 400000000000000000;
        } else if (currentSupply >= 500) {
            return 300000000000000000;
        } else if (currentSupply >= 250) {
            return 200000000000000000;
        } else {
            return 100000000000000000;
        }
    }


   function buyAvatars(uint256 count) public payable {
        require(totalSupply() < MAX_AVATARS, "Sale has already ended");
        require(count > 0 && count <= 5, "You can generate minimum 1, maximum 5 Avaxtars");
        require(totalSupply().add(count) <= MAX_AVATARS, "Exceeds MAX_AVATARS");
        require(msg.value >= calculatePrice().mul(count), "Avax value sent is below the price");

        for (uint i = 0; i < count; 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;
    }

    // MARKET
    function setTokenPrice(uint256 id, uint256 setPrice) public {
        require(msg.sender == ownerOf(id));
        Bazaar[id].price = setPrice;
        Bazaar[id].state = TokenState.ForSale;
    }

    function cancelTokenSale(uint256 id) public {
        require(msg.sender == ownerOf(id));
        delete Bazaar[id].price;
        Bazaar[id].state = TokenState.Neutral;
    }

    function approveBid(uint256 _tokenId) public {
        uint bidAmount = Bids[_tokenId].highestBid;

        require(msg.sender == ownerOf(_tokenId));
        require(bidAmount > 0, "There is no active bid");
        require(address(this).balance >= bidAmount, "Current balance is not enough for withdrawal");

        address tokenOwner = ownerOf(_tokenId);
        address payable seller = payable(address(tokenOwner));

        Bids[_tokenId].highestBid = 0;

        uint256 fee = serviceFee(bidAmount);
        uint256 fee1 = fee / 2;
        uint256 fee2 = fee / 4;
        uint256 fee3 = fee - fee1 - fee2;
        uint256 withFee = SafeMath.sub(bidAmount, fee);

        seller.transfer(withFee);
        feeReceiver.transfer(fee1);
        feeReceiver2.transfer(fee2);
        feeReceiver3.transfer(fee3);

        _transfer(ownerOf(_tokenId), Bids[_tokenId].bidder, _tokenId);
        Bazaar[_tokenId].state = TokenState.Sold;

        delete Bids[_tokenId];
    }

    function withdrawBid(uint _tokenId) public returns (bool) {
        uint bidAmount = Bids[_tokenId].highestBid;

        require(bidAmount > 0, "There is no active bid");
        require(msg.sender == Bids[_tokenId].bidder);
        require(address(this).balance >= bidAmount, "Current balance is not enough for withdrawal");

        address payable bidder = payable(Bids[_tokenId].bidder);

        Bids[_tokenId].highestBid = 0;

        if(!bidder.send(bidAmount))
        {
            Bids[_tokenId].highestBid = bidAmount;
            return false;
        }
        else
        {
            delete Bids[_tokenId];
            return true;
        }
    }

    function buy(uint256 _tokenId) public payable {
        require(msg.value >= Bazaar[_tokenId].price, "Price issue");
        require(TokenState.ForSale == Bazaar[_tokenId].state, "No Sale");

        address tokenOwner = ownerOf(_tokenId);
        address payable seller = payable(address(tokenOwner));

        if (Bazaar[_tokenId].price >= 0) {
            uint256 fee = serviceFee(msg.value);
            uint256 fee1 = fee / 2;
            uint256 fee2 = fee / 4;
            uint256 fee3 = fee - fee1 - fee2;
            uint256 withFee = SafeMath.sub(msg.value, fee);

            seller.transfer(withFee);
            feeReceiver.transfer(fee1);
            feeReceiver2.transfer(fee2);
            feeReceiver3.transfer(fee3);
        }

        _transfer(ownerOf(_tokenId), msg.sender, _tokenId);
        Bazaar[_tokenId].state = TokenState.Sold;
    }

    function bid(uint256 _tokenId) public payable {
        require(_tokenId <= totalSupply(), "No Sale");
        require(msg.value > Bids[_tokenId].highestBid, "You can only bid higher then highestBid");
        require(msg.sender != ownerOf(_tokenId), "You cannot bid to your own Avaxtar");

        if (Bids[_tokenId].highestBid > 0) {
            require(payable(Bids[_tokenId].bidder).send(Bids[_tokenId].highestBid), "Couldnt cancel previous Bid");

            Bids[_tokenId].bidder = msg.sender;
            Bids[_tokenId].highestBid = msg.value;
        } else {
            Bids[_tokenId].highestBid = msg.value;
            Bids[_tokenId].bidder = msg.sender;
        }
    }

    function serviceFee(uint256 amount) internal pure returns (uint256) {
        uint256 toOwner = SafeMath.mul(amount, 5);

        return SafeMath.div(toOwner, 100);
    }

    function getWaitingBids()  public view onlyOwner returns(uint256) {
        uint count = totalSupply();
        uint i;
        uint256 totalAmount = 0;
        for(i = 0; i < count; i++)
        {
            if(Bids[i].highestBid > 0)
            {
                totalAmount += Bids[i].highestBid;
            }
        }

        return totalAmount;
    }

    function withdrawal() public payable onlyOwner {
        uint256 freeBalance = address(this).balance - getWaitingBids();
        uint256 balance1 = freeBalance / 2;
        uint256 balance2 = freeBalance / 4;
        uint256 balance3 = freeBalance - balance1 - balance2;

        require(payable(feeReceiver).send(balance1));
        require(payable(feeReceiver2).send(balance2));
        require(payable(feeReceiver3).send(balance3));
    }

    function emergencyWithdrawal() public payable onlyOwner {
        uint256 freeBalance = address(this).balance;
        uint256 balance1 = freeBalance / 2;
        uint256 balance2 = freeBalance / 4;
        uint256 balance3 = freeBalance - balance1 - balance2;

        require(payable(feeReceiver).send(balance1));
        require(payable(feeReceiver2).send(balance2));
        require(payable(feeReceiver3).send(balance3));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Bought","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"}],"name":"ForSale","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"Bazaar","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"enum ERC721.TokenState","name":"state","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"Bids","outputs":[{"internalType":"address","name":"bidder","type":"address"},{"internalType":"uint256","name":"highestBid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_AVATARS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"METADATA_PROVENANCE_HASH","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"approveBid","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":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"bid","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"buyAvatars","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"calculatePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"cancelTokenSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdrawal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"feeAddress1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress3","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"getWaitingBids","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"setPrice","type":"uint256"}],"name":"setTokenPrice","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":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"withdrawBid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawal","outputs":[],"stateMutability":"payable","type":"function"}]

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

66477:8996:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31683:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43861:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46647:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46177:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71720:685;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69899:116;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45655:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66642:71;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66601:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47537:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70216:79;;;;;;;;;;;;;:::i;:::-;;70525:179;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45417:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70130:78;;;;;;;;;;;;;:::i;:::-;;47913:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73304:697;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45943:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70023:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69308:553;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75030:440;;;:::i;:::-;;70712:1000;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43617:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45236:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43184:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58753:148;;;;;;;;;;;;;:::i;:::-;;67077:35;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;41686:39;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;67413:540;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58102:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44030:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46940:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66554:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48135:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74191:373;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44205:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67961:1338;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74572:450;;;:::i;:::-;;72413:883;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66798:71;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47306:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70318:199;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66720:71;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66948:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59056:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;31683:150;31768:4;31792:20;:33;31813:11;31792:33;;;;;;;;;;;;;;;;;;;;;;;;;;;31785:40;;31683:150;;;:::o;43861:100::-;43915:13;43948:5;43941:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43861:100;:::o;46647:221::-;46723:7;46751:16;46759:7;46751;:16::i;:::-;46743:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;46836:15;:24;46852:7;46836:24;;;;;;;;;;;;;;;;;;;;;46829:31;;46647:221;;;:::o;46177:404::-;46258:13;46274:23;46289:7;46274:14;:23::i;:::-;46258:39;;46322:5;46316:11;;:2;:11;;;;46308:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;46402:5;46386:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;46411:44;46435:5;46442:12;:10;:12::i;:::-;46411:23;:44::i;:::-;46386:69;46378:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;46552:21;46561:2;46565:7;46552:8;:21::i;:::-;46177:404;;;:::o;71720:685::-;71772:4;71789:14;71806:4;:14;71811:8;71806:14;;;;;;;;;;;:25;;;71789:42;;71864:1;71852:9;:13;71844:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;71925:4;:14;71930:8;71925:14;;;;;;;;;;;:21;;;;;;;;;;;;71911:35;;:10;:35;;;71903:44;;;;;;71991:9;71966:21;:34;;71958:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;72062:22;72095:4;:14;72100:8;72095:14;;;;;;;;;;;:21;;;;;;;;;;;;72062:55;;72158:1;72130:4;:14;72135:8;72130:14;;;;;;;;;;;:25;;:29;;;;72176:6;:11;;:22;72188:9;72176:22;;;;;;;;;;;;;;;;;;;;;;;72172:226;;72252:9;72224:4;:14;72229:8;72224:14;;;;;;;;;;;:25;;:37;;;;72283:5;72276:12;;;;;;72172:226;72346:4;:14;72351:8;72346:14;;;;;;;;;;;;72339:21;;;;;;;;;;;;;;;;;;;;;;;72382:4;72375:11;;;;71720:685;;;;:::o;69899:116::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70002:5:::1;69975:24;:32;;;;;;;;;;;;:::i;:::-;;69899:116:::0;:::o;45655:211::-;45716:7;45837:21;:12;:19;:21::i;:::-;45830:28;;45655:211;:::o;66642:71::-;;;;;;;;;;;;;:::o;66601:34::-;;;;;;;;;;;;;:::o;47537:305::-;47698:41;47717:12;:10;:12::i;:::-;47731:7;47698:18;:41::i;:::-;47690:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;47806:28;47816:4;47822:2;47826:7;47806:9;:28::i;:::-;47537:305;;;:::o;70216:79::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70282:5:::1;70265:14;;:22;;;;;;;;;;;;;;;;;;70216:79::o:0;70525:179::-;70602:11;70610:2;70602:7;:11::i;:::-;70588:25;;:10;:25;;;70580:34;;;;;;70632:6;:10;70639:2;70632:10;;;;;;;;;;;:16;;70625:23;;;70678:18;70659:6;:10;70666:2;70659:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70525:179;:::o;45417:162::-;45514:7;45541:30;45565:5;45541:13;:20;45555:5;45541:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;45534:37;;45417:162;;;;:::o;70130:78::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70196:4:::1;70179:14;;:21;;;;;;;;;;;;;;;;;;70130:78::o:0;47913:151::-;48017:39;48034:4;48040:2;48044:7;48017:39;;;;;;;;;;;;:16;:39::i;:::-;47913:151;;;:::o;73304:697::-;73381:13;:11;:13::i;:::-;73369:8;:25;;73361:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;73437:4;:14;73442:8;73437:14;;;;;;;;;;;:25;;;73425:9;:37;73417:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;73539:17;73547:8;73539:7;:17::i;:::-;73525:31;;:10;:31;;;;73517:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;73640:1;73612:4;:14;73617:8;73612:14;;;;;;;;;;;:25;;;:29;73608:386;;;73674:4;:14;73679:8;73674:14;;;;;;;;;;;:21;;;;;;;;;;;;73666:35;;:62;73702:4;:14;73707:8;73702:14;;;;;;;;;;;:25;;;73666:62;;;;;;;;;;;;;;;;;;;;;;;73658:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;73801:10;73777:4;:14;73782:8;73777:14;;;;;;;;;;;:21;;;:34;;;;;;;;;;;;;;;;;;73854:9;73826:4;:14;73831:8;73826:14;;;;;;;;;;;:25;;:37;;;;73608:386;;;73924:9;73896:4;:14;73901:8;73896:14;;;;;;;;;;;:25;;:37;;;;73972:10;73948:4;:14;73953:8;73948:14;;;;;;;;;;;:21;;;:34;;;;;;;;;;;;;;;;;;73608:386;73304:697;:::o;45943:172::-;46018:7;46039:15;46060:22;46076:5;46060:12;:15;;:22;;;;:::i;:::-;46038:44;;;46100:7;46093:14;;;45943:172;;;:::o;70023:99::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70094:20:::1;70106:7;70094:11;:20::i;:::-;70023:99:::0;:::o;69308:553::-;66589:5;69377:13;:11;:13::i;:::-;:27;69369:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;69458:1;69450:5;:9;:23;;;;;69472:1;69463:5;:10;;69450:23;69442:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;66589:5;69543:24;69561:5;69543:13;:11;:13::i;:::-;:17;;:24;;;;:::i;:::-;:39;;69535:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;69638:27;69659:5;69638:16;:14;:16::i;:::-;:20;;:27;;;;:::i;:::-;69625:9;:40;;69617:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;69722:6;69717:137;69738:5;69734:1;:9;69717:137;;;69765:14;69782:13;:11;:13::i;:::-;69765:30;;69810:32;69820:10;69832:9;69810;:32::i;:::-;69717:137;69745:3;;;;;:::i;:::-;;;;69717:137;;;;69308:553;:::o;75030:440::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;75097:19:::1;75119:21;75097:43;;75151:16;75184:1;75170:11;:15;;;;:::i;:::-;75151:34;;75196:16;75229:1;75215:11;:15;;;;:::i;:::-;75196:34;;75241:16;75285:8;75274;75260:11;:22;;;;:::i;:::-;:33;;;;:::i;:::-;75241:52;;75322:11;;;;;;;;;;;75314:25;;:35;75340:8;75314:35;;;;;;;;;;;;;;;;;;;;;;;75306:44;;;::::0;::::1;;75377:12;;;;;;;;;;;75369:26;;:36;75396:8;75369:36;;;;;;;;;;;;;;;;;;;;;;;75361:45;;;::::0;::::1;;75433:12;;;;;;;;;;;75425:26;;:36;75452:8;75425:36;;;;;;;;;;;;;;;;;;;;;;;75417:45;;;::::0;::::1;;58393:1;;;;75030:440::o:0;70712:1000::-;70768:14;70785:4;:14;70790:8;70785:14;;;;;;;;;;;:25;;;70768:42;;70845:17;70853:8;70845:7;:17::i;:::-;70831:31;;:10;:31;;;70823:40;;;;;;70894:1;70882:9;:13;70874:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;70966:9;70941:21;:34;;70933:91;;;;;;;;;;;;:::i;:::-;;;;;;;;;71037:18;71058:17;71066:8;71058:7;:17::i;:::-;71037:38;;71086:22;71127:10;71086:53;;71180:1;71152:4;:14;71157:8;71152:14;;;;;;;;;;;:25;;:29;;;;71194:11;71208:21;71219:9;71208:10;:21::i;:::-;71194:35;;71240:12;71261:1;71255:3;:7;;;;:::i;:::-;71240:22;;71273:12;71294:1;71288:3;:7;;;;:::i;:::-;71273:22;;71306:12;71334:4;71327;71321:3;:10;;;;:::i;:::-;:17;;;;:::i;:::-;71306:32;;71349:15;71367:28;71380:9;71391:3;71367:12;:28::i;:::-;71349:46;;71408:6;:15;;:24;71424:7;71408:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71443:11;;;;;;;;;;;:20;;:26;71464:4;71443:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71480:12;;;;;;;;;;;:21;;:27;71502:4;71480:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71518:12;;;;;;;;;;;:21;;:27;71540:4;71518:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71558:61;71568:17;71576:8;71568:7;:17::i;:::-;71587:4;:14;71592:8;71587:14;;;;;;;;;;;:21;;;;;;;;;;;;71610:8;71558:9;:61::i;:::-;71655:15;71630:6;:16;71637:8;71630:16;;;;;;;;;;;:22;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71690:4;:14;71695:8;71690:14;;;;;;;;;;;;71683:21;;;;;;;;;;;;;;;;;;;;;;;70712:1000;;;;;;;;;:::o;43617:177::-;43689:7;43716:70;43733:7;43716:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;43709:77;;43617:177;;;:::o;45236:97::-;45284:13;45317:8;45310:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45236:97;:::o;43184:221::-;43256:7;43301:1;43284:19;;:5;:19;;;;43276:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;43368:29;:13;:20;43382:5;43368:20;;;;;;;;;;;;;;;:27;:29::i;:::-;43361:36;;43184:221;;;:::o;58753:148::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58860:1:::1;58823:40;;58844:6;;;;;;;;;;;58823:40;;;;;;;;;;;;58891:1;58874:6;;:19;;;;;;;;;;;;;;;;;;58753:148::o:0;67077:35::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;41686:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;67413:540::-;67474:16;67504:18;67525:17;67535:6;67525:9;:17::i;:::-;67504:38;;67571:1;67557:10;:15;67553:393;;;67648:1;67634:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67627:23;;;;;67553:393;67683:23;67723:10;67709:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67683:51;;67749:13;67777:130;67801:10;67793:5;:18;67777:130;;;67857:34;67877:6;67885:5;67857:19;:34::i;:::-;67841:6;67848:5;67841:13;;;;;;;;;;;;;;;;;;;;;:50;;;;;67813:7;;;;;:::i;:::-;;;;67777:130;;;67928:6;67921:13;;;;;67413:540;;;;:::o;58102:87::-;58148:7;58175:6;;;;;;;;;;;58168:13;;58102:87;:::o;44030:104::-;44086:13;44119:7;44112:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44030:104;:::o;46940:295::-;47055:12;:10;:12::i;:::-;47043:24;;:8;:24;;;;47035:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;47155:8;47110:18;:32;47129:12;:10;:12::i;:::-;47110:32;;;;;;;;;;;;;;;:42;47143:8;47110:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;47208:8;47179:48;;47194:12;:10;:12::i;:::-;47179:48;;;47218:8;47179:48;;;;;;:::i;:::-;;;;;;;;46940:295;;:::o;66554:40::-;66589:5;66554:40;:::o;48135:285::-;48267:41;48286:12;:10;:12::i;:::-;48300:7;48267:18;:41::i;:::-;48259:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;48373:39;48387:4;48393:2;48397:7;48406:5;48373:13;:39::i;:::-;48135:285;;;;:::o;74191:373::-;74248:7;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74268:10:::1;74281:13;:11;:13::i;:::-;74268:26;;74305:6;74322:19:::0;74344:1:::1;74322:23;;74364:1;74360:5;;74356:170;74371:5;74367:1;:9;74356:170;;;74431:1;74410:4;:7;74415:1;74410:7;;;;;;;;;;;:18;;;:22;74407:108;;;74481:4;:7;74486:1;74481:7;;;;;;;;;;;:18;;;74466:33;;;;;:::i;:::-;;;74407:108;74378:3;;;;;:::i;:::-;;;;74356:170;;;74545:11;74538:18;;;;;74191:373:::0;:::o;44205:792::-;44278:13;44312:16;44320:7;44312;:16::i;:::-;44304:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;44393:23;44419:10;:19;44430:7;44419:19;;;;;;;;;;;44393:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44449:18;44470:9;:7;:9::i;:::-;44449:30;;44577:1;44561:4;44555:18;:23;44551:72;;;44602:9;44595:16;;;;;;44551:72;44753:1;44733:9;44727:23;:27;44723:108;;;44802:4;44808:9;44785:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44771:48;;;;;;44723:108;44963:4;44969:18;:7;:16;:18::i;:::-;44946:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44932:57;;;;44205:792;;;;:::o;67961:1338::-;68008:7;68054:4;68036:22;;:14;;;;;;;;;;;:22;;;68028:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;66589:5;68101:13;:11;:13::i;:::-;:27;68093:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;68168:18;68189:13;:11;:13::i;:::-;68168:34;;68236:4;68219:13;:21;68215:1077;;68264:19;68257:26;;;;;68215:1077;68322:4;68305:13;:21;68301:991;;68350:19;68343:26;;;;;68301:991;68409:4;68392:13;:21;68388:904;;68437:19;68430:26;;;;;68388:904;68495:4;68478:13;:21;68474:818;;68523:19;68516:26;;;;;68474:818;68581:4;68564:13;:21;68560:732;;68609:19;68602:26;;;;;68560:732;68668:4;68651:13;:21;68647:645;;68696:18;68689:25;;;;;68647:645;68754:4;68737:13;:21;68733:559;;68782:18;68775:25;;;;;68733:559;68839:4;68822:13;:21;68818:474;;68867:18;68860:25;;;;;68818:474;68924:4;68907:13;:21;68903:389;;68952:18;68945:25;;;;;68903:389;69009:3;68992:13;:20;68988:304;;69036:18;69029:25;;;;;68988:304;69093:3;69076:13;:20;69072:220;;69120:18;69113:25;;;;;69072:220;69177:3;69160:13;:20;69156:136;;69204:18;69197:25;;;;;69156:136;69262:18;69255:25;;;67961:1338;;:::o;74572:450::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74630:19:::1;74676:16;:14;:16::i;:::-;74652:21;:40;;;;:::i;:::-;74630:62;;74703:16;74736:1;74722:11;:15;;;;:::i;:::-;74703:34;;74748:16;74781:1;74767:11;:15;;;;:::i;:::-;74748:34;;74793:16;74837:8;74826;74812:11;:22;;;;:::i;:::-;:33;;;;:::i;:::-;74793:52;;74874:11;;;;;;;;;;;74866:25;;:35;74892:8;74866:35;;;;;;;;;;;;;;;;;;;;;;;74858:44;;;::::0;::::1;;74929:12;;;;;;;;;;;74921:26;;:36;74948:8;74921:36;;;;;;;;;;;;;;;;;;;;;;;74913:45;;;::::0;::::1;;74985:12;;;;;;;;;;;74977:26;;:36;75004:8;74977:36;;;;;;;;;;;;;;;;;;;;;;;74969:45;;;::::0;::::1;;58393:1;;;;74572:450::o:0;72413:883::-;72491:6;:16;72498:8;72491:16;;;;;;;;;;;:22;;;72478:9;:35;;72470:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;72570:6;:16;72577:8;72570:16;;;;;;;;;;;:22;;;;;;;;;;;;72548:44;;;;;;;;;;;;;;;;:18;:44;;;;;;;;;;;;;;;;;72540:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;72617:18;72638:17;72646:8;72638:7;:17::i;:::-;72617:38;;72666:22;72707:10;72666:53;;72762:1;72736:6;:16;72743:8;72736:16;;;;;;;;;;;:22;;;:27;72732:443;;72780:11;72794:21;72805:9;72794:10;:21::i;:::-;72780:35;;72830:12;72851:1;72845:3;:7;;;;:::i;:::-;72830:22;;72867:12;72888:1;72882:3;:7;;;;:::i;:::-;72867:22;;72904:12;72932:4;72925;72919:3;:10;;;;:::i;:::-;:17;;;;:::i;:::-;72904:32;;72951:15;72969:28;72982:9;72993:3;72969:12;:28::i;:::-;72951:46;;73014:6;:15;;:24;73030:7;73014:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73053:11;;;;;;;;;;;:20;;:26;73074:4;73053:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73094:12;;;;;;;;;;;:21;;:27;73116:4;73094:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73136:12;;;;;;;;;;;:21;;:27;73158:4;73136:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72732:443;;;;;;73187:50;73197:17;73205:8;73197:7;:17::i;:::-;73216:10;73228:8;73187:9;:50::i;:::-;73273:15;73248:6;:16;73255:8;73248:16;;;;;;;;;;;:22;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72413:883;;;:::o;66798:71::-;;;;;;;;;;;;;:::o;47306:164::-;47403:4;47427:18;:25;47446:5;47427:25;;;;;;;;;;;;;;;:35;47453:8;47427:35;;;;;;;;;;;;;;;;;;;;;;;;;47420:42;;47306:164;;;;:::o;70318:199::-;70411:11;70419:2;70411:7;:11::i;:::-;70397:25;;:10;:25;;;70389:34;;;;;;70453:8;70434:6;:10;70441:2;70434:10;;;;;;;;;;;:16;;:27;;;;70491:18;70472:6;:10;70479:2;70472:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70318:199;;:::o;66720:71::-;;;;;;;;;;;;;:::o;66948:43::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;59056:244::-;58333:12;:10;:12::i;:::-;58322:23;;:7;:5;:7::i;:::-;:23;;;58314:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59165:1:::1;59145:22;;:8;:22;;;;59137:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;59255:8;59226:38;;59247:6;;;;;;;;;;;59226:38;;;;;;;;;;;;59284:8;59275:6;;:17;;;;;;;;;;;;;;;;;;59056:244:::0;:::o;20494:131::-;20561:4;20585:32;20590:3;:10;;20610:5;20602:14;;20585:4;:32::i;:::-;20578:39;;20494:131;;;;:::o;9324:185::-;9413:4;9437:64;9442:3;:10;;9462:3;9454:12;;9492:5;9476:23;;9468:32;;9437:4;:64::i;:::-;9430:71;;9324:185;;;;;:::o;22666:422::-;22726:4;22934:12;23045:7;23033:20;23025:28;;23079:1;23072:4;:8;23065:15;;;22666:422;;;:::o;9901:151::-;9985:4;10009:35;10019:3;:10;;10039:3;10031:12;;10009:9;:35::i;:::-;10002:42;;9901:151;;;;:::o;49887:127::-;49952:4;49976:30;49998:7;49976:12;:21;;:30;;;;:::i;:::-;49969:37;;49887:127;;;:::o;40614:98::-;40667:7;40694:10;40687:17;;40614:98;:::o;56062:183::-;56155:2;56128:15;:24;56144:7;56128:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;56211:7;56207:2;56173:46;;56182:23;56197:7;56182:14;:23::i;:::-;56173:46;;;;;;;;;;;;56062:183;;:::o;10140:123::-;10209:7;10236:19;10244:3;:10;;10236:7;:19::i;:::-;10229:26;;10140:123;;;:::o;50181:355::-;50274:4;50299:16;50307:7;50299;:16::i;:::-;50291:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;50375:13;50391:23;50406:7;50391:14;:23::i;:::-;50375:39;;50444:5;50433:16;;:7;:16;;;:51;;;;50477:7;50453:31;;:20;50465:7;50453:11;:20::i;:::-;:31;;;50433:51;:94;;;;50488:39;50512:5;50519:7;50488:23;:39::i;:::-;50433:94;50425:103;;;50181:355;;;;:::o;53317:628::-;53442:4;53415:31;;:23;53430:7;53415:14;:23::i;:::-;:31;;;53407:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;53543:1;53529:16;;:2;:16;;;;53521:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53599:39;53620:4;53626:2;53630:7;53599:20;:39::i;:::-;53703:29;53720:1;53724:7;53703:8;:29::i;:::-;53745:35;53772:7;53745:13;:19;53759:4;53745:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;53791:30;53813:7;53791:13;:17;53805:2;53791:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;53834:29;53851:7;53860:2;53834:12;:16;;:29;;;;;:::i;:::-;;53874:20;53886:7;53874:11;:20::i;:::-;53929:7;53925:2;53910:27;;53919:4;53910:27;;;;;;;;;;;;53317:628;;;:::o;21714:137::-;21785:7;21820:22;21824:3;:10;;21836:5;21820:3;:22::i;:::-;21812:31;;21805:38;;21714:137;;;;:::o;10602:236::-;10682:7;10691;10712:11;10725:13;10742:22;10746:3;:10;;10758:5;10742:3;:22::i;:::-;10711:53;;;;10791:3;10783:12;;10821:5;10813:14;;10775:55;;;;;;10602:236;;;;;:::o;54546:100::-;54630:8;54619;:19;;;;;;;;;;;;:::i;:::-;;54546:100;:::o;62142:98::-;62200:7;62231:1;62227;:5;;;;:::i;:::-;62220:12;;62142:98;;;;:::o;62880:::-;62938:7;62969:1;62965;:5;;;;:::i;:::-;62958:12;;62880:98;;;;:::o;50879:110::-;50955:26;50965:2;50969:7;50955:26;;;;;;;;;;;;:9;:26::i;:::-;50879:110;;:::o;74009:174::-;74068:7;74088:15;74106:23;74119:6;74127:1;74106:12;:23::i;:::-;74088:41;;74149:26;74162:7;74171:3;74149:12;:26::i;:::-;74142:33;;;74009:174;;;:::o;62523:98::-;62581:7;62612:1;62608;:5;;;;:::i;:::-;62601:12;;62523:98;;;;:::o;11888:213::-;11995:7;12046:44;12051:3;:10;;12071:3;12063:12;;12077;12046:4;:44::i;:::-;12038:53;;12015:78;;11888:213;;;;;:::o;21256:114::-;21316:7;21343:19;21351:3;:10;;21343:7;:19::i;:::-;21336:26;;21256:114;;;:::o;49302:272::-;49416:28;49426:4;49432:2;49436:7;49416:9;:28::i;:::-;49463:48;49486:4;49492:2;49496:7;49505:5;49463:22;:48::i;:::-;49455:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;49302:272;;;;:::o;284:723::-;340:13;570:1;561:5;:10;557:53;;;588:10;;;;;;;;;;;;;;;;;;;;;557:53;620:12;635:5;620:20;;651:14;676:78;691:1;683:4;:9;676:78;;709:8;;;;;:::i;:::-;;;;740:2;732:10;;;;;:::i;:::-;;;676:78;;;764:19;796:6;786:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;764:39;;814:154;830:1;821:5;:10;814:154;;858:1;848:11;;;;;:::i;:::-;;;925:2;917:5;:10;;;;:::i;:::-;904:2;:24;;;;:::i;:::-;891:39;;874:6;881;874:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;954:2;945:11;;;;;:::i;:::-;;;814:154;;;992:6;978:21;;;;;284:723;;;;:::o;13864:414::-;13927:4;13949:21;13959:3;13964:5;13949:9;:21::i;:::-;13944:327;;13987:3;:11;;14004:5;13987:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14170:3;:11;;:18;;;;14148:3;:12;;:19;14161:5;14148:19;;;;;;;;;;;:40;;;;14210:4;14203:11;;;;13944:327;14254:5;14247:12;;13864:414;;;;;:::o;3999:692::-;4075:4;4191:16;4210:3;:12;;:17;4223:3;4210:17;;;;;;;;;;;;4191:36;;4256:1;4244:8;:13;4240:444;;;4311:3;:12;;4329:38;;;;;;;;4346:3;4329:38;;;;4359:5;4329:38;;;4311:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4526:3;:12;;:19;;;;4506:3;:12;;:17;4519:3;4506:17;;;;;;;;;;;:39;;;;4567:4;4560:11;;;;;4240:444;4640:5;4604:3;:12;;4628:1;4617:8;:12;;;;:::i;:::-;4604:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;:41;;;;4667:5;4660:12;;;3999:692;;;;;;:::o;6499:125::-;6570:4;6615:1;6594:3;:12;;:17;6607:3;6594:17;;;;;;;;;;;;:22;;6587:29;;6499:125;;;;:::o;6719:110::-;6775:7;6802:3;:12;;:19;;;;6795:26;;6719:110;;;:::o;56858:93::-;;;;:::o;20801:137::-;20871:4;20895:35;20903:3;:10;;20923:5;20915:14;;20895:7;:35::i;:::-;20888:42;;20801:137;;;;:::o;43415:132::-;43475:6;:10;43482:2;43475:10;;;;;;;;;;;:16;;43468:23;;;43521:18;43502:6;:10;43509:2;43502:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43415:132;:::o;16752:204::-;16819:7;16868:5;16847:3;:11;;:18;;;;:26;16839:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;16930:3;:11;;16942:5;16930:18;;;;;;;;;;;;;;;;;;;;;;;;16923:25;;16752:204;;;;:::o;7184:279::-;7251:7;7260;7310:5;7288:3;:12;;:19;;;;:27;7280:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7367:22;7392:3;:12;;7405:5;7392:19;;;;;;;;;;;;;;;;;;;;;;;;;;7367:44;;7430:5;:10;;;7442:5;:12;;;7422:33;;;;;7184:279;;;;;:::o;51216:250::-;51312:18;51318:2;51322:7;51312:5;:18::i;:::-;51349:54;51380:1;51384:2;51388:7;51397:5;51349:22;:54::i;:::-;51341:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;51216:250;;;:::o;63279:98::-;63337:7;63368:1;63364;:5;;;;:::i;:::-;63357:12;;63279:98;;;;:::o;8681:319::-;8775:7;8795:16;8814:3;:12;;:17;8827:3;8814:17;;;;;;;;;;;;8795:36;;8862:1;8850:8;:13;;8865:12;8842:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;8932:3;:12;;8956:1;8945:8;:12;;;;:::i;:::-;8932:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;8925:40;;;8681:319;;;;;:::o;16299:109::-;16355:7;16382:3;:11;;:18;;;;16375:25;;16299:109;;;:::o;55211:843::-;55332:4;55358:15;:2;:13;;;:15::i;:::-;55354:693;;;55410:2;55394:36;;;55431:12;:10;:12::i;:::-;55445:4;55451:7;55460:5;55394:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55390:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55657:1;55640:6;:13;:18;55636:341;;;55683:60;;;;;;;;;;:::i;:::-;;;;;;;;55636:341;55927:6;55921:13;55912:6;55908:2;55904:15;55897:38;55390:602;55527:45;;;55517:55;;;:6;:55;;;;55510:62;;;;;55354:693;56031:4;56024:11;;55211:843;;;;;;;:::o;16084:129::-;16157:4;16204:1;16181:3;:12;;:19;16194:5;16181:19;;;;;;;;;;;;:24;;16174:31;;16084:129;;;;:::o;14454:1544::-;14520:4;14638:18;14659:3;:12;;:19;14672:5;14659:19;;;;;;;;;;;;14638:40;;14709:1;14695:10;:15;14691:1300;;15057:21;15094:1;15081:10;:14;;;;:::i;:::-;15057:38;;15110:17;15151:1;15130:3;:11;;:18;;;;:22;;;;:::i;:::-;15110:42;;15397:17;15417:3;:11;;15429:9;15417:22;;;;;;;;;;;;;;;;;;;;;;;;15397:42;;15563:9;15534:3;:11;;15546:13;15534:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;15682:1;15666:13;:17;;;;:::i;:::-;15640:3;:12;;:23;15653:9;15640:23;;;;;;;;;;;:43;;;;15792:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15887:3;:12;;:19;15900:5;15887:19;;;;;;;;;;;15880:26;;;15930:4;15923:11;;;;;;;;14691:1300;15974:5;15967:12;;;14454:1544;;;;;:::o;51802:404::-;51896:1;51882:16;;:2;:16;;;;51874:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;51955:16;51963:7;51955;:16::i;:::-;51954:17;51946:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;52017:45;52046:1;52050:2;52054:7;52017:20;:45::i;:::-;52075:30;52097:7;52075:13;:17;52089:2;52075:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;52118:29;52135:7;52144:2;52118:12;:16;;:29;;;;;:::i;:::-;;52190:7;52186:2;52165:33;;52182:1;52165:33;;;;;;;;;;;;51802:404;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:1:-;;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;;1074:6;1061:20;1052:29;;1090:32;1116:5;1090:32;:::i;:::-;1042:86;;;;:::o;1134:141::-;;1221:6;1215:13;1206:22;;1237:32;1263:5;1237:32;:::i;:::-;1196:79;;;;:::o;1294:271::-;;1398:3;1391:4;1383:6;1379:17;1375:27;1365:2;;1416:1;1413;1406:12;1365:2;1456:6;1443:20;1481:78;1555:3;1547:6;1540:4;1532:6;1528:17;1481:78;:::i;:::-;1472:87;;1355:210;;;;;:::o;1585:273::-;;1690:3;1683:4;1675:6;1671:17;1667:27;1657:2;;1708:1;1705;1698:12;1657:2;1748:6;1735:20;1773:79;1848:3;1840:6;1833:4;1825:6;1821:17;1773:79;:::i;:::-;1764:88;;1647:211;;;;;:::o;1864:139::-;;1948:6;1935:20;1926:29;;1964:33;1991:5;1964:33;:::i;:::-;1916:87;;;;:::o;2009:262::-;;2117:2;2105:9;2096:7;2092:23;2088:32;2085:2;;;2133:1;2130;2123:12;2085:2;2176:1;2201:53;2246:7;2237:6;2226:9;2222:22;2201:53;:::i;:::-;2191:63;;2147:117;2075:196;;;;:::o;2277:407::-;;;2402:2;2390:9;2381:7;2377:23;2373:32;2370:2;;;2418:1;2415;2408:12;2370:2;2461:1;2486:53;2531:7;2522:6;2511:9;2507:22;2486:53;:::i;:::-;2476:63;;2432:117;2588:2;2614:53;2659:7;2650:6;2639:9;2635:22;2614:53;:::i;:::-;2604:63;;2559:118;2360:324;;;;;:::o;2690:552::-;;;;2832:2;2820:9;2811:7;2807:23;2803:32;2800:2;;;2848:1;2845;2838:12;2800:2;2891:1;2916:53;2961:7;2952:6;2941:9;2937:22;2916:53;:::i;:::-;2906:63;;2862:117;3018:2;3044:53;3089:7;3080:6;3069:9;3065:22;3044:53;:::i;:::-;3034:63;;2989:118;3146:2;3172:53;3217:7;3208:6;3197:9;3193:22;3172:53;:::i;:::-;3162:63;;3117:118;2790:452;;;;;:::o;3248:809::-;;;;;3416:3;3404:9;3395:7;3391:23;3387:33;3384:2;;;3433:1;3430;3423:12;3384:2;3476:1;3501:53;3546:7;3537:6;3526:9;3522:22;3501:53;:::i;:::-;3491:63;;3447:117;3603:2;3629:53;3674:7;3665:6;3654:9;3650:22;3629:53;:::i;:::-;3619:63;;3574:118;3731:2;3757:53;3802:7;3793:6;3782:9;3778:22;3757:53;:::i;:::-;3747:63;;3702:118;3887:2;3876:9;3872:18;3859:32;3918:18;3910:6;3907:30;3904:2;;;3950:1;3947;3940:12;3904:2;3978:62;4032:7;4023:6;4012:9;4008:22;3978:62;:::i;:::-;3968:72;;3830:220;3374:683;;;;;;;:::o;4063:401::-;;;4185:2;4173:9;4164:7;4160:23;4156:32;4153:2;;;4201:1;4198;4191:12;4153:2;4244:1;4269:53;4314:7;4305:6;4294:9;4290:22;4269:53;:::i;:::-;4259:63;;4215:117;4371:2;4397:50;4439:7;4430:6;4419:9;4415:22;4397:50;:::i;:::-;4387:60;;4342:115;4143:321;;;;;:::o;4470:407::-;;;4595:2;4583:9;4574:7;4570:23;4566:32;4563:2;;;4611:1;4608;4601:12;4563:2;4654:1;4679:53;4724:7;4715:6;4704:9;4700:22;4679:53;:::i;:::-;4669:63;;4625:117;4781:2;4807:53;4852:7;4843:6;4832:9;4828:22;4807:53;:::i;:::-;4797:63;;4752:118;4553:324;;;;;:::o;4883:260::-;;4990:2;4978:9;4969:7;4965:23;4961:32;4958:2;;;5006:1;5003;4996:12;4958:2;5049:1;5074:52;5118:7;5109:6;5098:9;5094:22;5074:52;:::i;:::-;5064:62;;5020:116;4948:195;;;;:::o;5149:282::-;;5267:2;5255:9;5246:7;5242:23;5238:32;5235:2;;;5283:1;5280;5273:12;5235:2;5326:1;5351:63;5406:7;5397:6;5386:9;5382:22;5351:63;:::i;:::-;5341:73;;5297:127;5225:206;;;;:::o;5437:375::-;;5555:2;5543:9;5534:7;5530:23;5526:32;5523:2;;;5571:1;5568;5561:12;5523:2;5642:1;5631:9;5627:17;5614:31;5672:18;5664:6;5661:30;5658:2;;;5704:1;5701;5694:12;5658:2;5732:63;5787:7;5778:6;5767:9;5763:22;5732:63;:::i;:::-;5722:73;;5585:220;5513:299;;;;:::o;5818:262::-;;5926:2;5914:9;5905:7;5901:23;5897:32;5894:2;;;5942:1;5939;5932:12;5894:2;5985:1;6010:53;6055:7;6046:6;6035:9;6031:22;6010:53;:::i;:::-;6000:63;;5956:117;5884:196;;;;:::o;6086:407::-;;;6211:2;6199:9;6190:7;6186:23;6182:32;6179:2;;;6227:1;6224;6217:12;6179:2;6270:1;6295:53;6340:7;6331:6;6320:9;6316:22;6295:53;:::i;:::-;6285:63;;6241:117;6397:2;6423:53;6468:7;6459:6;6448:9;6444:22;6423:53;:::i;:::-;6413:63;;6368:118;6169:324;;;;;:::o;6499:179::-;;6589:46;6631:3;6623:6;6589:46;:::i;:::-;6667:4;6662:3;6658:14;6644:28;;6579:99;;;;:::o;6684:118::-;6771:24;6789:5;6771:24;:::i;:::-;6766:3;6759:37;6749:53;;:::o;6838:732::-;;6986:54;7034:5;6986:54;:::i;:::-;7056:86;7135:6;7130:3;7056:86;:::i;:::-;7049:93;;7166:56;7216:5;7166:56;:::i;:::-;7245:7;7276:1;7261:284;7286:6;7283:1;7280:13;7261:284;;;7362:6;7356:13;7389:63;7448:3;7433:13;7389:63;:::i;:::-;7382:70;;7475:60;7528:6;7475:60;:::i;:::-;7465:70;;7321:224;7308:1;7305;7301:9;7296:14;;7261:284;;;7265:14;7561:3;7554:10;;6962:608;;;;;;;:::o;7576:109::-;7657:21;7672:5;7657:21;:::i;:::-;7652:3;7645:34;7635:50;;:::o;7691:360::-;;7805:38;7837:5;7805:38;:::i;:::-;7859:70;7922:6;7917:3;7859:70;:::i;:::-;7852:77;;7938:52;7983:6;7978:3;7971:4;7964:5;7960:16;7938:52;:::i;:::-;8015:29;8037:6;8015:29;:::i;:::-;8010:3;8006:39;7999:46;;7781:270;;;;;:::o;8057:157::-;8157:50;8201:5;8157:50;:::i;:::-;8152:3;8145:63;8135:79;;:::o;8220:364::-;;8336:39;8369:5;8336:39;:::i;:::-;8391:71;8455:6;8450:3;8391:71;:::i;:::-;8384:78;;8471:52;8516:6;8511:3;8504:4;8497:5;8493:16;8471:52;:::i;:::-;8548:29;8570:6;8548:29;:::i;:::-;8543:3;8539:39;8532:46;;8312:272;;;;;:::o;8590:377::-;;8724:39;8757:5;8724:39;:::i;:::-;8779:89;8861:6;8856:3;8779:89;:::i;:::-;8772:96;;8877:52;8922:6;8917:3;8910:4;8903:5;8899:16;8877:52;:::i;:::-;8954:6;8949:3;8945:16;8938:23;;8700:267;;;;;:::o;8973:366::-;;9136:67;9200:2;9195:3;9136:67;:::i;:::-;9129:74;;9212:93;9301:3;9212:93;:::i;:::-;9330:2;9325:3;9321:12;9314:19;;9119:220;;;:::o;9345:366::-;;9508:67;9572:2;9567:3;9508:67;:::i;:::-;9501:74;;9584:93;9673:3;9584:93;:::i;:::-;9702:2;9697:3;9693:12;9686:19;;9491:220;;;:::o;9717:366::-;;9880:67;9944:2;9939:3;9880:67;:::i;:::-;9873:74;;9956:93;10045:3;9956:93;:::i;:::-;10074:2;10069:3;10065:12;10058:19;;9863:220;;;:::o;10089:366::-;;10252:67;10316:2;10311:3;10252:67;:::i;:::-;10245:74;;10328:93;10417:3;10328:93;:::i;:::-;10446:2;10441:3;10437:12;10430:19;;10235:220;;;:::o;10461:366::-;;10624:67;10688:2;10683:3;10624:67;:::i;:::-;10617:74;;10700:93;10789:3;10700:93;:::i;:::-;10818:2;10813:3;10809:12;10802:19;;10607:220;;;:::o;10833:366::-;;10996:67;11060:2;11055:3;10996:67;:::i;:::-;10989:74;;11072:93;11161:3;11072:93;:::i;:::-;11190:2;11185:3;11181:12;11174:19;;10979:220;;;:::o;11205:366::-;;11368:67;11432:2;11427:3;11368:67;:::i;:::-;11361:74;;11444:93;11533:3;11444:93;:::i;:::-;11562:2;11557:3;11553:12;11546:19;;11351:220;;;:::o;11577:366::-;;11740:67;11804:2;11799:3;11740:67;:::i;:::-;11733:74;;11816:93;11905:3;11816:93;:::i;:::-;11934:2;11929:3;11925:12;11918:19;;11723:220;;;:::o;11949:366::-;;12112:67;12176:2;12171:3;12112:67;:::i;:::-;12105:74;;12188:93;12277:3;12188:93;:::i;:::-;12306:2;12301:3;12297:12;12290:19;;12095:220;;;:::o;12321:366::-;;12484:67;12548:2;12543:3;12484:67;:::i;:::-;12477:74;;12560:93;12649:3;12560:93;:::i;:::-;12678:2;12673:3;12669:12;12662:19;;12467:220;;;:::o;12693:366::-;;12856:67;12920:2;12915:3;12856:67;:::i;:::-;12849:74;;12932:93;13021:3;12932:93;:::i;:::-;13050:2;13045:3;13041:12;13034:19;;12839:220;;;:::o;13065:366::-;;13228:67;13292:2;13287:3;13228:67;:::i;:::-;13221:74;;13304:93;13393:3;13304:93;:::i;:::-;13422:2;13417:3;13413:12;13406:19;;13211:220;;;:::o;13437:366::-;;13600:67;13664:2;13659:3;13600:67;:::i;:::-;13593:74;;13676:93;13765:3;13676:93;:::i;:::-;13794:2;13789:3;13785:12;13778:19;;13583:220;;;:::o;13809:366::-;;13972:67;14036:2;14031:3;13972:67;:::i;:::-;13965:74;;14048:93;14137:3;14048:93;:::i;:::-;14166:2;14161:3;14157:12;14150:19;;13955:220;;;:::o;14181:366::-;;14344:67;14408:2;14403:3;14344:67;:::i;:::-;14337:74;;14420:93;14509:3;14420:93;:::i;:::-;14538:2;14533:3;14529:12;14522:19;;14327:220;;;:::o;14553:366::-;;14716:67;14780:2;14775:3;14716:67;:::i;:::-;14709:74;;14792:93;14881:3;14792:93;:::i;:::-;14910:2;14905:3;14901:12;14894:19;;14699:220;;;:::o;14925:366::-;;15088:67;15152:2;15147:3;15088:67;:::i;:::-;15081:74;;15164:93;15253:3;15164:93;:::i;:::-;15282:2;15277:3;15273:12;15266:19;;15071:220;;;:::o;15297:366::-;;15460:67;15524:2;15519:3;15460:67;:::i;:::-;15453:74;;15536:93;15625:3;15536:93;:::i;:::-;15654:2;15649:3;15645:12;15638:19;;15443:220;;;:::o;15669:366::-;;15832:67;15896:2;15891:3;15832:67;:::i;:::-;15825:74;;15908:93;15997:3;15908:93;:::i;:::-;16026:2;16021:3;16017:12;16010:19;;15815:220;;;:::o;16041:366::-;;16204:67;16268:2;16263:3;16204:67;:::i;:::-;16197:74;;16280:93;16369:3;16280:93;:::i;:::-;16398:2;16393:3;16389:12;16382:19;;16187:220;;;:::o;16413:366::-;;16576:67;16640:2;16635:3;16576:67;:::i;:::-;16569:74;;16652:93;16741:3;16652:93;:::i;:::-;16770:2;16765:3;16761:12;16754:19;;16559:220;;;:::o;16785:366::-;;16948:67;17012:2;17007:3;16948:67;:::i;:::-;16941:74;;17024:93;17113:3;17024:93;:::i;:::-;17142:2;17137:3;17133:12;17126:19;;16931:220;;;:::o;17157:366::-;;17320:67;17384:2;17379:3;17320:67;:::i;:::-;17313:74;;17396:93;17485:3;17396:93;:::i;:::-;17514:2;17509:3;17505:12;17498:19;;17303:220;;;:::o;17529:365::-;;17692:66;17756:1;17751:3;17692:66;:::i;:::-;17685:73;;17767:93;17856:3;17767:93;:::i;:::-;17885:2;17880:3;17876:12;17869:19;;17675:219;;;:::o;17900:366::-;;18063:67;18127:2;18122:3;18063:67;:::i;:::-;18056:74;;18139:93;18228:3;18139:93;:::i;:::-;18257:2;18252:3;18248:12;18241:19;;18046:220;;;:::o;18272:366::-;;18435:67;18499:2;18494:3;18435:67;:::i;:::-;18428:74;;18511:93;18600:3;18511:93;:::i;:::-;18629:2;18624:3;18620:12;18613:19;;18418:220;;;:::o;18644:366::-;;18807:67;18871:2;18866:3;18807:67;:::i;:::-;18800:74;;18883:93;18972:3;18883:93;:::i;:::-;19001:2;18996:3;18992:12;18985:19;;18790:220;;;:::o;19016:366::-;;19179:67;19243:2;19238:3;19179:67;:::i;:::-;19172:74;;19255:93;19344:3;19255:93;:::i;:::-;19373:2;19368:3;19364:12;19357:19;;19162:220;;;:::o;19388:366::-;;19551:67;19615:2;19610:3;19551:67;:::i;:::-;19544:74;;19627:93;19716:3;19627:93;:::i;:::-;19745:2;19740:3;19736:12;19729:19;;19534:220;;;:::o;19760:108::-;19837:24;19855:5;19837:24;:::i;:::-;19832:3;19825:37;19815:53;;:::o;19874:118::-;19961:24;19979:5;19961:24;:::i;:::-;19956:3;19949:37;19939:53;;:::o;19998:435::-;;20200:95;20291:3;20282:6;20200:95;:::i;:::-;20193:102;;20312:95;20403:3;20394:6;20312:95;:::i;:::-;20305:102;;20424:3;20417:10;;20182:251;;;;;:::o;20439:222::-;;20570:2;20559:9;20555:18;20547:26;;20583:71;20651:1;20640:9;20636:17;20627:6;20583:71;:::i;:::-;20537:124;;;;:::o;20667:640::-;;20900:3;20889:9;20885:19;20877:27;;20914:71;20982:1;20971:9;20967:17;20958:6;20914:71;:::i;:::-;20995:72;21063:2;21052:9;21048:18;21039:6;20995:72;:::i;:::-;21077;21145:2;21134:9;21130:18;21121:6;21077:72;:::i;:::-;21196:9;21190:4;21186:20;21181:2;21170:9;21166:18;21159:48;21224:76;21295:4;21286:6;21224:76;:::i;:::-;21216:84;;20867:440;;;;;;;:::o;21313:332::-;;21472:2;21461:9;21457:18;21449:26;;21485:71;21553:1;21542:9;21538:17;21529:6;21485:71;:::i;:::-;21566:72;21634:2;21623:9;21619:18;21610:6;21566:72;:::i;:::-;21439:206;;;;;:::o;21651:373::-;;21832:2;21821:9;21817:18;21809:26;;21881:9;21875:4;21871:20;21867:1;21856:9;21852:17;21845:47;21909:108;22012:4;22003:6;21909:108;:::i;:::-;21901:116;;21799:225;;;;:::o;22030:210::-;;22155:2;22144:9;22140:18;22132:26;;22168:65;22230:1;22219:9;22215:17;22206:6;22168:65;:::i;:::-;22122:118;;;;:::o;22246:313::-;;22397:2;22386:9;22382:18;22374:26;;22446:9;22440:4;22436:20;22432:1;22421:9;22417:17;22410:47;22474:78;22547:4;22538:6;22474:78;:::i;:::-;22466:86;;22364:195;;;;:::o;22565:419::-;;22769:2;22758:9;22754:18;22746:26;;22818:9;22812:4;22808:20;22804:1;22793:9;22789:17;22782:47;22846:131;22972:4;22846:131;:::i;:::-;22838:139;;22736:248;;;:::o;22990:419::-;;23194:2;23183:9;23179:18;23171:26;;23243:9;23237:4;23233:20;23229:1;23218:9;23214:17;23207:47;23271:131;23397:4;23271:131;:::i;:::-;23263:139;;23161:248;;;:::o;23415:419::-;;23619:2;23608:9;23604:18;23596:26;;23668:9;23662:4;23658:20;23654:1;23643:9;23639:17;23632:47;23696:131;23822:4;23696:131;:::i;:::-;23688:139;;23586:248;;;:::o;23840:419::-;;24044:2;24033:9;24029:18;24021:26;;24093:9;24087:4;24083:20;24079:1;24068:9;24064:17;24057:47;24121:131;24247:4;24121:131;:::i;:::-;24113:139;;24011:248;;;:::o;24265:419::-;;24469:2;24458:9;24454:18;24446:26;;24518:9;24512:4;24508:20;24504:1;24493:9;24489:17;24482:47;24546:131;24672:4;24546:131;:::i;:::-;24538:139;;24436:248;;;:::o;24690:419::-;;24894:2;24883:9;24879:18;24871:26;;24943:9;24937:4;24933:20;24929:1;24918:9;24914:17;24907:47;24971:131;25097:4;24971:131;:::i;:::-;24963:139;;24861:248;;;:::o;25115:419::-;;25319:2;25308:9;25304:18;25296:26;;25368:9;25362:4;25358:20;25354:1;25343:9;25339:17;25332:47;25396:131;25522:4;25396:131;:::i;:::-;25388:139;;25286:248;;;:::o;25540:419::-;;25744:2;25733:9;25729:18;25721:26;;25793:9;25787:4;25783:20;25779:1;25768:9;25764:17;25757:47;25821:131;25947:4;25821:131;:::i;:::-;25813:139;;25711:248;;;:::o;25965:419::-;;26169:2;26158:9;26154:18;26146:26;;26218:9;26212:4;26208:20;26204:1;26193:9;26189:17;26182:47;26246:131;26372:4;26246:131;:::i;:::-;26238:139;;26136:248;;;:::o;26390:419::-;;26594:2;26583:9;26579:18;26571:26;;26643:9;26637:4;26633:20;26629:1;26618:9;26614:17;26607:47;26671:131;26797:4;26671:131;:::i;:::-;26663:139;;26561:248;;;:::o;26815:419::-;;27019:2;27008:9;27004:18;26996:26;;27068:9;27062:4;27058:20;27054:1;27043:9;27039:17;27032:47;27096:131;27222:4;27096:131;:::i;:::-;27088:139;;26986:248;;;:::o;27240:419::-;;27444:2;27433:9;27429:18;27421:26;;27493:9;27487:4;27483:20;27479:1;27468:9;27464:17;27457:47;27521:131;27647:4;27521:131;:::i;:::-;27513:139;;27411:248;;;:::o;27665:419::-;;27869:2;27858:9;27854:18;27846:26;;27918:9;27912:4;27908:20;27904:1;27893:9;27889:17;27882:47;27946:131;28072:4;27946:131;:::i;:::-;27938:139;;27836:248;;;:::o;28090:419::-;;28294:2;28283:9;28279:18;28271:26;;28343:9;28337:4;28333:20;28329:1;28318:9;28314:17;28307:47;28371:131;28497:4;28371:131;:::i;:::-;28363:139;;28261:248;;;:::o;28515:419::-;;28719:2;28708:9;28704:18;28696:26;;28768:9;28762:4;28758:20;28754:1;28743:9;28739:17;28732:47;28796:131;28922:4;28796:131;:::i;:::-;28788:139;;28686:248;;;:::o;28940:419::-;;29144:2;29133:9;29129:18;29121:26;;29193:9;29187:4;29183:20;29179:1;29168:9;29164:17;29157:47;29221:131;29347:4;29221:131;:::i;:::-;29213:139;;29111:248;;;:::o;29365:419::-;;29569:2;29558:9;29554:18;29546:26;;29618:9;29612:4;29608:20;29604:1;29593:9;29589:17;29582:47;29646:131;29772:4;29646:131;:::i;:::-;29638:139;;29536:248;;;:::o;29790:419::-;;29994:2;29983:9;29979:18;29971:26;;30043:9;30037:4;30033:20;30029:1;30018:9;30014:17;30007:47;30071:131;30197:4;30071:131;:::i;:::-;30063:139;;29961:248;;;:::o;30215:419::-;;30419:2;30408:9;30404:18;30396:26;;30468:9;30462:4;30458:20;30454:1;30443:9;30439:17;30432:47;30496:131;30622:4;30496:131;:::i;:::-;30488:139;;30386:248;;;:::o;30640:419::-;;30844:2;30833:9;30829:18;30821:26;;30893:9;30887:4;30883:20;30879:1;30868:9;30864:17;30857:47;30921:131;31047:4;30921:131;:::i;:::-;30913:139;;30811:248;;;:::o;31065:419::-;;31269:2;31258:9;31254:18;31246:26;;31318:9;31312:4;31308:20;31304:1;31293:9;31289:17;31282:47;31346:131;31472:4;31346:131;:::i;:::-;31338:139;;31236:248;;;:::o;31490:419::-;;31694:2;31683:9;31679:18;31671:26;;31743:9;31737:4;31733:20;31729:1;31718:9;31714:17;31707:47;31771:131;31897:4;31771:131;:::i;:::-;31763:139;;31661:248;;;:::o;31915:419::-;;32119:2;32108:9;32104:18;32096:26;;32168:9;32162:4;32158:20;32154:1;32143:9;32139:17;32132:47;32196:131;32322:4;32196:131;:::i;:::-;32188:139;;32086:248;;;:::o;32340:419::-;;32544:2;32533:9;32529:18;32521:26;;32593:9;32587:4;32583:20;32579:1;32568:9;32564:17;32557:47;32621:131;32747:4;32621:131;:::i;:::-;32613:139;;32511:248;;;:::o;32765:419::-;;32969:2;32958:9;32954:18;32946:26;;33018:9;33012:4;33008:20;33004:1;32993:9;32989:17;32982:47;33046:131;33172:4;33046:131;:::i;:::-;33038:139;;32936:248;;;:::o;33190:419::-;;33394:2;33383:9;33379:18;33371:26;;33443:9;33437:4;33433:20;33429:1;33418:9;33414:17;33407:47;33471:131;33597:4;33471:131;:::i;:::-;33463:139;;33361:248;;;:::o;33615:419::-;;33819:2;33808:9;33804:18;33796:26;;33868:9;33862:4;33858:20;33854:1;33843:9;33839:17;33832:47;33896:131;34022:4;33896:131;:::i;:::-;33888:139;;33786:248;;;:::o;34040:419::-;;34244:2;34233:9;34229:18;34221:26;;34293:9;34287:4;34283:20;34279:1;34268:9;34264:17;34257:47;34321:131;34447:4;34321:131;:::i;:::-;34313:139;;34211:248;;;:::o;34465:419::-;;34669:2;34658:9;34654:18;34646:26;;34718:9;34712:4;34708:20;34704:1;34693:9;34689:17;34682:47;34746:131;34872:4;34746:131;:::i;:::-;34738:139;;34636:248;;;:::o;34890:222::-;;35021:2;35010:9;35006:18;34998:26;;35034:71;35102:1;35091:9;35087:17;35078:6;35034:71;:::i;:::-;34988:124;;;;:::o;35118:468::-;;35318:2;35307:9;35303:18;35295:26;;35331:71;35399:1;35388:9;35384:17;35375:6;35331:71;:::i;:::-;35412:72;35480:2;35469:9;35465:18;35456:6;35412:72;:::i;:::-;35494:85;35575:2;35564:9;35560:18;35551:6;35494:85;:::i;:::-;35285:301;;;;;;:::o;35592:129::-;;35653:20;;:::i;:::-;35643:30;;35682:33;35710:4;35702:6;35682:33;:::i;:::-;35633:88;;;:::o;35727:75::-;;35793:2;35787:9;35777:19;;35767:35;:::o;35808:307::-;;35959:18;35951:6;35948:30;35945:2;;;35981:18;;:::i;:::-;35945:2;36019:29;36041:6;36019:29;:::i;:::-;36011:37;;36103:4;36097;36093:15;36085:23;;35874:241;;;:::o;36121:308::-;;36273:18;36265:6;36262:30;36259:2;;;36295:18;;:::i;:::-;36259:2;36333:29;36355:6;36333:29;:::i;:::-;36325:37;;36417:4;36411;36407:15;36399:23;;36188:241;;;:::o;36435:132::-;;36525:3;36517:11;;36555:4;36550:3;36546:14;36538:22;;36507:60;;;:::o;36573:114::-;;36674:5;36668:12;36658:22;;36647:40;;;:::o;36693:98::-;;36778:5;36772:12;36762:22;;36751:40;;;:::o;36797:99::-;;36883:5;36877:12;36867:22;;36856:40;;;:::o;36902:113::-;;37004:4;36999:3;36995:14;36987:22;;36977:38;;;:::o;37021:184::-;;37154:6;37149:3;37142:19;37194:4;37189:3;37185:14;37170:29;;37132:73;;;;:::o;37211:168::-;;37328:6;37323:3;37316:19;37368:4;37363:3;37359:14;37344:29;;37306:73;;;;:::o;37385:169::-;;37503:6;37498:3;37491:19;37543:4;37538:3;37534:14;37519:29;;37481:73;;;;:::o;37560:148::-;;37699:3;37684:18;;37674:34;;;;:::o;37714:305::-;;37773:20;37791:1;37773:20;:::i;:::-;37768:25;;37807:20;37825:1;37807:20;:::i;:::-;37802:25;;37961:1;37893:66;37889:74;37886:1;37883:81;37880:2;;;37967:18;;:::i;:::-;37880:2;38011:1;38008;38004:9;37997:16;;37758:261;;;;:::o;38025:185::-;;38082:20;38100:1;38082:20;:::i;:::-;38077:25;;38116:20;38134:1;38116:20;:::i;:::-;38111:25;;38155:1;38145:2;;38160:18;;:::i;:::-;38145:2;38202:1;38199;38195:9;38190:14;;38067:143;;;;:::o;38216:348::-;;38279:20;38297:1;38279:20;:::i;:::-;38274:25;;38313:20;38331:1;38313:20;:::i;:::-;38308:25;;38501:1;38433:66;38429:74;38426:1;38423:81;38418:1;38411:9;38404:17;38400:105;38397:2;;;38508:18;;:::i;:::-;38397:2;38556:1;38553;38549:9;38538:20;;38264:300;;;;:::o;38570:191::-;;38630:20;38648:1;38630:20;:::i;:::-;38625:25;;38664:20;38682:1;38664:20;:::i;:::-;38659:25;;38703:1;38700;38697:8;38694:2;;;38708:18;;:::i;:::-;38694:2;38753:1;38750;38746:9;38738:17;;38615:146;;;;:::o;38767:96::-;;38833:24;38851:5;38833:24;:::i;:::-;38822:35;;38812:51;;;:::o;38869:90::-;;38946:5;38939:13;38932:21;38921:32;;38911:48;;;:::o;38965:149::-;;39041:66;39034:5;39030:78;39019:89;;39009:105;;;:::o;39120:141::-;;39201:5;39190:16;;39207:48;39249:5;39207:48;:::i;:::-;39180:81;;;:::o;39267:126::-;;39344:42;39337:5;39333:54;39322:65;;39312:81;;;:::o;39399:77::-;;39465:5;39454:16;;39444:32;;;:::o;39482:141::-;;39578:39;39611:5;39578:39;:::i;:::-;39565:52;;39555:68;;;:::o;39629:154::-;39713:6;39708:3;39703;39690:30;39775:1;39766:6;39761:3;39757:16;39750:27;39680:103;;;:::o;39789:307::-;39857:1;39867:113;39881:6;39878:1;39875:13;39867:113;;;39966:1;39961:3;39957:11;39951:18;39947:1;39942:3;39938:11;39931:39;39903:2;39900:1;39896:10;39891:15;;39867:113;;;39998:6;39995:1;39992:13;39989:2;;;40078:1;40069:6;40064:3;40060:16;40053:27;39989:2;39838:258;;;;:::o;40102:320::-;;40183:1;40177:4;40173:12;40163:22;;40230:1;40224:4;40220:12;40251:18;40241:2;;40307:4;40299:6;40295:17;40285:27;;40241:2;40369;40361:6;40358:14;40338:18;40335:38;40332:2;;;40388:18;;:::i;:::-;40332:2;40153:269;;;;:::o;40428:281::-;40511:27;40533:4;40511:27;:::i;:::-;40503:6;40499:40;40641:6;40629:10;40626:22;40605:18;40593:10;40590:34;40587:62;40584:2;;;40652:18;;:::i;:::-;40584:2;40692:10;40688:2;40681:22;40471:238;;;:::o;40715:233::-;;40777:24;40795:5;40777:24;:::i;:::-;40768:33;;40823:66;40816:5;40813:77;40810:2;;;40893:18;;:::i;:::-;40810:2;40940:1;40933:5;40929:13;40922:20;;40758:190;;;:::o;40954:176::-;;41003:20;41021:1;41003:20;:::i;:::-;40998:25;;41037:20;41055:1;41037:20;:::i;:::-;41032:25;;41076:1;41066:2;;41081:18;;:::i;:::-;41066:2;41122:1;41119;41115:9;41110:14;;40988:142;;;;:::o;41136:180::-;41184:77;41181:1;41174:88;41281:4;41278:1;41271:15;41305:4;41302:1;41295:15;41322:180;41370:77;41367:1;41360:88;41467:4;41464:1;41457:15;41491:4;41488:1;41481:15;41508:180;41556:77;41553:1;41546:88;41653:4;41650:1;41643:15;41677:4;41674:1;41667:15;41694:180;41742:77;41739:1;41732:88;41839:4;41836:1;41829:15;41863:4;41860:1;41853:15;41880:180;41928:77;41925:1;41918:88;42025:4;42022:1;42015:15;42049:4;42046:1;42039:15;42066:102;;42158:2;42154:7;42149:2;42142:5;42138:14;42134:28;42124:38;;42114:54;;;:::o;42174:226::-;42314:34;42310:1;42302:6;42298:14;42291:58;42383:9;42378:2;42370:6;42366:15;42359:34;42280:120;:::o;42406:221::-;42546:34;42542:1;42534:6;42530:14;42523:58;42615:4;42610:2;42602:6;42598:15;42591:29;42512:115;:::o;42633:161::-;42773:13;42769:1;42761:6;42757:14;42750:37;42739:55;:::o;42800:221::-;42940:34;42936:1;42928:6;42924:14;42917:58;43009:4;43004:2;42996:6;42992:15;42985:29;42906:115;:::o;43027:237::-;43167:34;43163:1;43155:6;43151:14;43144:58;43236:20;43231:2;43223:6;43219:15;43212:45;43133:131;:::o;43270:225::-;43410:34;43406:1;43398:6;43394:14;43387:58;43479:8;43474:2;43466:6;43462:15;43455:33;43376:119;:::o;43501:178::-;43641:30;43637:1;43629:6;43625:14;43618:54;43607:72;:::o;43685:223::-;43825:34;43821:1;43813:6;43809:14;43802:58;43894:6;43889:2;43881:6;43877:15;43870:31;43791:117;:::o;43914:175::-;44054:27;44050:1;44042:6;44038:14;44031:51;44020:69;:::o;44095:172::-;44235:24;44231:1;44223:6;44219:14;44212:48;44201:66;:::o;44273:169::-;44413:21;44409:1;44401:6;44397:14;44390:45;44379:63;:::o;44448:231::-;44588:34;44584:1;44576:6;44572:14;44565:58;44657:14;44652:2;44644:6;44640:15;44633:39;44554:125;:::o;44685:243::-;44825:34;44821:1;44813:6;44809:14;44802:58;44894:26;44889:2;44881:6;44877:15;44870:51;44791:137;:::o;44934:229::-;45074:34;45070:1;45062:6;45058:14;45051:58;45143:12;45138:2;45130:6;45126:15;45119:37;45040:123;:::o;45169:221::-;45309:34;45305:1;45297:6;45293:14;45286:58;45378:4;45373:2;45365:6;45361:15;45354:29;45275:115;:::o;45396:182::-;45536:34;45532:1;45524:6;45520:14;45513:58;45502:76;:::o;45584:231::-;45724:34;45720:1;45712:6;45708:14;45701:58;45793:14;45788:2;45780:6;45776:15;45769:39;45690:125;:::o;45821:182::-;45961:34;45957:1;45949:6;45945:14;45938:58;45927:76;:::o;46009:221::-;46149:34;46145:1;46137:6;46133:14;46126:58;46218:4;46213:2;46205:6;46201:15;46194:29;46115:115;:::o;46236:228::-;46376:34;46372:1;46364:6;46360:14;46353:58;46445:11;46440:2;46432:6;46428:15;46421:36;46342:122;:::o;46470:234::-;46610:34;46606:1;46598:6;46594:14;46587:58;46679:17;46674:2;46666:6;46662:15;46655:42;46576:128;:::o;46710:177::-;46850:29;46846:1;46838:6;46834:14;46827:53;46816:71;:::o;46893:233::-;47033:34;47029:1;47021:6;47017:14;47010:58;47102:16;47097:2;47089:6;47085:15;47078:41;46999:127;:::o;47132:157::-;47272:9;47268:1;47260:6;47256:14;47249:33;47238:51;:::o;47295:220::-;47435:34;47431:1;47423:6;47419:14;47412:58;47504:3;47499:2;47491:6;47487:15;47480:28;47401:114;:::o;47521:172::-;47661:24;47657:1;47649:6;47645:14;47638:48;47627:66;:::o;47699:236::-;47839:34;47835:1;47827:6;47823:14;47816:58;47908:19;47903:2;47895:6;47891:15;47884:44;47805:130;:::o;47941:231::-;48081:34;48077:1;48069:6;48065:14;48058:58;48150:14;48145:2;48137:6;48133:15;48126:39;48047:125;:::o;48178:169::-;48318:21;48314:1;48306:6;48302:14;48295:45;48284:63;:::o;48353:120::-;48441:1;48434:5;48431:12;48421:2;;48447:18;;:::i;:::-;48421:2;48411:62;:::o;48479:122::-;48552:24;48570:5;48552:24;:::i;:::-;48545:5;48542:35;48532:2;;48591:1;48588;48581:12;48532:2;48522:79;:::o;48607:116::-;48677:21;48692:5;48677:21;:::i;:::-;48670:5;48667:32;48657:2;;48713:1;48710;48703:12;48657:2;48647:76;:::o;48729:120::-;48801:23;48818:5;48801:23;:::i;:::-;48794:5;48791:34;48781:2;;48839:1;48836;48829:12;48781:2;48771:78;:::o;48855:122::-;48928:24;48946:5;48928:24;:::i;:::-;48921:5;48918:35;48908:2;;48967:1;48964;48957:12;48908:2;48898:79;:::o

ipfs://45f0d9859227ad7aab242f6f692a98a7ceb5d23a700d8c0eef3b0109f111ff49