Contract 0xf3c1e16720502aa49570765883bd5e87d328f481

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @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 NftSoccerGames is ERC721, Ownable {
    using SafeMath for uint256;
    uint public constant MAX_NFTS = 11000;
    bool public isActive = false;
    bool public isMarketplaceActive = false;
    address public feeAddress1 = 0x8a861502644d55cD787B34FC17BdE65cE6B97476;
    address public feeAddress2 = 0x6aDd12F9e62cAb0ee3cc95d8220695640Ae3f56b;
    address payable feeReceiver2;
    address payable feeReceiver3;

    mapping(uint256 => address) public OriginalOwners;

    string public METADATA_PROVENANCE_HASH = "";

    mapping(address => uint) public TeamMints;

    constructor() ERC721("NftSoccerGames","NftSoccerGames")  {
        setBaseURI("https://nftsoccergames.com/api/nfts/detail/");
        feeReceiver = payable(feeAddress1);
        feeReceiver2 = payable(feeAddress2);

        TeamMints[feeAddress1] = 100;
        TeamMints[feeAddress2] = 50;

    }

    function mintForTeam(uint count) public
    {
        require(msg.sender == feeAddress1 || msg.sender == feeAddress2, "Only for the team");
        require(count <= TeamMints[msg.sender], "Already minted all team mints");

        TeamMints[msg.sender] -= count;
        for(uint i = 0; i < count; i++)
        {
            uint mintIndex = totalSupply() + 1;
            _safeMint(msg.sender, mintIndex);
        }
    }

    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 getNfts(uint256 count) public payable {
        require(isActive, "Sales is not started yet");
        require(totalSupply() < MAX_NFTS, "Sale has already ended");
        require(count > 0 && count <= 11, "You can mint minimum 1 and maximum of 11 nft");
        require(totalSupply().add(count) <= MAX_NFTS, "Exceeds MAX_NFTS");
        require(msg.value >= calculatePrice().mul(count), "AVAX value sent is below the price");

        for (uint i = 0; i < count; i++) {
            uint mintIndex = totalSupply() + 1;
            _safeMint(msg.sender, mintIndex);
            OriginalOwners[mintIndex] = msg.sender;
        }
    }

    function calculatePrice() public view returns (uint256) {
        require(isActive == true, "Sale hasn't started");
        require(totalSupply() < MAX_NFTS, "Sale has already ended");

        uint currentSupply = totalSupply();

        if (currentSupply >= 11000){
            return 100000000000000000000;
        }
        else if (currentSupply >= 10999){
            return 50000000000000000000;
        }
        else if (currentSupply >= 10990){
            return 30000000000000000000;
        }
        else if (currentSupply >= 10980){
            return 25000000000000000000;
        }
        else if (currentSupply >= 10970){
            return 20000000000000000000;
        }
        else if (currentSupply >= 10960){
            return 15000000000000000000;
        }
        else if (currentSupply >= 10950){
            return 10000000000000000000;
        }
        else if (currentSupply >= 10900){
            return 6000000000000000000;
        }
        else if (currentSupply >= 10000){
            return 5000000000000000000;
        }
        else if (currentSupply >= 8000){
            return 4000000000000000000;
        }
        else if (currentSupply >= 6000){
            return 3000000000000000000;
        }
        else if (currentSupply >= 4000){
            return 2500000000000000000;
        }
        else if (currentSupply >= 3500){
            return 2000000000000000000;
        }
        else if (currentSupply >= 3000){
            return 1750000000000000000;
        }
        else if (currentSupply >= 2500){
            return 1500000000000000000;
        }
        else if (currentSupply >= 2000){
            return 1250000000000000000;
        }
        else if (currentSupply >= 1750){
            return 1000000000000000000;
        }
        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 >= 250){
            return 300000000000000000;
        }
        else {
            return 200000000000000000;
        }
    }

    function setProvenanceHash(string memory _hash) public onlyOwner {
        METADATA_PROVENANCE_HASH = _hash;
    }

    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }

    function getOriginalOwnerOf(uint id) public view returns (address owner) {
        return OriginalOwners[id];
    }

    function startSales() public onlyOwner {
        isActive = true;
    }

    function pauseSales() public onlyOwner {
        isActive = false;
    }

    function startMarketplaceSales() public onlyOwner {
        isMarketplaceActive = true;
    }

    function pauseMarketplaceSales() public onlyOwner {
        isMarketplaceActive = false;
    }

    function putOnMarketplace(uint256 id, uint256 setPrice) public {
        require(isMarketplaceActive, "Marketplace sales is not started yet");
        require(msg.sender == ownerOf(id));

        Bazaar[id].price = setPrice;
        Bazaar[id].state = TokenState.ForSale;

        emit MarketplaceSetPrice(id, setPrice);
    }

    function removeFromMarketplace(uint256 id) public {
        require(isMarketplaceActive, "Marketplace sales is not started yet");
        require(msg.sender == ownerOf(id));

        delete Bazaar[id].price;
        Bazaar[id].state = TokenState.Neutral;

        emit MarketplaceRemove(id);
    }

    function buyFromMarketplace(uint256 _tokenId) public payable {
        require(isMarketplaceActive, "Marketplace sales is not started yet");
        require(msg.value >= Bazaar[_tokenId].price, "Price issue");
        require(TokenState.ForSale == Bazaar[_tokenId].state, "No Sale");

        address tokenOwner = ownerOf(_tokenId);
        address originalTokenOwner = getOriginalOwnerOf(_tokenId);
        address payable seller = payable(address(tokenOwner));
        address payable originalOwner = payable(address(originalTokenOwner));

        if (Bazaar[_tokenId].price >= 0) {
            uint256 fee = serviceFee(msg.value);
            uint256 withFee = SafeMath.sub(msg.value, fee);
            uint256 originalOwnerFee = withFee * 2 / 100;

            seller.transfer(withFee - originalOwnerFee);
            originalOwner.transfer(originalOwnerFee);
        }

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

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

        return SafeMath.div(toOwner, 100);
    }

    function withdraw() public onlyOwner {
        uint256 freeBalance = address(this).balance;
        uint256 balance1 = freeBalance / 2;
        uint256 balance2 = freeBalance - balance1;

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

    function withdrawTokens(address tokenAddress) public onlyOwner
    {
        IERC20 token = IERC20(tokenAddress);

        uint256 amount = token.balanceOf(address(this));
        uint256 amount1 = amount / 2;
        uint256 amount2 = amount - amount1;

        token.approve(address(this), amount);

        token.transferFrom(address(this), feeAddress1, amount1);
        token.transferFrom(address(this), feeAddress2, amount2);
    }

    event MarketplaceSetPrice(uint256 tokenId, uint256 price);
    event MarketplaceRemove(uint256 tokenId);
}

[{"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":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"MarketplaceRemove","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"}],"name":"MarketplaceSetPrice","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":[],"name":"MAX_NFTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"METADATA_PROVENANCE_HASH","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"OriginalOwners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"TeamMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"buyFromMarketplace","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"calculatePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"getNfts","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getOriginalOwnerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isActive","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":"isMarketplaceActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mintForTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseMarketplaceSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"setPrice","type":"uint256"}],"name":"putOnMarketplace","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"removeFromMarketplace","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_hash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startMarketplaceSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

