Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./Ownable.sol";
import "./SafeMath.sol";

contract GANMasks is Ownable, ERC721 {

    using SafeMath for uint256;

    // Provenance Hash of all GANMASKS
    string public constant PROVENANCE_HASH = "bbbe617ba4cc4a581350472f8a05cff398828e03ab5623646886652c4e01184f";

    // Maximum supply of tokens
    uint256 public constant MAX_SUPPLY = 10500;

    // Base URI to get metadata of all GAN Masks (will be changed to ipfs link after the sale)
    string internal baseURI = "https://ganmasks.com/api/";

    constructor() ERC721("GANMasks", "GM") {
    }

    /**
     * @dev Base URI for computing {tokenURI}.
     */
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    /**
     * @dev Get price of the token
     */
    function getTokenPrice() public view returns (uint256) {
        uint tokenId = totalSupply();
        require(tokenId < MAX_SUPPLY, "All tokens sold out");

        if (tokenId < 4000) {
          return 125000000000000000;
        }
        else if (tokenId < 7000) {
          return 250000000000000000;
        }
        else if (tokenId < 9000) {
          return 500000000000000000;
        }
        else {
          return 1000000000000000000;
        }
    }

    /**
     * @dev Mint a token
     */
    function mintToken(uint256 numTokens) public payable {
        require(numTokens > 0 && numTokens <= 20, "You can only mint between 1 and 20 tokens at a time");
        require(getTokenPrice().mul(numTokens) == msg.value, "Ether value sent is incorrect");

        for (uint i = 0; i < numTokens; i++) {
            uint tokenId = totalSupply() ;
            require(tokenId < MAX_SUPPLY, "Cannot mint more tokens than the maximum limit");
            _safeMint(msg.sender, tokenId);
        }
    }

    /**
     * @dev Set the Base URI of tokens
     */
    function setBaseURI(string memory baseURI_) public onlyOwner {
        baseURI = baseURI_;
    }

    /**
     * @dev Withdraw ether from the contract
     */
    function withdraw() public onlyOwner {
        payable(msg.sender).transfer(address(this).balance);
    }
}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./EnumerableSet.sol";