69077:8413:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34457:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46635:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49421:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69160:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48951:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74382:73;;;;;;;;;;;;;:::i;:::-;;74545:95;;;;;;;;;;;;;:::i;:::-;;74026:116;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48429:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69285:71;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69623:41;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69204:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50311:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74648:96;;;;;;;;;;;;;:::i;:::-;;48191:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76608:309;;;;;;;;;;;;;:::i;:::-;;70975:653;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50687:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74257:117;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76925:449;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48717:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74150:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69986:433;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46391:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48010:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45958:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61523:148;;;;;;;;;;;;;:::i;:::-;;69513:49;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44460:39;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;70427:540;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74752:334;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60872:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46804:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49714:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75094:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74463:74;;;;;;;;;;;;;:::i;:::-;;50909:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75407:1011;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46979:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69239:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71636:2382;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50080:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69363:71;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69571:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61826:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34457:150;34542:4;34566:20;:33;34587:11;34566:33;;;;;;;;;;;;;;;;;;;;;;;;;;;34559:40;;34457:150;;;:::o;46635:100::-;46689:13;46722:5;46715:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46635:100;:::o;49421:221::-;49497:7;49525:16;49533:7;49525;:16::i;:::-;49517:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;49610:15;:24;49626:7;49610:24;;;;;;;;;;;;;;;;;;;;;49603:31;;49421:221;;;:::o;69160:37::-;69192:5;69160:37;:::o;48951:404::-;49032:13;49048:23;49063:7;49048:14;:23::i;:::-;49032:39;;49096:5;49090:11;;:2;:11;;;;49082:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;49176:5;49160:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;49185:44;49209:5;49216:12;:10;:12::i;:::-;49185:23;:44::i;:::-;49160:69;49152:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;49326:21;49335:2;49339:7;49326:8;:21::i;:::-;48951:404;;;:::o;74382:73::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74443:4:::1;74432:8;;:15;;;;;;;;;;;;;;;;;;74382:73::o:0;74545:95::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74628:4:::1;74606:19;;:26;;;;;;;;;;;;;;;;;;74545:95::o:0;74026:116::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74129:5:::1;74102:24;:32;;;;;;;;;;;;:::i;:::-;;74026:116:::0;:::o;48429:211::-;48490:7;48611:21;:12;:19;:21::i;:::-;48604:28;;48429:211;:::o;69285:71::-;;;;;;;;;;;;;:::o;69623:41::-;;;;;;;;;;;;;;;;;:::o;69204:28::-;;;;;;;;;;;;;:::o;50311:305::-;50472:41;50491:12;:10;:12::i;:::-;50505:7;50472:18;:41::i;:::-;50464:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;50580:28;50590:4;50596:2;50600:7;50580:9;:28::i;:::-;50311:305;;;:::o;74648:96::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74731:5:::1;74709:19;;:27;;;;;;;;;;;;;;;;;;74648:96::o:0;48191:162::-;48288:7;48315:30;48339:5;48315:13;:20;48329:5;48315:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;48308:37;;48191:162;;;;:::o;76608:309::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;76656:19:::1;76678:21;76656:43;;76710:16;76743:1;76729:11;:15;;;;:::i;:::-;76710:34;;76755:16;76788:8;76774:11;:22;;;;:::i;:::-;76755:41;;76825:11;;;;;;;;;;;76817:25;;:35;76843:8;76817:35;;;;;;;;;;;;;;;;;;;;;;;76809:44;;;::::0;::::1;;76880:12;;;;;;;;;;;76872:26;;:36;76899:8;76872:36;;;;;;;;;;;;;;;;;;;;;;;76864:45;;;::::0;::::1;;61163:1;;;76608:309::o:0;70975:653::-;71041:8;;;;;;;;;;;71033:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;69192:5;71097:13;:11;:13::i;:::-;:24;71089:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;71175:1;71167:5;:9;:24;;;;;71189:2;71180:5;:11;;71167:24;71159:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;69192:5;71259:24;71277:5;71259:13;:11;:13::i;:::-;:17;;:24;;;;:::i;:::-;:36;;71251:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;71348:27;71369:5;71348:16;:14;:16::i;:::-;:20;;:27;;;;:::i;:::-;71335:9;:40;;71327:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;71432:6;71427:194;71448:5;71444:1;:9;71427:194;;;71475:14;71508:1;71492:13;:11;:13::i;:::-;:17;;;;:::i;:::-;71475:34;;71524:32;71534:10;71546:9;71524;:32::i;:::-;71599:10;71571:14;:25;71586:9;71571:25;;;;;;;;;;;;:38;;;;;;;;;;;;;;;;;;71427:194;71455:3;;;;;:::i;:::-;;;;71427:194;;;;70975:653;:::o;50687:151::-;50791:39;50808:4;50814:2;50818:7;50791:39;;;;;;;;;;;;:16;:39::i;:::-;50687:151;;;:::o;74257:117::-;74315:13;74348:14;:18;74363:2;74348:18;;;;;;;;;;;;;;;;;;;;;74341:25;;74257:117;;;:::o;76925:449::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;77004:12:::1;77026;77004:35;;77052:14;77069:5;:15;;;77093:4;77069:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;77052:47;;77110:15;77137:1;77128:6;:10;;;;:::i;:::-;77110:28;;77149:15;77176:7;77167:6;:16;;;;:::i;:::-;77149:34;;77196:5;:13;;;77218:4;77225:6;77196:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77245:5;:18;;;77272:4;77279:11;;;;;;;;;;;77292:7;77245:55;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77311:5;:18;;;77338:4;77345:11;;;;;;;;;;;77358:7;77311:55;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;61163:1;;;;76925:449:::0;:::o;48717:172::-;48792:7;48813:15;48834:22;48850:5;48834:12;:15;;:22;;;;:::i;:::-;48812:44;;;48874:7;48867:14;;;48717:172;;;:::o;74150:99::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74221:20:::1;74233:7;74221:11;:20::i;:::-;74150:99:::0;:::o;69986:433::-;70064:11;;;;;;;;;;;70050:25;;:10;:25;;;:54;;;;70093:11;;;;;;;;;;;70079:25;;:10;:25;;;70050:54;70042:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;70154:9;:21;70164:10;70154:21;;;;;;;;;;;;;;;;70145:5;:30;;70137:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;70247:5;70222:9;:21;70232:10;70222:21;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;70267:6;70263:149;70283:5;70279:1;:9;70263:149;;;70319:14;70352:1;70336:13;:11;:13::i;:::-;:17;;;;:::i;:::-;70319:34;;70368:32;70378:10;70390:9;70368;:32::i;:::-;70263:149;70290:3;;;;;:::i;:::-;;;;70263:149;;;;69986:433;:::o;46391:177::-;46463:7;46490:70;46507:7;46490:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;46483:77;;46391:177;;;:::o;48010:97::-;48058:13;48091:8;48084:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48010:97;:::o;45958:221::-;46030:7;46075:1;46058:19;;:5;:19;;;;46050:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;46142:29;:13;:20;46156:5;46142:20;;;;;;;;;;;;;;;:27;:29::i;:::-;46135:36;;45958:221;;;:::o;61523:148::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;61630:1:::1;61593:40;;61614:6;;;;;;;;;;;61593:40;;;;;;;;;;;;61661:1;61644:6;;:19;;;;;;;;;;;;;;;;;;61523:148::o:0;69513:49::-;;;;;;;;;;;;;;;;;;;;;;:::o;44460:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;70427:540::-;70488:16;70518:18;70539:17;70549:6;70539:9;:17::i;:::-;70518:38;;70585:1;70571:10;:15;70567:393;;;70662:1;70648:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70641:23;;;;;70567:393;70697:23;70737:10;70723:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70697:51;;70763:13;70791:130;70815:10;70807:5;:18;70791:130;;;70871:34;70891:6;70899:5;70871:19;:34::i;:::-;70855:6;70862:5;70855:13;;;;;;;;;;;;;;;;;;;;;:50;;;;;70827:7;;;;;:::i;:::-;;;;70791:130;;;70942:6;70935:13;;;;;70427:540;;;;:::o;74752:334::-;74834:19;;;;;;;;;;;74826:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74927:11;74935:2;74927:7;:11::i;:::-;74913:25;;:10;:25;;;74905:34;;;;;;74971:8;74952:6;:10;74959:2;74952:10;;;;;;;;;;;:16;;:27;;;;75009:18;74990:6;:10;74997:2;74990:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75045:33;75065:2;75069:8;75045:33;;;;;;;:::i;:::-;;;;;;;;74752:334;;:::o;60872:87::-;60918:7;60945:6;;;;;;;;;;;60938:13;;60872:87;:::o;46804:104::-;46860:13;46893:7;46886:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46804:104;:::o;49714:295::-;49829:12;:10;:12::i;:::-;49817:24;;:8;:24;;;;49809:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;49929:8;49884:18;:32;49903:12;:10;:12::i;:::-;49884:32;;;;;;;;;;;;;;;:42;49917:8;49884:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;49982:8;49953:48;;49968:12;:10;:12::i;:::-;49953:48;;;49992:8;49953:48;;;;;;:::i;:::-;;;;;;;;49714:295;;:::o;75094:305::-;75163:19;;;;;;;;;;;75155:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;75256:11;75264:2;75256:7;:11::i;:::-;75242:25;;:10;:25;;;75234:34;;;;;;75288:6;:10;75295:2;75288:10;;;;;;;;;;;:16;;75281:23;;;75334:18;75315:6;:10;75322:2;75315:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75370:21;75388:2;75370:21;;;;;;:::i;:::-;;;;;;;;75094:305;:::o;74463:74::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;74524:5:::1;74513:8;;:16;;;;;;;;;;;;;;;;;;74463:74::o:0;50909:285::-;51041:41;51060:12;:10;:12::i;:::-;51074:7;51041:18;:41::i;:::-;51033:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;51147:39;51161:4;51167:2;51171:7;51180:5;51147:13;:39::i;:::-;50909:285;;;;:::o;75407:1011::-;75487:19;;;;;;;;;;;75479:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;75579:6;:16;75586:8;75579:16;;;;;;;;;;;:22;;;75566:9;:35;;75558:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;75658:6;:16;75665:8;75658:16;;;;;;;;;;;:22;;;;;;;;;;;;75636:44;;;;;;;;;;;;;;;;:18;:44;;;;;;;;;;;;;;;;;75628:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;75705:18;75726:17;75734:8;75726:7;:17::i;:::-;75705:38;;75754:26;75783:28;75802:8;75783:18;:28::i;:::-;75754:57;;75822:22;75863:10;75822:53;;75886:29;75934:18;75886:68;;75997:1;75971:6;:16;75978:8;75971:16;;;;;;;;;;;:22;;;:27;75967:330;;76015:11;76029:21;76040:9;76029:10;:21::i;:::-;76015:35;;76065:15;76083:28;76096:9;76107:3;76083:12;:28::i;:::-;76065:46;;76126:24;76167:3;76163:1;76153:7;:11;;;;:::i;:::-;:17;;;;:::i;:::-;76126:44;;76187:6;:15;;:43;76213:16;76203:7;:26;;;;:::i;:::-;76187:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76245:13;:22;;:40;76268:16;76245:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75967:330;;;;76309:50;76319:17;76327:8;76319:7;:17::i;:::-;76338:10;76350:8;76309:9;:50::i;:::-;76395:15;76370:6;:16;76377:8;76370:16;;;;;;;;;;;:22;;;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75407:1011;;;;;:::o;46979:792::-;47052:13;47086:16;47094:7;47086;:16::i;:::-;47078:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;47167:23;47193:10;:19;47204:7;47193:19;;;;;;;;;;;47167:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47223:18;47244:9;:7;:9::i;:::-;47223:30;;47351:1;47335:4;47329:18;:23;47325:72;;;47376:9;47369:16;;;;;;47325:72;47527:1;47507:9;47501:23;:27;47497:108;;;47576:4;47582:9;47559:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47545:48;;;;;;47497:108;47737:4;47743:18;:7;:16;:18::i;:::-;47720:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47706:57;;;;46979:792;;;;:::o;69239:39::-;;;;;;;;;;;;;:::o;71636:2382::-;71683:7;71723:4;71711:16;;:8;;;;;;;;;;;:16;;;71703:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;69192:5;71770:13;:11;:13::i;:::-;:24;71762:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;71834:18;71855:13;:11;:13::i;:::-;71834:34;;71902:5;71885:13;:22;71881:2130;;71930:21;71923:28;;;;;71881:2130;71999:5;71982:13;:22;71978:2033;;72027:20;72020:27;;;;;71978:2033;72095:5;72078:13;:22;72074:1937;;72123:20;72116:27;;;;;72074:1937;72191:5;72174:13;:22;72170:1841;;72219:20;72212:27;;;;;72170:1841;72287:5;72270:13;:22;72266:1745;;72315:20;72308:27;;;;;72266:1745;72383:5;72366:13;:22;72362:1649;;72411:20;72404:27;;;;;72362:1649;72479:5;72462:13;:22;72458:1553;;72507:20;72500:27;;;;;72458:1553;72575:5;72558:13;:22;72554:1457;;72603:19;72596:26;;;;;72554:1457;72670:5;72653:13;:22;72649:1362;;72698:19;72691:26;;;;;72649:1362;72765:4;72748:13;:21;72744:1267;;72792:19;72785:26;;;;;72744:1267;72859:4;72842:13;:21;72838:1173;;72886:19;72879:26;;;;;72838:1173;72953:4;72936:13;:21;72932:1079;;72980:19;72973:26;;;;;72932:1079;73047:4;73030:13;:21;73026:985;;73074:19;73067:26;;;;;73026:985;73141:4;73124:13;:21;73120:891;;73168:19;73161:26;;;;;73120:891;73235:4;73218:13;:21;73214:797;;73262:19;73255:26;;;;;73214:797;73329:4;73312:13;:21;73308:703;;73356:19;73349:26;;;;;73308:703;73423:4;73406:13;:21;73402:609;;73450:19;73443:26;;;;;73402:609;73517:4;73500:13;:21;73496:515;;73544:18;73537:25;;;;;73496:515;73610:4;73593:13;:21;73589:422;;73637:18;73630:25;;;;;73589:422;73703:4;73686:13;:21;73682:329;;73730:18;73723:25;;;;;73682:329;73796:3;73779:13;:20;73775:236;;73822:18;73815:25;;;;;73775:236;73888:3;73871:13;:20;73867:144;;73914:18;73907:25;;;;;73867:144;73981:18;73974:25;;;71636:2382;;:::o;50080:164::-;50177:4;50201:18;:25;50220:5;50201:25;;;;;;;;;;;;;;;:35;50227:8;50201:35;;;;;;;;;;;;;;;;;;;;;;;;;50194:42;;50080:164;;;;:::o;69363:71::-;;;;;;;;;;;;;:::o;69571:43::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;61826:244::-;61103:12;:10;:12::i;:::-;61092:23;;:7;:5;:7::i;:::-;:23;;;61084:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;61935:1:::1;61915:22;;:8;:22;;;;61907:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;62025:8;61996:38;;62017:6;;;;;;;;;;;61996:38;;;;;;;;;;;;62054:8;62045:6;;:17;;;;;;;;;;;;;;;;;;61826:244:::0;:::o;52661:127::-;52726:4;52750:30;52772:7;52750:12;:21;;:30;;;;:::i;:::-;52743:37;;52661:127;;;:::o;43388:98::-;43441:7;43468:10;43461:17;;43388:98;:::o;58832:183::-;58925:2;58898:15;:24;58914:7;58898:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;58981:7;58977:2;58943:46;;58952:23;58967:7;58952:14;:23::i;:::-;58943:46;;;;;;;;;;;;58832:183;;:::o;12863:123::-;12932:7;12959:19;12967:3;:10;;12959:7;:19::i;:::-;12952:26;;12863:123;;;:::o;52955:355::-;53048:4;53073:16;53081:7;53073;:16::i;:::-;53065:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;53149:13;53165:23;53180:7;53165:14;:23::i;:::-;53149:39;;53218:5;53207:16;;:7;:16;;;:51;;;;53251:7;53227:31;;:20;53239:7;53227:11;:20::i;:::-;:31;;;53207:51;:94;;;;53262:39;53286:5;53293:7;53262:23;:39::i;:::-;53207:94;53199:103;;;52955:355;;;;:::o;56091:628::-;56216:4;56189:31;;:23;56204:7;56189:14;:23::i;:::-;:31;;;56181:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;56317:1;56303:16;;:2;:16;;;;56295:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;56373:39;56394:4;56400:2;56404:7;56373:20;:39::i;:::-;56477:29;56494:1;56498:7;56477:8;:29::i;:::-;56519:35;56546:7;56519:13;:19;56533:4;56519:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;56565:30;56587:7;56565:13;:17;56579:2;56565:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;56608:29;56625:7;56634:2;56608:12;:16;;:29;;;;;:::i;:::-;;56648:20;56660:7;56648:11;:20::i;:::-;56703:7;56699:2;56684:27;;56693:4;56684:27;;;;;;;;;;;;56091:628;;;:::o;24486:137::-;24557:7;24592:22;24596:3;:10;;24608:5;24592:3;:22::i;:::-;24584:31;;24577:38;;24486:137;;;;:::o;64808:98::-;64866:7;64897:1;64893;:5;;;;:::i;:::-;64886:12;;64808:98;;;;:::o;65546:::-;65604:7;65635:1;65631;:5;;;;:::i;:::-;65624:12;;65546:98;;;;:::o;53653:110::-;53729:26;53739:2;53743:7;53729:26;;;;;;;;;;;;:9;:26::i;:::-;53653:110;;:::o;13334:236::-;13414:7;13423;13444:11;13457:13;13474:22;13478:3;:10;;13490:5;13474:3;:22::i;:::-;13443:53;;;;13523:3;13515:12;;13553:5;13545:14;;13507:55;;;;;;13334:236;;;;;:::o;57320:100::-;57404:8;57393;:19;;;;;;;;;;;;:::i;:::-;;57320:100;:::o;14620:213::-;14727:7;14778:44;14783:3;:10;;14803:3;14795:12;;14809;14778:4;:44::i;:::-;14770:53;;14747:78;;14620:213;;;;;:::o;24018:114::-;24078:7;24105:19;24113:3;:10;;24105:7;:19::i;:::-;24098:26;;24018:114;;;:::o;52076:272::-;52190:28;52200:4;52206:2;52210:7;52190:9;:28::i;:::-;52237:48;52260:4;52266:2;52270:7;52279:5;52237:22;:48::i;:::-;52229:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;52076:272;;;;:::o;76426:174::-;76485:7;76505:15;76523:23;76536:6;76544:1;76523:12;:23::i;:::-;76505:41;;76566:26;76579:7;76588:3;76566:12;:26::i;:::-;76559:33;;;76426:174;;;:::o;65189:98::-;65247:7;65278:1;65274;:5;;;;:::i;:::-;65267:12;;65189:98;;;;:::o;2997:723::-;3053:13;3283:1;3274:5;:10;3270:53;;;3301:10;;;;;;;;;;;;;;;;;;;;;3270:53;3333:12;3348:5;3333:20;;3364:14;3389:78;3404:1;3396:4;:9;3389:78;;3422:8;;;;;:::i;:::-;;;;3453:2;3445:10;;;;;:::i;:::-;;;3389:78;;;3477:19;3509:6;3499:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3477:39;;3527:154;3543:1;3534:5;:10;3527:154;;3571:1;3561:11;;;;;:::i;:::-;;;3638:2;3630:5;:10;;;;:::i;:::-;3617:2;:24;;;;:::i;:::-;3604:39;;3587:6;3594;3587:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;3667:2;3658:11;;;;;:::i;:::-;;;3527:154;;;3705:6;3691:21;;;;;2997:723;;;;:::o;12624:151::-;12708:4;12732:35;12742:3;:10;;12762:3;12754:12;;12732:9;:35::i;:::-;12725:42;;12624:151;;;;:::o;9432:110::-;9488:7;9515:3;:12;;:19;;;;9508:26;;9432:110;;;:::o;59628:93::-;;;;:::o;23563:137::-;23633:4;23657:35;23665:3;:10;;23685:5;23677:14;;23657:7;:35::i;:::-;23650:42;;23563:137;;;;:::o;23256:131::-;23323:4;23347:32;23352:3;:10;;23372:5;23364:14;;23347:4;:32::i;:::-;23340:39;;23256:131;;;;:::o;12047:185::-;12136:4;12160:64;12165:3;:10;;12185:3;12177:12;;12215:5;12199:23;;12191:32;;12160:4;:64::i;:::-;12153:71;;12047:185;;;;;:::o;46189:132::-;46249:6;:10;46256:2;46249:10;;;;;;;;;;;:16;;46242:23;;;46295:18;46276:6;:10;46283:2;46276:10;;;;;;;;;;;:16;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46189:132;:::o;19494:204::-;19561:7;19610:5;19589:3;:11;;:18;;;;:26;19581:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;19672:3;:11;;19684:5;19672:18;;;;;;;;;;;;;;;;;;;;;;;;19665:25;;19494:204;;;;:::o;53990:250::-;54086:18;54092:2;54096:7;54086:5;:18::i;:::-;54123:54;54154:1;54158:2;54162:7;54171:5;54123:22;:54::i;:::-;54115:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;53990:250;;;:::o;9907:279::-;9974:7;9983;10033:5;10011:3;:12;;:19;;;;:27;10003:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;10090:22;10115:3;:12;;10128:5;10115:19;;;;;;;;;;;;;;;;;;;;;;;;;;10090:44;;10153:5;:10;;;10165:5;:12;;;10145:33;;;;;9907:279;;;;;:::o;11404:319::-;11498:7;11518:16;11537:3;:12;;:17;11550:3;11537:17;;;;;;;;;;;;11518:36;;11585:1;11573:8;:13;;11588:12;11565:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;11655:3;:12;;11679:1;11668:8;:12;;;;:::i;:::-;11655:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;;11648:40;;;11404:319;;;;;:::o;19031:109::-;19087:7;19114:3;:11;;:18;;;;19107:25;;19031:109;;;:::o;57985:839::-;58102:4;58128:15;:2;:13;;;:15::i;:::-;58124:693;;;58180:2;58164:36;;;58201:12;:10;:12::i;:::-;58215:4;58221:7;58230:5;58164:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;58160:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58427:1;58410:6;:13;:18;58406:341;;;58453:60;;;;;;;;;;:::i;:::-;;;;;;;;58406:341;58697:6;58691:13;58682:6;58678:2;58674:15;58667:38;58160:602;58297:45;;;58287:55;;;:6;:55;;;;58280:62;;;;;58124:693;58801:4;58794:11;;57985:839;;;;;;;:::o;65945:98::-;66003:7;66034:1;66030;:5;;;;:::i;:::-;66023:12;;65945:98;;;;:::o;9212:125::-;9283:4;9328:1;9307:3;:12;;:17;9320:3;9307:17;;;;;;;;;;;;:22;;9300:29;;9212:125;;;;:::o;17186:1544::-;17252:4;17370:18;17391:3;:12;;:19;17404:5;17391:19;;;;;;;;;;;;17370:40;;17441:1;17427:10;:15;17423:1300;;17789:21;17826:1;17813:10;:14;;;;:::i;:::-;17789:38;;17842:17;17883:1;17862:3;:11;;:18;;;;:22;;;;:::i;:::-;17842:42;;18129:17;18149:3;:11;;18161:9;18149:22;;;;;;;;;;;;;;;;;;;;;;;;18129:42;;18295:9;18266:3;:11;;18278:13;18266:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;18414:1;18398:13;:17;;;;:::i;:::-;18372:3;:12;;:23;18385:9;18372:23;;;;;;;;;;;:43;;;;18524:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18619:3;:12;;:19;18632:5;18619:19;;;;;;;;;;;18612:26;;;18662:4;18655:11;;;;;;;;17423:1300;18706:5;18699:12;;;17186:1544;;;;;:::o;16596:414::-;16659:4;16681:21;16691:3;16696:5;16681:9;:21::i;:::-;16676:327;;16719:3;:11;;16736:5;16719:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16902:3;:11;;:18;;;;16880:3;:12;;:19;16893:5;16880:19;;;;;;;;;;;:40;;;;16942:4;16935:11;;;;16676:327;16986:5;16979:12;;16596:414;;;;;:::o;6712:692::-;6788:4;6904:16;6923:3;:12;;:17;6936:3;6923:17;;;;;;;;;;;;6904:36;;6969:1;6957:8;:13;6953:444;;;7024:3;:12;;7042:38;;;;;;;;7059:3;7042:38;;;;7072:5;7042:38;;;7024:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7239:3;:12;;:19;;;;7219:3;:12;;:17;7232:3;7219:17;;;;;;;;;;;:39;;;;7280:4;7273:11;;;;;6953:444;7353:5;7317:3;:12;;7341:1;7330:8;:12;;;;:::i;:::-;7317:26;;;;;;;;;;;;;;;;;;;;;;;;;;:33;;:41;;;;7380:5;7373:12;;;6712:692;;;;;;:::o;54576:404::-;54670:1;54656:16;;:2;:16;;;;54648:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;54729:16;54737:7;54729;:16::i;:::-;54728:17;54720:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;54791:45;54820:1;54824:2;54828:7;54791:20;:45::i;:::-;54849:30;54871:7;54849:13;:17;54863:2;54849:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;54892:29;54909:7;54918:2;54892:12;:16;;:29;;;;;:::i;:::-;;54964:7;54960:2;54939:33;;54956:1;54939:33;;;;;;;;;;;;54576:404;;:::o;25438:422::-;25498:4;25706:12;25817:7;25805:20;25797:28;;25851:1;25844:4;:8;25837:15;;;25438:422;;;:::o;18816:129::-;18889:4;18936:1;18913:3;:12;;:19;18926:5;18913:19;;;;;;;;;;;;:24;;18906:31;;18816:129;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:133::-;;931:6;918:20;909:29;;947:30;971:5;947:30;:::i;:::-;899:84;;;;:::o;989:137::-;;1074:6;1068:13;1059:22;;1090:30;1114:5;1090:30;:::i;:::-;1049:77;;;;:::o;1132:137::-;;1215:6;1202:20;1193:29;;1231:32;1257:5;1231:32;:::i;:::-;1183:86;;;;:::o;1275:141::-;;1362:6;1356:13;1347:22;;1378:32;1404:5;1378:32;:::i;:::-;1337:79;;;;:::o;1435:271::-;;1539:3;1532:4;1524:6;1520:17;1516:27;1506:2;;1557:1;1554;1547:12;1506:2;1597:6;1584:20;1622:78;1696:3;1688:6;1681:4;1673:6;1669:17;1622:78;:::i;:::-;1613:87;;1496:210;;;;;:::o;1726:273::-;;1831:3;1824:4;1816:6;1812:17;1808:27;1798:2;;1849:1;1846;1839:12;1798:2;1889:6;1876:20;1914:79;1989:3;1981:6;1974:4;1966:6;1962:17;1914:79;:::i;:::-;1905:88;;1788:211;;;;;:::o;2005:139::-;;2089:6;2076:20;2067:29;;2105:33;2132:5;2105:33;:::i;:::-;2057:87;;;;:::o;2150:143::-;;2238:6;2232:13;2223:22;;2254:33;2281:5;2254:33;:::i;:::-;2213:80;;;;:::o;2299:262::-;;2407:2;2395:9;2386:7;2382:23;2378:32;2375:2;;;2423:1;2420;2413:12;2375:2;2466:1;2491:53;2536:7;2527:6;2516:9;2512:22;2491:53;:::i;:::-;2481:63;;2437:117;2365:196;;;;:::o;2567:407::-;;;2692:2;2680:9;2671:7;2667:23;2663:32;2660:2;;;2708:1;2705;2698:12;2660:2;2751:1;2776:53;2821:7;2812:6;2801:9;2797:22;2776:53;:::i;:::-;2766:63;;2722:117;2878:2;2904:53;2949:7;2940:6;2929:9;2925:22;2904:53;:::i;:::-;2894:63;;2849:118;2650:324;;;;;:::o;2980:552::-;;;;3122:2;3110:9;3101:7;3097:23;3093:32;3090:2;;;3138:1;3135;3128:12;3090:2;3181:1;3206:53;3251:7;3242:6;3231:9;3227:22;3206:53;:::i;:::-;3196:63;;3152:117;3308:2;3334:53;3379:7;3370:6;3359:9;3355:22;3334:53;:::i;:::-;3324:63;;3279:118;3436:2;3462:53;3507:7;3498:6;3487:9;3483:22;3462:53;:::i;:::-;3452:63;;3407:118;3080:452;;;;;:::o;3538:809::-;;;;;3706:3;3694:9;3685:7;3681:23;3677:33;3674:2;;;3723:1;3720;3713:12;3674:2;3766:1;3791:53;3836:7;3827:6;3816:9;3812:22;3791:53;:::i;:::-;3781:63;;3737:117;3893:2;3919:53;3964:7;3955:6;3944:9;3940:22;3919:53;:::i;:::-;3909:63;;3864:118;4021:2;4047:53;4092:7;4083:6;4072:9;4068:22;4047:53;:::i;:::-;4037:63;;3992:118;4177:2;4166:9;4162:18;4149:32;4208:18;4200:6;4197:30;4194:2;;;4240:1;4237;4230:12;4194:2;4268:62;4322:7;4313:6;4302:9;4298:22;4268:62;:::i;:::-;4258:72;;4120:220;3664:683;;;;;;;:::o;4353:401::-;;;4475:2;4463:9;4454:7;4450:23;4446:32;4443:2;;;4491:1;4488;4481:12;4443:2;4534:1;4559:53;4604:7;4595:6;4584:9;4580:22;4559:53;:::i;:::-;4549:63;;4505:117;4661:2;4687:50;4729:7;4720:6;4709:9;4705:22;4687:50;:::i;:::-;4677:60;;4632:115;4433:321;;;;;:::o;4760:407::-;;;4885:2;4873:9;4864:7;4860:23;4856:32;4853:2;;;4901:1;4898;4891:12;4853:2;4944:1;4969:53;5014:7;5005:6;4994:9;4990:22;4969:53;:::i;:::-;4959:63;;4915:117;5071:2;5097:53;5142:7;5133:6;5122:9;5118:22;5097:53;:::i;:::-;5087:63;;5042:118;4843:324;;;;;:::o;5173:278::-;;5289:2;5277:9;5268:7;5264:23;5260:32;5257:2;;;5305:1;5302;5295:12;5257:2;5348:1;5373:61;5426:7;5417:6;5406:9;5402:22;5373:61;:::i;:::-;5363:71;;5319:125;5247:204;;;;:::o;5457:260::-;;5564:2;5552:9;5543:7;5539:23;5535:32;5532:2;;;5580:1;5577;5570:12;5532:2;5623:1;5648:52;5692:7;5683:6;5672:9;5668:22;5648:52;:::i;:::-;5638:62;;5594:116;5522:195;;;;:::o;5723:282::-;;5841:2;5829:9;5820:7;5816:23;5812:32;5809:2;;;5857:1;5854;5847:12;5809:2;5900:1;5925:63;5980:7;5971:6;5960:9;5956:22;5925:63;:::i;:::-;5915:73;;5871:127;5799:206;;;;:::o;6011:375::-;;6129:2;6117:9;6108:7;6104:23;6100:32;6097:2;;;6145:1;6142;6135:12;6097:2;6216:1;6205:9;6201:17;6188:31;6246:18;6238:6;6235:30;6232:2;;;6278:1;6275;6268:12;6232:2;6306:63;6361:7;6352:6;6341:9;6337:22;6306:63;:::i;:::-;6296:73;;6159:220;6087:299;;;;:::o;6392:262::-;;6500:2;6488:9;6479:7;6475:23;6471:32;6468:2;;;6516:1;6513;6506:12;6468:2;6559:1;6584:53;6629:7;6620:6;6609:9;6605:22;6584:53;:::i;:::-;6574:63;;6530:117;6458:196;;;;:::o;6660:284::-;;6779:2;6767:9;6758:7;6754:23;6750:32;6747:2;;;6795:1;6792;6785:12;6747:2;6838:1;6863:64;6919:7;6910:6;6899:9;6895:22;6863:64;:::i;:::-;6853:74;;6809:128;6737:207;;;;:::o;6950:407::-;;;7075:2;7063:9;7054:7;7050:23;7046:32;7043:2;;;7091:1;7088;7081:12;7043:2;7134:1;7159:53;7204:7;7195:6;7184:9;7180:22;7159:53;:::i;:::-;7149:63;;7105:117;7261:2;7287:53;7332:7;7323:6;7312:9;7308:22;7287:53;:::i;:::-;7277:63;;7232:118;7033:324;;;;;:::o;7363:179::-;;7453:46;7495:3;7487:6;7453:46;:::i;:::-;7531:4;7526:3;7522:14;7508:28;;7443:99;;;;:::o;7548:118::-;7635:24;7653:5;7635:24;:::i;:::-;7630:3;7623:37;7613:53;;:::o;7702:732::-;;7850:54;7898:5;7850:54;:::i;:::-;7920:86;7999:6;7994:3;7920:86;:::i;:::-;7913:93;;8030:56;8080:5;8030:56;:::i;:::-;8109:7;8140:1;8125:284;8150:6;8147:1;8144:13;8125:284;;;8226:6;8220:13;8253:63;8312:3;8297:13;8253:63;:::i;:::-;8246:70;;8339:60;8392:6;8339:60;:::i;:::-;8329:70;;8185:224;8172:1;8169;8165:9;8160:14;;8125:284;;;8129:14;8425:3;8418:10;;7826:608;;;;;;;:::o;8440:109::-;8521:21;8536:5;8521:21;:::i;:::-;8516:3;8509:34;8499:50;;:::o;8555:360::-;;8669:38;8701:5;8669:38;:::i;:::-;8723:70;8786:6;8781:3;8723:70;:::i;:::-;8716:77;;8802:52;8847:6;8842:3;8835:4;8828:5;8824:16;8802:52;:::i;:::-;8879:29;8901:6;8879:29;:::i;:::-;8874:3;8870:39;8863:46;;8645:270;;;;;:::o;8921:157::-;9021:50;9065:5;9021:50;:::i;:::-;9016:3;9009:63;8999:79;;:::o;9084:364::-;;9200:39;9233:5;9200:39;:::i;:::-;9255:71;9319:6;9314:3;9255:71;:::i;:::-;9248:78;;9335:52;9380:6;9375:3;9368:4;9361:5;9357:16;9335:52;:::i;:::-;9412:29;9434:6;9412:29;:::i;:::-;9407:3;9403:39;9396:46;;9176:272;;;;;:::o;9454:377::-;;9588:39;9621:5;9588:39;:::i;:::-;9643:89;9725:6;9720:3;9643:89;:::i;:::-;9636:96;;9741:52;9786:6;9781:3;9774:4;9767:5;9763:16;9741:52;:::i;:::-;9818:6;9813:3;9809:16;9802:23;;9564:267;;;;;:::o;9837:366::-;;10000:67;10064:2;10059:3;10000:67;:::i;:::-;9993:74;;10097:34;10093:1;10088:3;10084:11;10077:55;10163:4;10158:2;10153:3;10149:12;10142:26;10194:2;10189:3;10185:12;10178:19;;9983:220;;;:::o;10209:309::-;;10372:67;10436:2;10431:3;10372:67;:::i;:::-;10365:74;;10469:13;10465:1;10460:3;10456:11;10449:34;10509:2;10504:3;10500:12;10493:19;;10355:163;;;:::o;10524:376::-;;10687:67;10751:2;10746:3;10687:67;:::i;:::-;10680:74;;10784:34;10780:1;10775:3;10771:11;10764:55;10850:14;10845:2;10840:3;10836:12;10829:36;10891:2;10886:3;10882:12;10875:19;;10670:230;;;:::o;10906:382::-;;11069:67;11133:2;11128:3;11069:67;:::i;:::-;11062:74;;11166:34;11162:1;11157:3;11153:11;11146:55;11232:20;11227:2;11222:3;11218:12;11211:42;11279:2;11274:3;11270:12;11263:19;;11052:236;;;:::o;11294:366::-;;11457:67;11521:2;11516:3;11457:67;:::i;:::-;11450:74;;11554:34;11550:1;11545:3;11541:11;11534:55;11620:4;11615:2;11610:3;11606:12;11599:26;11651:2;11646:3;11642:12;11635:19;;11440:220;;;:::o;11666:370::-;;11829:67;11893:2;11888:3;11829:67;:::i;:::-;11822:74;;11926:34;11922:1;11917:3;11913:11;11906:55;11992:8;11987:2;11982:3;11978:12;11971:30;12027:2;12022:3;12018:12;12011:19;;11812:224;;;:::o;12042:326::-;;12205:67;12269:2;12264:3;12205:67;:::i;:::-;12198:74;;12302:30;12298:1;12293:3;12289:11;12282:51;12359:2;12354:3;12350:12;12343:19;;12188:180;;;:::o;12374:368::-;;12537:67;12601:2;12596:3;12537:67;:::i;:::-;12530:74;;12634:34;12630:1;12625:3;12621:11;12614:55;12700:6;12695:2;12690:3;12686:12;12679:28;12733:2;12728:3;12724:12;12717:19;;12520:222;;;:::o;12748:323::-;;12911:67;12975:2;12970:3;12911:67;:::i;:::-;12904:74;;13008:27;13004:1;12999:3;12995:11;12988:48;13062:2;13057:3;13053:12;13046:19;;12894:177;;;:::o;13077:376::-;;13240:67;13304:2;13299:3;13240:67;:::i;:::-;13233:74;;13337:34;13333:1;13328:3;13324:11;13317:55;13403:14;13398:2;13393:3;13389:12;13382:36;13444:2;13439:3;13435:12;13428:19;;13223:230;;;:::o;13459:388::-;;13622:67;13686:2;13681:3;13622:67;:::i;:::-;13615:74;;13719:34;13715:1;13710:3;13706:11;13699:55;13785:26;13780:2;13775:3;13771:12;13764:48;13838:2;13833:3;13829:12;13822:19;;13605:242;;;:::o;13853:374::-;;14016:67;14080:2;14075:3;14016:67;:::i;:::-;14009:74;;14113:34;14109:1;14104:3;14100:11;14093:55;14179:12;14174:2;14169:3;14165:12;14158:34;14218:2;14213:3;14209:12;14202:19;;13999:228;;;:::o;14233:366::-;;14396:67;14460:2;14455:3;14396:67;:::i;:::-;14389:74;;14493:34;14489:1;14484:3;14480:11;14473:55;14559:4;14554:2;14549:3;14545:12;14538:26;14590:2;14585:3;14581:12;14574:19;;14379:220;;;:::o;14605:330::-;;14768:67;14832:2;14827:3;14768:67;:::i;:::-;14761:74;;14865:34;14861:1;14856:3;14852:11;14845:55;14926:2;14921:3;14917:12;14910:19;;14751:184;;;:::o;14941:368::-;;15104:67;15168:2;15163:3;15104:67;:::i;:::-;15097:74;;15201:34;15197:1;15192:3;15188:11;15181:55;15267:6;15262:2;15257:3;15253:12;15246:28;15300:2;15295:3;15291:12;15284:19;;15087:222;;;:::o;15315:376::-;;15478:67;15542:2;15537:3;15478:67;:::i;:::-;15471:74;;15575:34;15571:1;15566:3;15562:11;15555:55;15641:14;15636:2;15631:3;15627:12;15620:36;15682:2;15677:3;15673:12;15666:19;;15461:230;;;:::o;15697:314::-;;15860:67;15924:2;15919:3;15860:67;:::i;:::-;15853:74;;15957:18;15953:1;15948:3;15944:11;15937:39;16002:2;15997:3;15993:12;15986:19;;15843:168;;;:::o;16017:330::-;;16180:67;16244:2;16239:3;16180:67;:::i;:::-;16173:74;;16277:34;16273:1;16268:3;16264:11;16257:55;16338:2;16333:3;16329:12;16322:19;;16163:184;;;:::o;16353:327::-;;16516:67;16580:2;16575:3;16516:67;:::i;:::-;16509:74;;16613:31;16609:1;16604:3;16600:11;16593:52;16671:2;16666:3;16662:12;16655:19;;16499:181;;;:::o;16686:322::-;;16849:67;16913:2;16908:3;16849:67;:::i;:::-;16842:74;;16946:26;16942:1;16937:3;16933:11;16926:47;16999:2;16994:3;16990:12;16983:19;;16832:176;;;:::o;17014:373::-;;17177:67;17241:2;17236:3;17177:67;:::i;:::-;17170:74;;17274:34;17270:1;17265:3;17261:11;17254:55;17340:11;17335:2;17330:3;17326:12;17319:33;17378:2;17373:3;17369:12;17362:19;;17160:227;;;:::o;17393:379::-;;17556:67;17620:2;17615:3;17556:67;:::i;:::-;17549:74;;17653:34;17649:1;17644:3;17640:11;17633:55;17719:17;17714:2;17709:3;17705:12;17698:39;17763:2;17758:3;17754:12;17747:19;;17539:233;;;:::o;17778:304::-;;17941:66;18005:1;18000:3;17941:66;:::i;:::-;17934:73;;18037:9;18033:1;18028:3;18024:11;18017:30;18073:2;18068:3;18064:12;18057:19;;17924:158;;;:::o;18088:365::-;;18251:67;18315:2;18310:3;18251:67;:::i;:::-;18244:74;;18348:34;18344:1;18339:3;18335:11;18328:55;18414:3;18409:2;18404:3;18400:12;18393:25;18444:2;18439:3;18435:12;18428:19;;18234:219;;;:::o;18459:320::-;;18622:67;18686:2;18681:3;18622:67;:::i;:::-;18615:74;;18719:24;18715:1;18710:3;18706:11;18699:45;18770:2;18765:3;18761:12;18754:19;;18605:174;;;:::o;18785:381::-;;18948:67;19012:2;19007:3;18948:67;:::i;:::-;18941:74;;19045:34;19041:1;19036:3;19032:11;19025:55;19111:19;19106:2;19101:3;19097:12;19090:41;19157:2;19152:3;19148:12;19141:19;;18931:235;;;:::o;19172:315::-;;19335:67;19399:2;19394:3;19335:67;:::i;:::-;19328:74;;19432:19;19428:1;19423:3;19419:11;19412:40;19478:2;19473:3;19469:12;19462:19;;19318:169;;;:::o;19493:317::-;;19656:67;19720:2;19715:3;19656:67;:::i;:::-;19649:74;;19753:21;19749:1;19744:3;19740:11;19733:42;19801:2;19796:3;19792:12;19785:19;;19639:171;;;:::o;19816:108::-;19893:24;19911:5;19893:24;:::i;:::-;19888:3;19881:37;19871:53;;:::o;19930:118::-;20017:24;20035:5;20017:24;:::i;:::-;20012:3;20005:37;19995:53;;:::o;20054:435::-;;20256:95;20347:3;20338:6;20256:95;:::i;:::-;20249:102;;20368:95;20459:3;20450:6;20368:95;:::i;:::-;20361:102;;20480:3;20473:10;;20238:251;;;;;:::o;20495:222::-;;20626:2;20615:9;20611:18;20603:26;;20639:71;20707:1;20696:9;20692:17;20683:6;20639:71;:::i;:::-;20593:124;;;;:::o;20723:442::-;;20910:2;20899:9;20895:18;20887:26;;20923:71;20991:1;20980:9;20976:17;20967:6;20923:71;:::i;:::-;21004:72;21072:2;21061:9;21057:18;21048:6;21004:72;:::i;:::-;21086;21154:2;21143:9;21139:18;21130:6;21086:72;:::i;:::-;20877:288;;;;;;:::o;21171:640::-;;21404:3;21393:9;21389:19;21381:27;;21418:71;21486:1;21475:9;21471:17;21462:6;21418:71;:::i;:::-;21499:72;21567:2;21556:9;21552:18;21543:6;21499:72;:::i;:::-;21581;21649:2;21638:9;21634:18;21625:6;21581:72;:::i;:::-;21700:9;21694:4;21690:20;21685:2;21674:9;21670:18;21663:48;21728:76;21799:4;21790:6;21728:76;:::i;:::-;21720:84;;21371:440;;;;;;;:::o;21817:332::-;;21976:2;21965:9;21961:18;21953:26;;21989:71;22057:1;22046:9;22042:17;22033:6;21989:71;:::i;:::-;22070:72;22138:2;22127:9;22123:18;22114:6;22070:72;:::i;:::-;21943:206;;;;;:::o;22155:373::-;;22336:2;22325:9;22321:18;22313:26;;22385:9;22379:4;22375:20;22371:1;22360:9;22356:17;22349:47;22413:108;22516:4;22507:6;22413:108;:::i;:::-;22405:116;;22303:225;;;;:::o;22534:210::-;;22659:2;22648:9;22644:18;22636:26;;22672:65;22734:1;22723:9;22719:17;22710:6;22672:65;:::i;:::-;22626:118;;;;:::o;22750:313::-;;22901:2;22890:9;22886:18;22878:26;;22950:9;22944:4;22940:20;22936:1;22925:9;22921:17;22914:47;22978:78;23051:4;23042:6;22978:78;:::i;:::-;22970:86;;22868:195;;;;:::o;23069:419::-;;23273:2;23262:9;23258:18;23250:26;;23322:9;23316:4;23312:20;23308:1;23297:9;23293:17;23286:47;23350:131;23476:4;23350:131;:::i;:::-;23342:139;;23240:248;;;:::o;23494:419::-;;23698:2;23687:9;23683:18;23675:26;;23747:9;23741:4;23737:20;23733:1;23722:9;23718:17;23711:47;23775:131;23901:4;23775:131;:::i;:::-;23767:139;;23665:248;;;:::o;23919:419::-;;24123:2;24112:9;24108:18;24100:26;;24172:9;24166:4;24162:20;24158:1;24147:9;24143:17;24136:47;24200:131;24326:4;24200:131;:::i;:::-;24192:139;;24090:248;;;:::o;24344:419::-;;24548:2;24537:9;24533:18;24525:26;;24597:9;24591:4;24587:20;24583:1;24572:9;24568:17;24561:47;24625:131;24751:4;24625:131;:::i;:::-;24617:139;;24515:248;;;:::o;24769:419::-;;24973:2;24962:9;24958:18;24950:26;;25022:9;25016:4;25012:20;25008:1;24997:9;24993:17;24986:47;25050:131;25176:4;25050:131;:::i;:::-;25042:139;;24940:248;;;:::o;25194:419::-;;25398:2;25387:9;25383:18;25375:26;;25447:9;25441:4;25437:20;25433:1;25422:9;25418:17;25411:47;25475:131;25601:4;25475:131;:::i;:::-;25467:139;;25365:248;;;:::o;25619:419::-;;25823:2;25812:9;25808:18;25800:26;;25872:9;25866:4;25862:20;25858:1;25847:9;25843:17;25836:47;25900:131;26026:4;25900:131;:::i;:::-;25892:139;;25790:248;;;:::o;26044:419::-;;26248:2;26237:9;26233:18;26225:26;;26297:9;26291:4;26287:20;26283:1;26272:9;26268:17;26261:47;26325:131;26451:4;26325:131;:::i;:::-;26317:139;;26215:248;;;:::o;26469:419::-;;26673:2;26662:9;26658:18;26650:26;;26722:9;26716:4;26712:20;26708:1;26697:9;26693:17;26686:47;26750:131;26876:4;26750:131;:::i;:::-;26742:139;;26640:248;;;:::o;26894:419::-;;27098:2;27087:9;27083:18;27075:26;;27147:9;27141:4;27137:20;27133:1;27122:9;27118:17;27111:47;27175:131;27301:4;27175:131;:::i;:::-;27167:139;;27065:248;;;:::o;27319:419::-;;27523:2;27512:9;27508:18;27500:26;;27572:9;27566:4;27562:20;27558:1;27547:9;27543:17;27536:47;27600:131;27726:4;27600:131;:::i;:::-;27592:139;;27490:248;;;:::o;27744:419::-;;27948:2;27937:9;27933:18;27925:26;;27997:9;27991:4;27987:20;27983:1;27972:9;27968:17;27961:47;28025:131;28151:4;28025:131;:::i;:::-;28017:139;;27915:248;;;:::o;28169:419::-;;28373:2;28362:9;28358:18;28350:26;;28422:9;28416:4;28412:20;28408:1;28397:9;28393:17;28386:47;28450:131;28576:4;28450:131;:::i;:::-;28442:139;;28340:248;;;:::o;28594:419::-;;28798:2;28787:9;28783:18;28775:26;;28847:9;28841:4;28837:20;28833:1;28822:9;28818:17;28811:47;28875:131;29001:4;28875:131;:::i;:::-;28867:139;;28765:248;;;:::o;29019:419::-;;29223:2;29212:9;29208:18;29200:26;;29272:9;29266:4;29262:20;29258:1;29247:9;29243:17;29236:47;29300:131;29426:4;29300:131;:::i;:::-;29292:139;;29190:248;;;:::o;29444:419::-;;29648:2;29637:9;29633:18;29625:26;;29697:9;29691:4;29687:20;29683:1;29672:9;29668:17;29661:47;29725:131;29851:4;29725:131;:::i;:::-;29717:139;;29615:248;;;:::o;29869:419::-;;30073:2;30062:9;30058:18;30050:26;;30122:9;30116:4;30112:20;30108:1;30097:9;30093:17;30086:47;30150:131;30276:4;30150:131;:::i;:::-;30142:139;;30040:248;;;:::o;30294:419::-;;30498:2;30487:9;30483:18;30475:26;;30547:9;30541:4;30537:20;30533:1;30522:9;30518:17;30511:47;30575:131;30701:4;30575:131;:::i;:::-;30567:139;;30465:248;;;:::o;30719:419::-;;30923:2;30912:9;30908:18;30900:26;;30972:9;30966:4;30962:20;30958:1;30947:9;30943:17;30936:47;31000:131;31126:4;31000:131;:::i;:::-;30992:139;;30890:248;;;:::o;31144:419::-;;31348:2;31337:9;31333:18;31325:26;;31397:9;31391:4;31387:20;31383:1;31372:9;31368:17;31361:47;31425:131;31551:4;31425:131;:::i;:::-;31417:139;;31315:248;;;:::o;31569:419::-;;31773:2;31762:9;31758:18;31750:26;;31822:9;31816:4;31812:20;31808:1;31797:9;31793:17;31786:47;31850:131;31976:4;31850:131;:::i;:::-;31842:139;;31740:248;;;:::o;31994:419::-;;32198:2;32187:9;32183:18;32175:26;;32247:9;32241:4;32237:20;32233:1;32222:9;32218:17;32211:47;32275:131;32401:4;32275:131;:::i;:::-;32267:139;;32165:248;;;:::o;32419:419::-;;32623:2;32612:9;32608:18;32600:26;;32672:9;32666:4;32662:20;32658:1;32647:9;32643:17;32636:47;32700:131;32826:4;32700:131;:::i;:::-;32692:139;;32590:248;;;:::o;32844:419::-;;33048:2;33037:9;33033:18;33025:26;;33097:9;33091:4;33087:20;33083:1;33072:9;33068:17;33061:47;33125:131;33251:4;33125:131;:::i;:::-;33117:139;;33015:248;;;:::o;33269:419::-;;33473:2;33462:9;33458:18;33450:26;;33522:9;33516:4;33512:20;33508:1;33497:9;33493:17;33486:47;33550:131;33676:4;33550:131;:::i;:::-;33542:139;;33440:248;;;:::o;33694:419::-;;33898:2;33887:9;33883:18;33875:26;;33947:9;33941:4;33937:20;33933:1;33922:9;33918:17;33911:47;33975:131;34101:4;33975:131;:::i;:::-;33967:139;;33865:248;;;:::o;34119:419::-;;34323:2;34312:9;34308:18;34300:26;;34372:9;34366:4;34362:20;34358:1;34347:9;34343:17;34336:47;34400:131;34526:4;34400:131;:::i;:::-;34392:139;;34290:248;;;:::o;34544:419::-;;34748:2;34737:9;34733:18;34725:26;;34797:9;34791:4;34787:20;34783:1;34772:9;34768:17;34761:47;34825:131;34951:4;34825:131;:::i;:::-;34817:139;;34715:248;;;:::o;34969:222::-;;35100:2;35089:9;35085:18;35077:26;;35113:71;35181:1;35170:9;35166:17;35157:6;35113:71;:::i;:::-;35067:124;;;;:::o;35197:332::-;;35356:2;35345:9;35341:18;35333:26;;35369:71;35437:1;35426:9;35422:17;35413:6;35369:71;:::i;:::-;35450:72;35518:2;35507:9;35503:18;35494:6;35450:72;:::i;:::-;35323:206;;;;;:::o;35535:468::-;;35735:2;35724:9;35720:18;35712:26;;35748:71;35816:1;35805:9;35801:17;35792:6;35748:71;:::i;:::-;35829:72;35897:2;35886:9;35882:18;35873:6;35829:72;:::i;:::-;35911:85;35992:2;35981:9;35977:18;35968:6;35911:85;:::i;:::-;35702:301;;;;;;:::o;36009:283::-;;36075:2;36069:9;36059:19;;36117:4;36109:6;36105:17;36224:6;36212:10;36209:22;36188:18;36176:10;36173:34;36170:62;36167:2;;;36235:18;;:::i;:::-;36167:2;36275:10;36271:2;36264:22;36049:243;;;;:::o;36298:331::-;;36449:18;36441:6;36438:30;36435:2;;;36471:18;;:::i;:::-;36435:2;36556:4;36552:9;36545:4;36537:6;36533:17;36529:33;36521:41;;36617:4;36611;36607:15;36599:23;;36364:265;;;:::o;36635:332::-;;36787:18;36779:6;36776:30;36773:2;;;36809:18;;:::i;:::-;36773:2;36894:4;36890:9;36883:4;36875:6;36871:17;36867:33;36859:41;;36955:4;36949;36945:15;36937:23;;36702:265;;;:::o;36973:132::-;;37063:3;37055:11;;37093:4;37088:3;37084:14;37076:22;;37045:60;;;:::o;37111:114::-;;37212:5;37206:12;37196:22;;37185:40;;;:::o;37231:98::-;;37316:5;37310:12;37300:22;;37289:40;;;:::o;37335:99::-;;37421:5;37415:12;37405:22;;37394:40;;;:::o;37440:113::-;;37542:4;37537:3;37533:14;37525:22;;37515:38;;;:::o;37559:184::-;;37692:6;37687:3;37680:19;37732:4;37727:3;37723:14;37708:29;;37670:73;;;;:::o;37749:168::-;;37866:6;37861:3;37854:19;37906:4;37901:3;37897:14;37882:29;;37844:73;;;;:::o;37923:169::-;;38041:6;38036:3;38029:19;38081:4;38076:3;38072:14;38057:29;;38019:73;;;;:::o;38098:148::-;;38237:3;38222:18;;38212:34;;;;:::o;38252:305::-;;38311:20;38329:1;38311:20;:::i;:::-;38306:25;;38345:20;38363:1;38345:20;:::i;:::-;38340:25;;38499:1;38431:66;38427:74;38424:1;38421:81;38418:2;;;38505:18;;:::i;:::-;38418:2;38549:1;38546;38542:9;38535:16;;38296:261;;;;:::o;38563:185::-;;38620:20;38638:1;38620:20;:::i;:::-;38615:25;;38654:20;38672:1;38654:20;:::i;:::-;38649:25;;38693:1;38683:2;;38698:18;;:::i;:::-;38683:2;38740:1;38737;38733:9;38728:14;;38605:143;;;;:::o;38754:348::-;;38817:20;38835:1;38817:20;:::i;:::-;38812:25;;38851:20;38869:1;38851:20;:::i;:::-;38846:25;;39039:1;38971:66;38967:74;38964:1;38961:81;38956:1;38949:9;38942:17;38938:105;38935:2;;;39046:18;;:::i;:::-;38935:2;39094:1;39091;39087:9;39076:20;;38802:300;;;;:::o;39108:191::-;;39168:20;39186:1;39168:20;:::i;:::-;39163:25;;39202:20;39220:1;39202:20;:::i;:::-;39197:25;;39241:1;39238;39235:8;39232:2;;;39246:18;;:::i;:::-;39232:2;39291:1;39288;39284:9;39276:17;;39153:146;;;;:::o;39305:96::-;;39371:24;39389:5;39371:24;:::i;:::-;39360:35;;39350:51;;;:::o;39407:90::-;;39484:5;39477:13;39470:21;39459:32;;39449:48;;;:::o;39503:149::-;;39579:66;39572:5;39568:78;39557:89;;39547:105;;;:::o;39658:141::-;;39739:5;39728:16;;39745:48;39787:5;39745:48;:::i;:::-;39718:81;;;:::o;39805:126::-;;39882:42;39875:5;39871:54;39860:65;;39850:81;;;:::o;39937:77::-;;40003:5;39992:16;;39982:32;;;:::o;40020:141::-;;40116:39;40149:5;40116:39;:::i;:::-;40103:52;;40093:68;;;:::o;40167:154::-;40251:6;40246:3;40241;40228:30;40313:1;40304:6;40299:3;40295:16;40288:27;40218:103;;;:::o;40327:307::-;40395:1;40405:113;40419:6;40416:1;40413:13;40405:113;;;40504:1;40499:3;40495:11;40489:18;40485:1;40480:3;40476:11;40469:39;40441:2;40438:1;40434:10;40429:15;;40405:113;;;40536:6;40533:1;40530:13;40527:2;;;40616:1;40607:6;40602:3;40598:16;40591:27;40527:2;40376:258;;;;:::o;40640:320::-;;40721:1;40715:4;40711:12;40701:22;;40768:1;40762:4;40758:12;40789:18;40779:2;;40845:4;40837:6;40833:17;40823:27;;40779:2;40907;40899:6;40896:14;40876:18;40873:38;40870:2;;;40926:18;;:::i;:::-;40870:2;40691:269;;;;:::o;40966:233::-;;41028:24;41046:5;41028:24;:::i;:::-;41019:33;;41074:66;41067:5;41064:77;41061:2;;;41144:18;;:::i;:::-;41061:2;41191:1;41184:5;41180:13;41173:20;;41009:190;;;:::o;41205:176::-;;41254:20;41272:1;41254:20;:::i;:::-;41249:25;;41288:20;41306:1;41288:20;:::i;:::-;41283:25;;41327:1;41317:2;;41332:18;;:::i;:::-;41317:2;41373:1;41370;41366:9;41361:14;;41239:142;;;;:::o;41387:180::-;41435:77;41432:1;41425:88;41532:4;41529:1;41522:15;41556:4;41553:1;41546:15;41573:180;41621:77;41618:1;41611:88;41718:4;41715:1;41708:15;41742:4;41739:1;41732:15;41759:180;41807:77;41804:1;41797:88;41904:4;41901:1;41894:15;41928:4;41925:1;41918:15;41945:180;41993:77;41990:1;41983:88;42090:4;42087:1;42080:15;42114:4;42111:1;42104:15;42131:180;42179:77;42176:1;42169:88;42276:4;42273:1;42266:15;42300:4;42297:1;42290:15;42317:102;;42409:2;42405:7;42400:2;42393:5;42389:14;42385:28;42375:38;;42365:54;;;:::o;42425:120::-;42513:1;42506:5;42503:12;42493:2;;42519:18;;:::i;:::-;42493:2;42483:62;:::o;42551:122::-;42624:24;42642:5;42624:24;:::i;:::-;42617:5;42614:35;42604:2;;42663:1;42660;42653:12;42604:2;42594:79;:::o;42679:116::-;42749:21;42764:5;42749:21;:::i;:::-;42742:5;42739:32;42729:2;;42785:1;42782;42775:12;42729:2;42719:76;:::o;42801:120::-;42873:23;42890:5;42873:23;:::i;:::-;42866:5;42863:34;42853:2;;42911:1;42908;42901:12;42853:2;42843:78;:::o;42927:122::-;43000:24;43018:5;43000:24;:::i;:::-;42993:5;42990:35;42980:2;;43039:1;43036;43029:12;42980:2;42970:79;:::o

ipfs://26b04098c43c50dbe5a08323b261f1977c8e14c4c056002c2ddde685e428c234