/**
 * @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 {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // 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 Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;

        mapping (bytes32 => bytes32) _values;
    }

    /**
     * @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) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @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) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @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._keys.contains(key);
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._keys.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) {
        bytes32 key = map._keys.at(index);
        return (key, map._values[key]);
    }

    /**
     * @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) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (_contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @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) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    /**
     * @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) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), errorMessage);
        return value;
    }

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

// SPDX-License-Identifier: MIT

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] = valueIndex; // Replace lastvalue's index to valueIndex

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./IERC721Enumerable.sol";
import "./EnumerableMap.sol";
import "./EnumerableSet.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using Strings for uint256;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using EnumerableSet for EnumerableSet.UintSet;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Enumerable mapping from token ID to owner address
    EnumerableMap.UintToAddressMap private _tokenOwners;

    // Mapping from owner to (enumerable) set of owned token IDs
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

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

    /**
     * @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_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC721).interfaceId
            || interfaceId == type(IERC721Metadata).interfaceId
            || super.supportsInterface(interfaceId);
    }

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

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

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

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _tokenOwners.length();
    }

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

    /**
     * @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 baseURI = _baseURI();
        return bytes(baseURI).length > 0
            ? string(abi.encodePacked(baseURI, tokenId.toString()))
            : '';
    }

    /**
     * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
     * in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @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 || 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 || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `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 Mints `tokenId` and transfers it to `to` owner.
     *
     * 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 _mintWithoutEmiting(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);

    }

    /**
     * @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);

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

        // Clear approvals
        _approve(address(0), 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");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @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;
        }
    }

    /**
     * @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 { }
}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @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;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

contract Migrations {
  address public owner = msg.sender;
  uint public last_completed_migration;

  modifier restricted() {
    require(
      msg.sender == owner,
      "This function is restricted to the contract's owner"
    );
    _;
  }

  function setCompleted(uint completed) public restricted {
    last_completed_migration = completed;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";
/**
 * @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);
    }

}

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PROVENANCE_HASH","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numTokens","type":"uint256"}],"name":"mintToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"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":[],"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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

131:2080:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1718:288:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3219:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4631:217;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4182:388;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2817:107;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5495:300;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2594:152;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;393:42:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2104:105;;;;;;;;;;;;;:::i;:::-;;5861:149:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;867:467:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2996:161:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1941:96:6;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2340:175:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2065:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1693:145:13;;;;;;;;;;;;;:::i;:::-;;1061:85;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3381:102:3;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4915:290;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6076:282;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1381:499:6;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3549:353:3;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5271:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;247:107:6;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1718:288:3;1820:4;1858:25;1843:40;;;:11;:40;;;;:104;;;;1914:33;1899:48;;;:11;:48;;;;1843:104;:156;;;;1963:36;1987:11;1963:23;:36::i;:::-;1843:156;1836:163;;1718:288;;;:::o;3219:98::-;3273:13;3305:5;3298:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3219:98;:::o;4631:217::-;4707:7;4734:16;4742:7;4734;:16::i;:::-;4726:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;4817:15;:24;4833:7;4817:24;;;;;;;;;;;;;;;;;;;;;4810:31;;4631:217;;;:::o;4182:388::-;4262:13;4278:23;4293:7;4278:14;:23::i;:::-;4262:39;;4325:5;4319:11;;:2;:11;;;;4311:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;4403:5;4387:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;4412:37;4429:5;4436:12;:10;:12::i;:::-;4412:16;:37::i;:::-;4387:62;4379:152;;;;;;;;;;;;:::i;:::-;;;;;;;;;4542:21;4551:2;4555:7;4542:8;:21::i;:::-;4182:388;;;:::o;2817:107::-;2870:7;2896:21;:12;:19;:21::i;:::-;2889:28;;2817:107;:::o;5495:300::-;5654:41;5673:12;:10;:12::i;:::-;5687:7;5654:18;:41::i;:::-;5646:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;5760:28;5770:4;5776:2;5780:7;5760:9;:28::i;:::-;5495:300;;;:::o;2594:152::-;2683:7;2709:30;2733:5;2709:13;:20;2723:5;2709:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;2702:37;;2594:152;;;;:::o;393:42:6:-;430:5;393:42;:::o;2104:105::-;1284:12:13;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2159:10:6::1;2151:28;;:51;2180:21;2151:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;2104:105::o:0;5861:149:3:-;5964:39;5981:4;5987:2;5991:7;5964:39;;;;;;;;;;;;:16;:39::i;:::-;5861:149;;;:::o;867:467:6:-;913:7;932:12;947:13;:11;:13::i;:::-;932:28;;430:5;978:7;:20;970:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;1047:4;1037:7;:14;1033:295;;;1072:18;1065:25;;;;;1033:295;1129:4;1119:7;:14;1115:213;;;1154:18;1147:25;;;;;1115:213;1211:4;1201:7;:14;1197:131;;;1236:18;1229:25;;;;;1197:131;1298:19;1291:26;;;867:467;;:::o;2996:161:3:-;3063:7;3083:15;3104:22;3120:5;3104:12;:15;;:22;;;;:::i;:::-;3082:44;;;3143:7;3136:14;;;2996:161;;;:::o;1941:96:6:-;1284:12:13;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2022:8:6::1;2012:7;:18;;;;;;;;;;;;:::i;:::-;;1941:96:::0;:::o;2340:175:3:-;2412:7;2438:70;2455:7;2438:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;2431:77;;2340:175;;;:::o;2065:218::-;2137:7;2181:1;2164:19;;:5;:19;;;;2156:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;2247:29;:13;:20;2261:5;2247:20;;;;;;;;;;;;;;;:27;:29::i;:::-;2240:36;;2065:218;;;:::o;1693:145:13:-;1284:12;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1799:1:::1;1762:40;;1783:6;::::0;::::1;;;;;;;;1762:40;;;;;;;;;;;;1829:1;1812:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;1693:145::o:0;1061:85::-;1107:7;1133:6;;;;;;;;;;;1126:13;;1061:85;:::o;3381:102:3:-;3437:13;3469:7;3462:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3381:102;:::o;4915:290::-;5029:12;:10;:12::i;:::-;5017:24;;:8;:24;;;;5009:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;5127:8;5082:18;:32;5101:12;:10;:12::i;:::-;5082:32;;;;;;;;;;;;;;;:42;5115:8;5082:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;5179:8;5150:48;;5165:12;:10;:12::i;:::-;5150:48;;;5189:8;5150:48;;;;;;:::i;:::-;;;;;;;;4915:290;;:::o;6076:282::-;6207:41;6226:12;:10;:12::i;:::-;6240:7;6207:18;:41::i;:::-;6199:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;6312:39;6326:4;6332:2;6336:7;6345:5;6312:13;:39::i;:::-;6076:282;;;;:::o;1381:499:6:-;1464:1;1452:9;:13;:32;;;;;1482:2;1469:9;:15;;1452:32;1444:96;;;;;;;;;;;;:::i;:::-;;;;;;;;;1592:9;1558:30;1578:9;1558:15;:13;:15::i;:::-;:19;;:30;;;;:::i;:::-;:43;1550:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;1651:6;1646:228;1667:9;1663:1;:13;1646:228;;;1697:12;1712:13;:11;:13::i;:::-;1697:28;;430:5;1748:7;:20;1740:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;1833:30;1843:10;1855:7;1833:9;:30::i;:::-;1646:228;1678:3;;;;;:::i;:::-;;;;1646:228;;;;1381:499;:::o;3549:353:3:-;3622:13;3655:16;3663:7;3655;:16::i;:::-;3647:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;3734:21;3758:10;:8;:10::i;:::-;3734:34;;3809:1;3791:7;3785:21;:25;:110;;;;;;;;;;;;;;;;;3849:7;3858:18;:7;:16;:18::i;:::-;3832:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3785:110;3778:117;;;3549:353;;;:::o;5271:162::-;5368:4;5391:18;:25;5410:5;5391:25;;;;;;;;;;;;;;;:35;5417:8;5391:35;;;;;;;;;;;;;;;;;;;;;;;;;5384:42;;5271:162;;;;:::o;247:107:6:-;;;;;;;;;;;;;;;;;;;:::o;763:155:2:-;848:4;886:25;871:40;;;:11;:40;;;;864:47;;763:155;;;:::o;7792:125:3:-;7857:4;7880:30;7902:7;7880:12;:21;;:30;;;;:::i;:::-;7873:37;;7792:125;;;:::o;586:96:1:-;639:7;665:10;658:17;;586:96;:::o;12310:171:3:-;12411:2;12384:15;:24;12400:7;12384:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;12466:7;12462:2;12428:46;;12437:23;12452:7;12437:14;:23::i;:::-;12428:46;;;;;;;;;;;;12310:171;;:::o;5520:121:4:-;5589:7;5615:19;5623:3;:10;;5615:7;:19::i;:::-;5608:26;;5520:121;;;:::o;8075:344:3:-;8168:4;8192:16;8200:7;8192;:16::i;:::-;8184:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;8267:13;8283:23;8298:7;8283:14;:23::i;:::-;8267:39;;8335:5;8324:16;;:7;:16;;;:51;;;;8368:7;8344:31;;:20;8356:7;8344:11;:20::i;:::-;:31;;;8324:51;:87;;;;8379:32;8396:5;8403:7;8379:16;:32::i;:::-;8324:87;8316:96;;;8075:344;;;;:::o;11634:565::-;11758:4;11731:31;;:23;11746:7;11731:14;:23::i;:::-;:31;;;11723:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;11840:1;11826:16;;:2;:16;;;;11818:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;11894:39;11915:4;11921:2;11925:7;11894:20;:39::i;:::-;11995:29;12012:1;12016:7;11995:8;:29::i;:::-;12035:35;12062:7;12035:13;:19;12049:4;12035:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;12080:30;12102:7;12080:13;:17;12094:2;12080:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;12120:29;12137:7;12146:2;12120:12;:16;;:29;;;;;:::i;:::-;;12184:7;12180:2;12165:27;;12174:4;12165:27;;;;;;;;;;;;11634:565;;;:::o;9251:135:5:-;9322:7;9356:22;9360:3;:10;;9372:5;9356:3;:22::i;:::-;9348:31;;9341:38;;9251:135;;;;:::o;5969:233:4:-;6049:7;6058;6078:11;6091:13;6108:22;6112:3;:10;;6124:5;6108:3;:22::i;:::-;6077:53;;;;6156:3;6148:12;;6186:5;6178:14;;6140:55;;;;;;5969:233;;;;;:::o;7222:211::-;7329:7;7379:44;7384:3;:10;;7404:3;7396:12;;7410;7379:4;:44::i;:::-;7371:53;;7348:78;;7222:211;;;;;:::o;8807:112:5:-;8867:7;8893:19;8901:3;:10;;8893:7;:19::i;:::-;8886:26;;8807:112;;;:::o;7220:269:3:-;7333:28;7343:4;7349:2;7353:7;7333:9;:28::i;:::-;7379:48;7402:4;7408:2;7412:7;7421:5;7379:22;:48::i;:::-;7371:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;7220:269;;;;:::o;3382:96:14:-;3440:7;3470:1;3466;:5;;;;:::i;:::-;3459:12;;3382:96;;;;:::o;8749:108:3:-;8824:26;8834:2;8838:7;8824:26;;;;;;;;;;;;:9;:26::i;:::-;8749:108;;:::o;712:98:6:-;764:13;796:7;789:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;712:98;:::o;271:703:15:-;327:13;553:1;544:5;:10;540:51;;;570:10;;;;;;;;;;;;;;;;;;;;;540:51;600:12;615:5;600:20;;630:14;654:75;669:1;661:4;:9;654:75;;686:8;;;;;:::i;:::-;;;;716:2;708:10;;;;;:::i;:::-;;;654:75;;;738:19;770:6;760:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;738:39;;787:150;803:1;794:5;:10;787:150;;830:1;820:11;;;;;:::i;:::-;;;896:2;888:5;:10;;;;:::i;:::-;875:2;:24;;;;:::i;:::-;862:39;;845:6;852;845:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;924:2;915:11;;;;;:::i;:::-;;;787:150;;;960:6;946:21;;;;;271:703;;;;:::o;5288:149:4:-;5372:4;5395:35;5405:3;:10;;5425:3;5417:12;;5395:9;:35::i;:::-;5388:42;;5288:149;;;;:::o;2462:107::-;2518:7;2544:18;:3;:9;;:16;:18::i;:::-;2537:25;;2462:107;;;:::o;14454:93:3:-;;;;:::o;8366:135:5:-;8436:4;8459:35;8467:3;:10;;8487:5;8479:14;;8459:7;:35::i;:::-;8452:42;;8366:135;;;;:::o;8069:129::-;8136:4;8159:32;8164:3;:10;;8184:5;8176:14;;8159:4;:32::i;:::-;8152:39;;8069:129;;;;:::o;4727:183:4:-;4816:4;4839:64;4844:3;:10;;4864:3;4856:12;;4894:5;4878:23;;4870:32;;4839:4;:64::i;:::-;4832:71;;4727:183;;;;;:::o;4453:201:5:-;4520:7;4568:5;4547:3;:11;;:18;;;;:26;4539:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;4629:3;:11;;4641:5;4629:18;;;;;;;;;;;;;;;;;;;;;;;;4622:25;;4453:201;;;;:::o;2912:175:4:-;2979:7;2988;3007:11;3021:19;3034:5;3021:3;:9;;:12;;:19;;;;:::i;:::-;3007:33;;3058:3;3063;:11;;:16;3075:3;3063:16;;;;;;;;;;;;3050:30;;;;;2912:175;;;;;:::o;4178:240::-;4272:7;4291:13;4307:3;:11;;:16;4319:3;4307:16;;;;;;;;;;;;4291:32;;4350:1;4341:10;;:5;:10;;:33;;;;4355:19;4365:3;4370;4355:9;:19::i;:::-;4341:33;4376:12;4333:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;4406:5;4399:12;;;4178:240;;;;;:::o;4014:107:5:-;4070:7;4096:3;:11;;:18;;;;4089:25;;4014:107;;;:::o;13034:824:3:-;13154:4;13178:15;:2;:13;;;:15::i;:::-;13174:678;;;13229:2;13213:36;;;13250:12;:10;:12::i;:::-;13264:4;13270:7;13279:5;13213:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;13209:591;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13473:1;13456:6;:13;:18;13452:334;;;13498:60;;;;;;;;;;:::i;:::-;;;;;;;;13452:334;13738:6;13732:13;13723:6;13719:2;13715:15;13708:38;13209:591;13345:45;;;13335:55;;;:6;:55;;;;13328:62;;;;;13174:678;13837:4;13830:11;;13034:824;;;;;;;:::o;9078:247::-;9173:18;9179:2;9183:7;9173:5;:18::i;:::-;9209:54;9240:1;9244:2;9248:7;9257:5;9209:22;:54::i;:::-;9201:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;9078:247;;;:::o;2248:124:4:-;2319:4;2342:23;2361:3;2342;:9;;:18;;:23;;;;:::i;:::-;2335:30;;2248:124;;;;:::o;5614:115:5:-;5677:7;5703:19;5711:3;:10;;5703:7;:19::i;:::-;5696:26;;5614:115;;;:::o;2204:1521::-;2270:4;2386:18;2407:3;:12;;:19;2420:5;2407:19;;;;;;;;;;;;2386:40;;2455:1;2441:10;:15;2437:1282;;2798:21;2835:1;2822:10;:14;;;;:::i;:::-;2798:38;;2850:17;2891:1;2870:3;:11;;:18;;;;:22;;;;:::i;:::-;2850:42;;3132:17;3152:3;:11;;3164:9;3152:22;;;;;;;;;;;;;;;;;;;;;;;;3132:42;;3295:9;3266:3;:11;;3278:13;3266:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;3396:10;3370:3;:12;;:23;3383:9;3370:23;;;;;;;;;;;:36;;;;3528:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3620:3;:12;;:19;3633:5;3620:19;;;;;;;;;;;3613:26;;;3661:4;3654:11;;;;;;;;2437:1282;3703:5;3696:12;;;2204:1521;;;;;:::o;1632:404::-;1695:4;1716:21;1726:3;1731:5;1716:9;:21::i;:::-;1711:319;;1753:3;:11;;1770:5;1753:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1933:3;:11;;:18;;;;1911:3;:12;;:19;1924:5;1911:19;;;;;;;;;;;:40;;;;1972:4;1965:11;;;;1711:319;2014:5;2007:12;;1632:404;;;;;:::o;1695:158:4:-;1771:4;1806:5;1787:3;:11;;:16;1799:3;1787:16;;;;;;;;;;;:24;;;;1828:18;1842:3;1828;:9;;:13;;:18;;;;:::i;:::-;1821:25;;1695:158;;;;;:::o;6061:129:5:-;6135:7;6161:22;6165:3;:10;;6177:5;6161:3;:22::i;:::-;6154:29;;6061:129;;;;:::o;718:413:0:-;778:4;981:12;1090:7;1078:20;1070:28;;1123:1;1116:4;:8;1109:15;;;718:413;;;:::o;9647:392:3:-;9740:1;9726:16;;:2;:16;;;;9718:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;9798:16;9806:7;9798;:16::i;:::-;9797:17;9789:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9858:45;9887:1;9891:2;9895:7;9858:20;:45::i;:::-;9914:30;9936:7;9914:13;:17;9928:2;9914:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;9954:29;9971:7;9980:2;9954:12;:16;;:29;;;;;:::i;:::-;;10024:7;10020:2;9999:33;;10016:1;9999:33;;;;;;;;;;;;9647:392;;:::o;5395:138:5:-;5475:4;5498:28;5508:3;:10;;5520:5;5498:9;:28::i;:::-;5491:35;;5395:138;;;;:::o;3806:127::-;3879:4;3925:1;3902:3;:12;;:19;3915:5;3902:19;;;;;;;;;;;;:24;;3895:31;;3806:127;;;;:::o;4894:123::-;4964:4;4987:23;4992:3;:10;;5004:5;4987:4;:23::i;:::-;4980:30;;4894:123;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:16:-;;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;;1074:6;1061:20;1052:29;;1090:32;1116:5;1090:32;:::i;:::-;1042:86;;;;:::o;1134:141::-;;1221:6;1215:13;1206:22;;1237:32;1263:5;1237:32;:::i;:::-;1196:79;;;;:::o;1294:271::-;;1398:3;1391:4;1383:6;1379:17;1375:27;1365:2;;1416:1;1413;1406:12;1365:2;1456:6;1443:20;1481:78;1555:3;1547:6;1540:4;1532:6;1528:17;1481:78;:::i;:::-;1472:87;;1355:210;;;;;:::o;1585:273::-;;1690:3;1683:4;1675:6;1671:17;1667:27;1657:2;;1708:1;1705;1698:12;1657:2;1748:6;1735:20;1773:79;1848:3;1840:6;1833:4;1825:6;1821:17;1773:79;:::i;:::-;1764:88;;1647:211;;;;;:::o;1864:139::-;;1948:6;1935:20;1926:29;;1964:33;1991:5;1964:33;:::i;:::-;1916:87;;;;:::o;2009:262::-;;2117:2;2105:9;2096:7;2092:23;2088:32;2085:2;;;2133:1;2130;2123:12;2085:2;2176:1;2201:53;2246:7;2237:6;2226:9;2222:22;2201:53;:::i;:::-;2191:63;;2147:117;2075:196;;;;:::o;2277:407::-;;;2402:2;2390:9;2381:7;2377:23;2373:32;2370:2;;;2418:1;2415;2408:12;2370:2;2461:1;2486:53;2531:7;2522:6;2511:9;2507:22;2486:53;:::i;:::-;2476:63;;2432:117;2588:2;2614:53;2659:7;2650:6;2639:9;2635:22;2614:53;:::i;:::-;2604:63;;2559:118;2360:324;;;;;:::o;2690:552::-;;;;2832:2;2820:9;2811:7;2807:23;2803:32;2800:2;;;2848:1;2845;2838:12;2800:2;2891:1;2916:53;2961:7;2952:6;2941:9;2937:22;2916:53;:::i;:::-;2906:63;;2862:117;3018:2;3044:53;3089:7;3080:6;3069:9;3065:22;3044:53;:::i;:::-;3034:63;;2989:118;3146:2;3172:53;3217:7;3208:6;3197:9;3193:22;3172:53;:::i;:::-;3162:63;;3117:118;2790:452;;;;;:::o;3248:809::-;;;;;3416:3;3404:9;3395:7;3391:23;3387:33;3384:2;;;3433:1;3430;3423:12;3384:2;3476:1;3501:53;3546:7;3537:6;3526:9;3522:22;3501:53;:::i;:::-;3491:63;;3447:117;3603:2;3629:53;3674:7;3665:6;3654:9;3650:22;3629:53;:::i;:::-;3619:63;;3574:118;3731:2;3757:53;3802:7;3793:6;3782:9;3778:22;3757:53;:::i;:::-;3747:63;;3702:118;3887:2;3876:9;3872:18;3859:32;3918:18;3910:6;3907:30;3904:2;;;3950:1;3947;3940:12;3904:2;3978:62;4032:7;4023:6;4012:9;4008:22;3978:62;:::i;:::-;3968:72;;3830:220;3374:683;;;;;;;:::o;4063:401::-;;;4185:2;4173:9;4164:7;4160:23;4156:32;4153:2;;;4201:1;4198;4191:12;4153:2;4244:1;4269:53;4314:7;4305:6;4294:9;4290:22;4269:53;:::i;:::-;4259:63;;4215:117;4371:2;4397:50;4439:7;4430:6;4419:9;4415:22;4397:50;:::i;:::-;4387:60;;4342:115;4143:321;;;;;:::o;4470:407::-;;;4595:2;4583:9;4574:7;4570:23;4566:32;4563:2;;;4611:1;4608;4601:12;4563:2;4654:1;4679:53;4724:7;4715:6;4704:9;4700:22;4679:53;:::i;:::-;4669:63;;4625:117;4781:2;4807:53;4852:7;4843:6;4832:9;4828:22;4807:53;:::i;:::-;4797:63;;4752:118;4553:324;;;;;:::o;4883:260::-;;4990:2;4978:9;4969:7;4965:23;4961:32;4958:2;;;5006:1;5003;4996:12;4958:2;5049:1;5074:52;5118:7;5109:6;5098:9;5094:22;5074:52;:::i;:::-;5064:62;;5020:116;4948:195;;;;:::o;5149:282::-;;5267:2;5255:9;5246:7;5242:23;5238:32;5235:2;;;5283:1;5280;5273:12;5235:2;5326:1;5351:63;5406:7;5397:6;5386:9;5382:22;5351:63;:::i;:::-;5341:73;;5297:127;5225:206;;;;:::o;5437:375::-;;5555:2;5543:9;5534:7;5530:23;5526:32;5523:2;;;5571:1;5568;5561:12;5523:2;5642:1;5631:9;5627:17;5614:31;5672:18;5664:6;5661:30;5658:2;;;5704:1;5701;5694:12;5658:2;5732:63;5787:7;5778:6;5767:9;5763:22;5732:63;:::i;:::-;5722:73;;5585:220;5513:299;;;;:::o;5818:262::-;;5926:2;5914:9;5905:7;5901:23;5897:32;5894:2;;;5942:1;5939;5932:12;5894:2;5985:1;6010:53;6055:7;6046:6;6035:9;6031:22;6010:53;:::i;:::-;6000:63;;5956:117;5884:196;;;;:::o;6086:118::-;6173:24;6191:5;6173:24;:::i;:::-;6168:3;6161:37;6151:53;;:::o;6210:109::-;6291:21;6306:5;6291:21;:::i;:::-;6286:3;6279:34;6269:50;;:::o;6325:360::-;;6439:38;6471:5;6439:38;:::i;:::-;6493:70;6556:6;6551:3;6493:70;:::i;:::-;6486:77;;6572:52;6617:6;6612:3;6605:4;6598:5;6594:16;6572:52;:::i;:::-;6649:29;6671:6;6649:29;:::i;:::-;6644:3;6640:39;6633:46;;6415:270;;;;;:::o;6691:364::-;;6807:39;6840:5;6807:39;:::i;:::-;6862:71;6926:6;6921:3;6862:71;:::i;:::-;6855:78;;6942:52;6987:6;6982:3;6975:4;6968:5;6964:16;6942:52;:::i;:::-;7019:29;7041:6;7019:29;:::i;:::-;7014:3;7010:39;7003:46;;6783:272;;;;;:::o;7061:377::-;;7195:39;7228:5;7195:39;:::i;:::-;7250:89;7332:6;7327:3;7250:89;:::i;:::-;7243:96;;7348:52;7393:6;7388:3;7381:4;7374:5;7370:16;7348:52;:::i;:::-;7425:6;7420:3;7416:16;7409:23;;7171:267;;;;;:::o;7444:366::-;;7607:67;7671:2;7666:3;7607:67;:::i;:::-;7600:74;;7683:93;7772:3;7683:93;:::i;:::-;7801:2;7796:3;7792:12;7785:19;;7590:220;;;:::o;7816:366::-;;7979:67;8043:2;8038:3;7979:67;:::i;:::-;7972:74;;8055:93;8144:3;8055:93;:::i;:::-;8173:2;8168:3;8164:12;8157:19;;7962:220;;;:::o;8188:366::-;;8351:67;8415:2;8410:3;8351:67;:::i;:::-;8344:74;;8427:93;8516:3;8427:93;:::i;:::-;8545:2;8540:3;8536:12;8529:19;;8334:220;;;:::o;8560:366::-;;8723:67;8787:2;8782:3;8723:67;:::i;:::-;8716:74;;8799:93;8888:3;8799:93;:::i;:::-;8917:2;8912:3;8908:12;8901:19;;8706:220;;;:::o;8932:366::-;;9095:67;9159:2;9154:3;9095:67;:::i;:::-;9088:74;;9171:93;9260:3;9171:93;:::i;:::-;9289:2;9284:3;9280:12;9273:19;;9078:220;;;:::o;9304:366::-;;9467:67;9531:2;9526:3;9467:67;:::i;:::-;9460:74;;9543:93;9632:3;9543:93;:::i;:::-;9661:2;9656:3;9652:12;9645:19;;9450:220;;;:::o;9676:366::-;;9839:67;9903:2;9898:3;9839:67;:::i;:::-;9832:74;;9915:93;10004:3;9915:93;:::i;:::-;10033:2;10028:3;10024:12;10017:19;;9822:220;;;:::o;10048:366::-;;10211:67;10275:2;10270:3;10211:67;:::i;:::-;10204:74;;10287:93;10376:3;10287:93;:::i;:::-;10405:2;10400:3;10396:12;10389:19;;10194:220;;;:::o;10420:366::-;;10583:67;10647:2;10642:3;10583:67;:::i;:::-;10576:74;;10659:93;10748:3;10659:93;:::i;:::-;10777:2;10772:3;10768:12;10761:19;;10566:220;;;:::o;10792:366::-;;10955:67;11019:2;11014:3;10955:67;:::i;:::-;10948:74;;11031:93;11120:3;11031:93;:::i;:::-;11149:2;11144:3;11140:12;11133:19;;10938:220;;;:::o;11164:366::-;;11327:67;11391:2;11386:3;11327:67;:::i;:::-;11320:74;;11403:93;11492:3;11403:93;:::i;:::-;11521:2;11516:3;11512:12;11505:19;;11310:220;;;:::o;11536:366::-;;11699:67;11763:2;11758:3;11699:67;:::i;:::-;11692:74;;11775:93;11864:3;11775:93;:::i;:::-;11893:2;11888:3;11884:12;11877:19;;11682:220;;;:::o;11908:366::-;;12071:67;12135:2;12130:3;12071:67;:::i;:::-;12064:74;;12147:93;12236:3;12147:93;:::i;:::-;12265:2;12260:3;12256:12;12249:19;;12054:220;;;:::o;12280:366::-;;12443:67;12507:2;12502:3;12443:67;:::i;:::-;12436:74;;12519:93;12608:3;12519:93;:::i;:::-;12637:2;12632:3;12628:12;12621:19;;12426:220;;;:::o;12652:366::-;;12815:67;12879:2;12874:3;12815:67;:::i;:::-;12808:74;;12891:93;12980:3;12891:93;:::i;:::-;13009:2;13004:3;13000:12;12993:19;;12798:220;;;:::o;13024:366::-;;13187:67;13251:2;13246:3;13187:67;:::i;:::-;13180:74;;13263:93;13352:3;13263:93;:::i;:::-;13381:2;13376:3;13372:12;13365:19;;13170:220;;;:::o;13396:366::-;;13559:67;13623:2;13618:3;13559:67;:::i;:::-;13552:74;;13635:93;13724:3;13635:93;:::i;:::-;13753:2;13748:3;13744:12;13737:19;;13542:220;;;:::o;13768:366::-;;13931:67;13995:2;13990:3;13931:67;:::i;:::-;13924:74;;14007:93;14096:3;14007:93;:::i;:::-;14125:2;14120:3;14116:12;14109:19;;13914:220;;;:::o;14140:366::-;;14303:67;14367:2;14362:3;14303:67;:::i;:::-;14296:74;;14379:93;14468:3;14379:93;:::i;:::-;14497:2;14492:3;14488:12;14481:19;;14286:220;;;:::o;14512:118::-;14599:24;14617:5;14599:24;:::i;:::-;14594:3;14587:37;14577:53;;:::o;14636:435::-;;14838:95;14929:3;14920:6;14838:95;:::i;:::-;14831:102;;14950:95;15041:3;15032:6;14950:95;:::i;:::-;14943:102;;15062:3;15055:10;;14820:251;;;;;:::o;15077:222::-;;15208:2;15197:9;15193:18;15185:26;;15221:71;15289:1;15278:9;15274:17;15265:6;15221:71;:::i;:::-;15175:124;;;;:::o;15305:640::-;;15538:3;15527:9;15523:19;15515:27;;15552:71;15620:1;15609:9;15605:17;15596:6;15552:71;:::i;:::-;15633:72;15701:2;15690:9;15686:18;15677:6;15633:72;:::i;:::-;15715;15783:2;15772:9;15768:18;15759:6;15715:72;:::i;:::-;15834:9;15828:4;15824:20;15819:2;15808:9;15804:18;15797:48;15862:76;15933:4;15924:6;15862:76;:::i;:::-;15854:84;;15505:440;;;;;;;:::o;15951:210::-;;16076:2;16065:9;16061:18;16053:26;;16089:65;16151:1;16140:9;16136:17;16127:6;16089:65;:::i;:::-;16043:118;;;;:::o;16167:313::-;;16318:2;16307:9;16303:18;16295:26;;16367:9;16361:4;16357:20;16353:1;16342:9;16338:17;16331:47;16395:78;16468:4;16459:6;16395:78;:::i;:::-;16387:86;;16285:195;;;;:::o;16486:419::-;;16690:2;16679:9;16675:18;16667:26;;16739:9;16733:4;16729:20;16725:1;16714:9;16710:17;16703:47;16767:131;16893:4;16767:131;:::i;:::-;16759:139;;16657:248;;;:::o;16911:419::-;;17115:2;17104:9;17100:18;17092:26;;17164:9;17158:4;17154:20;17150:1;17139:9;17135:17;17128:47;17192:131;17318:4;17192:131;:::i;:::-;17184:139;;17082:248;;;:::o;17336:419::-;;17540:2;17529:9;17525:18;17517:26;;17589:9;17583:4;17579:20;17575:1;17564:9;17560:17;17553:47;17617:131;17743:4;17617:131;:::i;:::-;17609:139;;17507:248;;;:::o;17761:419::-;;17965:2;17954:9;17950:18;17942:26;;18014:9;18008:4;18004:20;18000:1;17989:9;17985:17;17978:47;18042:131;18168:4;18042:131;:::i;:::-;18034:139;;17932:248;;;:::o;18186:419::-;;18390:2;18379:9;18375:18;18367:26;;18439:9;18433:4;18429:20;18425:1;18414:9;18410:17;18403:47;18467:131;18593:4;18467:131;:::i;:::-;18459:139;;18357:248;;;:::o;18611:419::-;;18815:2;18804:9;18800:18;18792:26;;18864:9;18858:4;18854:20;18850:1;18839:9;18835:17;18828:47;18892:131;19018:4;18892:131;:::i;:::-;18884:139;;18782:248;;;:::o;19036:419::-;;19240:2;19229:9;19225:18;19217:26;;19289:9;19283:4;19279:20;19275:1;19264:9;19260:17;19253:47;19317:131;19443:4;19317:131;:::i;:::-;19309:139;;19207:248;;;:::o;19461:419::-;;19665:2;19654:9;19650:18;19642:26;;19714:9;19708:4;19704:20;19700:1;19689:9;19685:17;19678:47;19742:131;19868:4;19742:131;:::i;:::-;19734:139;;19632:248;;;:::o;19886:419::-;;20090:2;20079:9;20075:18;20067:26;;20139:9;20133:4;20129:20;20125:1;20114:9;20110:17;20103:47;20167:131;20293:4;20167:131;:::i;:::-;20159:139;;20057:248;;;:::o;20311:419::-;;20515:2;20504:9;20500:18;20492:26;;20564:9;20558:4;20554:20;20550:1;20539:9;20535:17;20528:47;20592:131;20718:4;20592:131;:::i;:::-;20584:139;;20482:248;;;:::o;20736:419::-;;20940:2;20929:9;20925:18;20917:26;;20989:9;20983:4;20979:20;20975:1;20964:9;20960:17;20953:47;21017:131;21143:4;21017:131;:::i;:::-;21009:139;;20907:248;;;:::o;21161:419::-;;21365:2;21354:9;21350:18;21342:26;;21414:9;21408:4;21404:20;21400:1;21389:9;21385:17;21378:47;21442:131;21568:4;21442:131;:::i;:::-;21434:139;;21332:248;;;:::o;21586:419::-;;21790:2;21779:9;21775:18;21767:26;;21839:9;21833:4;21829:20;21825:1;21814:9;21810:17;21803:47;21867:131;21993:4;21867:131;:::i;:::-;21859:139;;21757:248;;;:::o;22011:419::-;;22215:2;22204:9;22200:18;22192:26;;22264:9;22258:4;22254:20;22250:1;22239:9;22235:17;22228:47;22292:131;22418:4;22292:131;:::i;:::-;22284:139;;22182:248;;;:::o;22436:419::-;;22640:2;22629:9;22625:18;22617:26;;22689:9;22683:4;22679:20;22675:1;22664:9;22660:17;22653:47;22717:131;22843:4;22717:131;:::i;:::-;22709:139;;22607:248;;;:::o;22861:419::-;;23065:2;23054:9;23050:18;23042:26;;23114:9;23108:4;23104:20;23100:1;23089:9;23085:17;23078:47;23142:131;23268:4;23142:131;:::i;:::-;23134:139;;23032:248;;;:::o;23286:419::-;;23490:2;23479:9;23475:18;23467:26;;23539:9;23533:4;23529:20;23525:1;23514:9;23510:17;23503:47;23567:131;23693:4;23567:131;:::i;:::-;23559:139;;23457:248;;;:::o;23711:419::-;;23915:2;23904:9;23900:18;23892:26;;23964:9;23958:4;23954:20;23950:1;23939:9;23935:17;23928:47;23992:131;24118:4;23992:131;:::i;:::-;23984:139;;23882:248;;;:::o;24136:419::-;;24340:2;24329:9;24325:18;24317:26;;24389:9;24383:4;24379:20;24375:1;24364:9;24360:17;24353:47;24417:131;24543:4;24417:131;:::i;:::-;24409:139;;24307:248;;;:::o;24561:222::-;;24692:2;24681:9;24677:18;24669:26;;24705:71;24773:1;24762:9;24758:17;24749:6;24705:71;:::i;:::-;24659:124;;;;:::o;24789:129::-;;24850:20;;:::i;:::-;24840:30;;24879:33;24907:4;24899:6;24879:33;:::i;:::-;24830:88;;;:::o;24924:75::-;;24990:2;24984:9;24974:19;;24964:35;:::o;25005:307::-;;25156:18;25148:6;25145:30;25142:2;;;25178:18;;:::i;:::-;25142:2;25216:29;25238:6;25216:29;:::i;:::-;25208:37;;25300:4;25294;25290:15;25282:23;;25071:241;;;:::o;25318:308::-;;25470:18;25462:6;25459:30;25456:2;;;25492:18;;:::i;:::-;25456:2;25530:29;25552:6;25530:29;:::i;:::-;25522:37;;25614:4;25608;25604:15;25596:23;;25385:241;;;:::o;25632:98::-;;25717:5;25711:12;25701:22;;25690:40;;;:::o;25736:99::-;;25822:5;25816:12;25806:22;;25795:40;;;:::o;25841:168::-;;25958:6;25953:3;25946:19;25998:4;25993:3;25989:14;25974:29;;25936:73;;;;:::o;26015:169::-;;26133:6;26128:3;26121:19;26173:4;26168:3;26164:14;26149:29;;26111:73;;;;:::o;26190:148::-;;26329:3;26314:18;;26304:34;;;;:::o;26344:305::-;;26403:20;26421:1;26403:20;:::i;:::-;26398:25;;26437:20;26455:1;26437:20;:::i;:::-;26432:25;;26591:1;26523:66;26519:74;26516:1;26513:81;26510:2;;;26597:18;;:::i;:::-;26510:2;26641:1;26638;26634:9;26627:16;;26388:261;;;;:::o;26655:185::-;;26712:20;26730:1;26712:20;:::i;:::-;26707:25;;26746:20;26764:1;26746:20;:::i;:::-;26741:25;;26785:1;26775:2;;26790:18;;:::i;:::-;26775:2;26832:1;26829;26825:9;26820:14;;26697:143;;;;:::o;26846:348::-;;26909:20;26927:1;26909:20;:::i;:::-;26904:25;;26943:20;26961:1;26943:20;:::i;:::-;26938:25;;27131:1;27063:66;27059:74;27056:1;27053:81;27048:1;27041:9;27034:17;27030:105;27027:2;;;27138:18;;:::i;:::-;27027:2;27186:1;27183;27179:9;27168:20;;26894:300;;;;:::o;27200:191::-;;27260:20;27278:1;27260:20;:::i;:::-;27255:25;;27294:20;27312:1;27294:20;:::i;:::-;27289:25;;27333:1;27330;27327:8;27324:2;;;27338:18;;:::i;:::-;27324:2;27383:1;27380;27376:9;27368:17;;27245:146;;;;:::o;27397:96::-;;27463:24;27481:5;27463:24;:::i;:::-;27452:35;;27442:51;;;:::o;27499:90::-;;27576:5;27569:13;27562:21;27551:32;;27541:48;;;:::o;27595:149::-;;27671:66;27664:5;27660:78;27649:89;;27639:105;;;:::o;27750:126::-;;27827:42;27820:5;27816:54;27805:65;;27795:81;;;:::o;27882:77::-;;27948:5;27937:16;;27927:32;;;:::o;27965:154::-;28049:6;28044:3;28039;28026:30;28111:1;28102:6;28097:3;28093:16;28086:27;28016:103;;;:::o;28125:307::-;28193:1;28203:113;28217:6;28214:1;28211:13;28203:113;;;28302:1;28297:3;28293:11;28287:18;28283:1;28278:3;28274:11;28267:39;28239:2;28236:1;28232:10;28227:15;;28203:113;;;28334:6;28331:1;28328:13;28325:2;;;28414:1;28405:6;28400:3;28396:16;28389:27;28325:2;28174:258;;;;:::o;28438:320::-;;28519:1;28513:4;28509:12;28499:22;;28566:1;28560:4;28556:12;28587:18;28577:2;;28643:4;28635:6;28631:17;28621:27;;28577:2;28705;28697:6;28694:14;28674:18;28671:38;28668:2;;;28724:18;;:::i;:::-;28668:2;28489:269;;;;:::o;28764:281::-;28847:27;28869:4;28847:27;:::i;:::-;28839:6;28835:40;28977:6;28965:10;28962:22;28941:18;28929:10;28926:34;28923:62;28920:2;;;28988:18;;:::i;:::-;28920:2;29028:10;29024:2;29017:22;28807:238;;;:::o;29051:233::-;;29113:24;29131:5;29113:24;:::i;:::-;29104:33;;29159:66;29152:5;29149:77;29146:2;;;29229:18;;:::i;:::-;29146:2;29276:1;29269:5;29265:13;29258:20;;29094:190;;;:::o;29290:176::-;;29339:20;29357:1;29339:20;:::i;:::-;29334:25;;29373:20;29391:1;29373:20;:::i;:::-;29368:25;;29412:1;29402:2;;29417:18;;:::i;:::-;29402:2;29458:1;29455;29451:9;29446:14;;29324:142;;;;:::o;29472:180::-;29520:77;29517:1;29510:88;29617:4;29614:1;29607:15;29641:4;29638:1;29631:15;29658:180;29706:77;29703:1;29696:88;29803:4;29800:1;29793:15;29827:4;29824:1;29817:15;29844:180;29892:77;29889:1;29882:88;29989:4;29986:1;29979:15;30013:4;30010:1;30003:15;30030:180;30078:77;30075:1;30068:88;30175:4;30172:1;30165:15;30199:4;30196:1;30189:15;30216:102;;30308:2;30304:7;30299:2;30292:5;30288:14;30284:28;30274:38;;30264:54;;;:::o;30324:221::-;30464:34;30460:1;30452:6;30448:14;30441:58;30533:4;30528:2;30520:6;30516:15;30509:29;30430:115;:::o;30551:233::-;30691:34;30687:1;30679:6;30675:14;30668:58;30760:16;30755:2;30747:6;30743:15;30736:41;30657:127;:::o;30790:237::-;30930:34;30926:1;30918:6;30914:14;30907:58;30999:20;30994:2;30986:6;30982:15;30975:45;30896:131;:::o;31033:178::-;31173:30;31169:1;31161:6;31157:14;31150:54;31139:72;:::o;31217:179::-;31357:31;31353:1;31345:6;31341:14;31334:55;31323:73;:::o;31402:223::-;31542:34;31538:1;31530:6;31526:14;31519:58;31611:6;31606:2;31598:6;31594:15;31587:31;31508:117;:::o;31631:175::-;31771:27;31767:1;31759:6;31755:14;31748:51;31737:69;:::o;31812:231::-;31952:34;31948:1;31940:6;31936:14;31929:58;32021:14;32016:2;32008:6;32004:15;31997:39;31918:125;:::o;32049:243::-;32189:34;32185:1;32177:6;32173:14;32166:58;32258:26;32253:2;32245:6;32241:15;32234:51;32155:137;:::o;32298:229::-;32438:34;32434:1;32426:6;32422:14;32415:58;32507:12;32502:2;32494:6;32490:15;32483:37;32404:123;:::o;32533:182::-;32673:34;32669:1;32661:6;32657:14;32650:58;32639:76;:::o;32721:231::-;32861:34;32857:1;32849:6;32845:14;32838:58;32930:14;32925:2;32917:6;32913:15;32906:39;32827:125;:::o;32958:182::-;33098:34;33094:1;33086:6;33082:14;33075:58;33064:76;:::o;33146:228::-;33286:34;33282:1;33274:6;33270:14;33263:58;33355:11;33350:2;33342:6;33338:15;33331:36;33252:122;:::o;33380:234::-;33520:34;33516:1;33508:6;33504:14;33497:58;33589:17;33584:2;33576:6;33572:15;33565:42;33486:128;:::o;33620:220::-;33760:34;33756:1;33748:6;33744:14;33737:58;33829:3;33824:2;33816:6;33812:15;33805:28;33726:114;:::o;33846:236::-;33986:34;33982:1;33974:6;33970:14;33963:58;34055:19;34050:2;34042:6;34038:15;34031:44;33952:130;:::o;34088:169::-;34228:21;34224:1;34216:6;34212:14;34205:45;34194:63;:::o;34263:238::-;34403:34;34399:1;34391:6;34387:14;34380:58;34472:21;34467:2;34459:6;34455:15;34448:46;34369:132;:::o;34507:122::-;34580:24;34598:5;34580:24;:::i;:::-;34573:5;34570:35;34560:2;;34619:1;34616;34609:12;34560:2;34550:79;:::o;34635:116::-;34705:21;34720:5;34705:21;:::i;:::-;34698:5;34695:32;34685:2;;34741:1;34738;34731:12;34685:2;34675:76;:::o;34757:120::-;34829:23;34846:5;34829:23;:::i;:::-;34822:5;34819:34;34809:2;;34867:1;34864;34857:12;34809:2;34799:78;:::o;34883:122::-;34956:24;34974:5;34956:24;:::i;:::-;34949:5;34946:35;34936:2;;34995:1;34992;34985:12;34936:2;34926:79;:::o

ipfs://f7e81936074f1ab15ccee45ee8b8f89ade8ce2d94d41909acc162eceebdca6a5