Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./Ownable.sol";
import "./SafeMath.sol";
import "./Math.sol";
import "./EnumerableMap.sol";
import "./ERC721Enumerable.sol";
import "./ERC1155.sol";
import "./SafeERC20.sol";

contract HiveMind is ERC721Enumerable, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address private devAddress;

    // Max amount of token to purchase per account each time
    uint256 public MAX_PURCHASE = 20;

    // Maximum amount of tokens to supply for devs
    uint256 public DEV_TOKENS = 100;

    // Keep track of number of dev tokens that have been minted
    uint256 public numMintedDev;

    // Maximum amount of tokens to supply.
    // Max total tokens is 9900 + 100 = 10000
    uint256 public MAX_TOKENS = DEV_TOKENS + 9900;

    // Current price.
    uint256 public CURRENT_PRICE = 0.08 ether;

    // Define if sale is active
    bool public saleIsActive = false;

    // Base URI
    string private baseURI;

    /**
     * Contract constructor
     */
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {
        devAddress = msg.sender;

        // Too much gas to run here make sure to run reserve right after deploy :(
        // reserveTokens(20);
    }

    /**
     * Withdraw
     */
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(devAddress).transfer(balance);
    }

    /**
     * Reserve first tokens for devs
     */
    function reserveTokens(uint256 num) public onlyOwner {
        uint256 tokenId;
        // Too much gas to run in a single transaction to break into 40 NFTs at a time
        uint256 end_index = totalSupply() + num;

        if (numMintedDev + num > DEV_TOKENS) {
            end_index = totalSupply() + (DEV_TOKENS - numMintedDev);
            numMintedDev = DEV_TOKENS;
        } else {
            numMintedDev += num;
        }
	

        for (uint256 i = totalSupply() + 1; i <= end_index; i++) {
            tokenId = totalSupply().add(1);
            if (tokenId <= MAX_TOKENS) {
                _safeMint(msg.sender, tokenId);
            }
        }
    }

    /*
     * Set dev address
     */
    function setDevAddress(address newDevAddress) public onlyOwner {
        devAddress = newDevAddress;
    }

    /*
     * Set max tokens
     */
    function setMaxTokens(uint256 maxTokens) public onlyOwner {
        MAX_TOKENS = maxTokens;
    }

    /*
     * Pause sale if active, make active if paused
     */
    function setSaleState(bool newState) public onlyOwner {
        saleIsActive = newState;
    }

    /**
     * Mint Hive Mind NFTs
     */
    function mintHM(uint256 numberOfTokens) public payable {
        require(saleIsActive, "Minting is currently disabled");
        require(
            numberOfTokens >= 1,
            "Must mint at least one token at a time"
        );
        require(
            numberOfTokens <= MAX_PURCHASE,
            "Can only mint 20 tokens at a time"
        );
        require(
            totalSupply().add(numberOfTokens) <= MAX_TOKENS,
            "Purchase would exceed max supply of HiveMind"
        );
        require(
            CURRENT_PRICE.mul(numberOfTokens) <= msg.value,
            "Value does not match required amount"
        );

        uint256 curr_minted = totalSupply();
        for (uint256 i = 1; i <= numberOfTokens; i++) {
            _safeMint(msg.sender, curr_minted.add(i));
        }
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        super.safeTransferFrom(from, to, tokenId, "");
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        super.safeTransferFrom(from, to, tokenId, _data);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        super.transferFrom(from, to, tokenId);
    }

    /**
     * @dev Changes the base URI if we want to move things in the future (Callable by owner only)
     */
    function setBaseURI(string memory BaseURI) public onlyOwner {
        baseURI = BaseURI;
    }

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

    /**
     *
     */
    function getNumMintedDev() public view returns (uint256) {
        return numMintedDev;
    }

    /**
     * Set the current token price
     */
    function setCurrentPrice(uint256 currentPrice) public onlyOwner {
        CURRENT_PRICE = currentPrice;
    }
}

// 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 "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./IERC1155MetadataURI.sol";
import "./ERC165.sol";
import "./Address.sol";
import "./Context.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping (uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor (string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    )
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(_msgSender() != operator, "ERC1155: setting approval status for self");

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    )
        public
        virtual
        override
    {
        require(to != address(0), "ERC1155: transfer to the zero address");
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        _balances[id][from] = fromBalance - amount;
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        public
        virtual
        override
    {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            _balances[id][from] = fromBalance - amount;
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `account`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal virtual {
        require(account != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][account] += amount;
        emit TransferSingle(operator, address(0), account, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `account`
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens of token type `id`.
     */
    function _burn(address account, uint256 id, uint256 amount) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 accountBalance = _balances[id][account];
        require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
        _balances[id][account] = accountBalance - amount;

        emit TransferSingle(operator, account, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(address account, uint256[] memory ids, uint256[] memory amounts) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, account, address(0), ids, amounts, "");

        for (uint i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 accountBalance = _balances[id][account];
            require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
            _balances[id][account] = accountBalance - amount;
        }

        emit TransferBatch(operator, account, address(0), ids, amounts);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        internal
        virtual
    { }

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    )
        private
    {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver(to).onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        private
    {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
                if (response != IERC1155Receiver(to).onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}

// 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 "./ERC165.sol";
import "./Address.sol";
import "./Context.sol";
import "./String.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 {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping (uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping (address => uint256) private _balances;

    // 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 _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @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 _owners[tokenId] != address(0);
    }

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

        _balances[to] += 1;
        _owners[tokenId] = to;

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

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

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

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

        _balances[owner] -= 1;
        delete _owners[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);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[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;

import "./ERC721.sol";
import "./IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC1155.sol";

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {

    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    )
        external
        returns(bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    )
        external
        returns(bytes4);
}

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute.
        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.0;

import "./IERC20.sol";
import "./Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) external {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
    
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// 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":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"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":"CURRENT_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEV_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_PURCHASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumMintedDev","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":"numberOfTokens","type":"uint256"}],"name":"mintHM","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numMintedDev","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"num","type":"uint256"}],"name":"reserveTokens","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":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"uint256","name":"currentPrice","type":"uint256"}],"name":"setCurrentPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newDevAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxTokens","type":"uint256"}],"name":"setMaxTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"newState","type":"bool"}],"name":"setSaleState","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526014600c556064600d8190556200001e906126ac620002cf565b600f5567011c37937e0800006010556011805460ff191690553480156200004457600080fd5b506040516200349138038062003491833981016040819052620000679162000268565b8151829082906200008090600090602085019062000117565b5080516200009690600190602084019062000117565b5050506000620000ab6200011360201b60201c565b600a80546001600160a01b0319166001600160a01b038316908117909155604051919250906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35050600b80546001600160a01b031916331790555062000347565b3390565b8280546200012590620002f4565b90600052602060002090601f01602090048101928262000149576000855562000194565b82601f106200016457805160ff191683800117855562000194565b8280016001018555821562000194579182015b828111156200019457825182559160200191906001019062000177565b50620001a2929150620001a6565b5090565b5b80821115620001a25760008155600101620001a7565b600082601f830112620001ce578081fd5b81516001600160401b0380821115620001eb57620001eb62000331565b6040516020601f8401601f191682018101838111838210171562000213576200021362000331565b60405283825285840181018710156200022a578485fd5b8492505b838310156200024d57858301810151828401820152918201916200022e565b838311156200025e57848185840101525b5095945050505050565b600080604083850312156200027b578182fd5b82516001600160401b038082111562000292578384fd5b620002a086838701620001bd565b93506020850151915080821115620002b6578283fd5b50620002c585828601620001bd565b9150509250929050565b60008219821115620002ef57634e487b7160e01b81526011600452602481fd5b500190565b6002810460018216806200030957607f821691505b602082108114156200032b57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052604160045260246000fd5b61313a80620003576000396000f3fe6080604052600436106102195760003560e01c80637146bd081161011d578063d031370b116100b0578063eb8d24441161007f578063f2fde38b11610064578063f2fde38b146105b7578063f47c84c5146105d7578063f47eccde146105ec57610219565b8063eb8d24441461058d578063ef608680146105a257610219565b8063d031370b1461051a578063d0d41fe11461053a578063dc824df61461055a578063e985e9c51461056d57610219565b8063a22cb465116100ec578063a22cb4651461049a578063b88d4fde146104ba578063c4e37095146104da578063c87b56dd146104fa57610219565b80637146bd0814610446578063715018a61461045b5780638da5cb5b1461047057806395d89b411461048557610219565b80632f745c59116101b05780634ceffb2b1161017f57806355f804b31161016457806355f804b3146103e65780636352211e1461040657806370a082311461042657610219565b80634ceffb2b146103b15780634f6ccce7146103c657610219565b80632f745c59146103475780633ccfd60b1461036757806342842e0e1461037c5780634b369a611461039c57610219565b806311e776fe116101ec57806311e776fe146102c557806318160ddd146102e557806318b200711461030757806323b872dd1461032757610219565b806301ffc9a71461021e57806306fdde0314610254578063081812fc14610276578063095ea7b3146102a3575b600080fd5b34801561022a57600080fd5b5061023e6102393660046125c0565b610601565b60405161024b9190612739565b60405180910390f35b34801561026057600080fd5b5061026961065f565b60405161024b9190612744565b34801561028257600080fd5b5061029661029136600461263e565b6106f1565b60405161024b91906126cf565b3480156102af57600080fd5b506102c36102be36600461257d565b610764565b005b3480156102d157600080fd5b506102c36102e036600461263e565b610864565b3480156102f157600080fd5b506102fa6108dc565b60405161024b9190612ef0565b34801561031357600080fd5b506102c361032236600461263e565b6108e2565b34801561033357600080fd5b506102c36103423660046124a0565b61095a565b34801561035357600080fd5b506102fa61036236600461257d565b610965565b34801561037357600080fd5b506102c36109de565b34801561038857600080fd5b506102c36103973660046124a0565b610a9c565b3480156103a857600080fd5b506102fa610ab7565b3480156103bd57600080fd5b506102fa610abd565b3480156103d257600080fd5b506102fa6103e136600461263e565b610ac3565b3480156103f257600080fd5b506102c36104013660046125f8565b610b51565b34801561041257600080fd5b5061029661042136600461263e565b610bd7565b34801561043257600080fd5b506102fa610441366004612454565b610c33565b34801561045257600080fd5b506102fa610cab565b34801561046757600080fd5b506102c3610cb1565b34801561047c57600080fd5b50610296610d93565b34801561049157600080fd5b50610269610daf565b3480156104a657600080fd5b506102c36104b5366004612554565b610dbe565b3480156104c657600080fd5b506102c36104d53660046124db565b610ef8565b3480156104e657600080fd5b506102c36104f53660046125a6565b610f0a565b34801561050657600080fd5b5061026961051536600461263e565b610fae565b34801561052657600080fd5b506102c361053536600461263e565b61104b565b34801561054657600080fd5b506102c3610555366004612454565b61118d565b6102c361056836600461263e565b611247565b34801561057957600080fd5b5061023e61058836600461246e565b6113c3565b34801561059957600080fd5b5061023e6113fe565b3480156105ae57600080fd5b506102fa611407565b3480156105c357600080fd5b506102c36105d2366004612454565b61140d565b3480156105e357600080fd5b506102fa61155b565b3480156105f857600080fd5b506102fa611561565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f780e9d63000000000000000000000000000000000000000000000000000000001480610657575061065782611567565b90505b919050565b60606000805461066e90612fa5565b80601f016020809104026020016040519081016040528092919081815260200182805461069a90612fa5565b80156106e75780601f106106bc576101008083540402835291602001916106e7565b820191906000526020600020905b8154815290600101906020018083116106ca57829003601f168201915b5050505050905090565b60006106fc82611609565b61073b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612c8d565b60405180910390fd5b5060009081526004602052604090205473ffffffffffffffffffffffffffffffffffffffff1690565b600061076f82610bd7565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156107d7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612dd9565b8073ffffffffffffffffffffffffffffffffffffffff166107f6611633565b73ffffffffffffffffffffffffffffffffffffffff16148061081f575061081f81610588611633565b610855576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612b41565b61085f8383611637565b505050565b61086c611633565b73ffffffffffffffffffffffffffffffffffffffff1661088a610d93565b73ffffffffffffffffffffffffffffffffffffffff16146108d7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b600f55565b60085490565b6108ea611633565b73ffffffffffffffffffffffffffffffffffffffff16610908610d93565b73ffffffffffffffffffffffffffffffffffffffff1614610955576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b601055565b61085f8383836116d7565b600061097083610c33565b82106109a8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612811565b5073ffffffffffffffffffffffffffffffffffffffff919091166000908152600660209081526040808320938352929052205490565b6109e6611633565b73ffffffffffffffffffffffffffffffffffffffff16610a04610d93565b73ffffffffffffffffffffffffffffffffffffffff1614610a51576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b600b54604051479173ffffffffffffffffffffffffffffffffffffffff169082156108fc029083906000818181858888f19350505050158015610a98573d6000803e3d6000fd5b5050565b61085f83838360405180602001604052806000815250611729565b60105481565b600e5481565b6000610acd6108dc565b8210610b05576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612e93565b60088281548110610b3f577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b90600052602060002001549050919050565b610b59611633565b73ffffffffffffffffffffffffffffffffffffffff16610b77610d93565b73ffffffffffffffffffffffffffffffffffffffff1614610bc4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b8051610a989060129060208401906122f9565b60008181526002602052604081205473ffffffffffffffffffffffffffffffffffffffff1680610657576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612bfb565b600073ffffffffffffffffffffffffffffffffffffffff8216610c82576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612b9e565b5073ffffffffffffffffffffffffffffffffffffffff1660009081526003602052604090205490565b600c5481565b610cb9611633565b73ffffffffffffffffffffffffffffffffffffffff16610cd7610d93565b73ffffffffffffffffffffffffffffffffffffffff1614610d24576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b600a5460405160009173ffffffffffffffffffffffffffffffffffffffff16907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600a80547fffffffffffffffffffffffff0000000000000000000000000000000000000000169055565b600a5473ffffffffffffffffffffffffffffffffffffffff1690565b60606001805461066e90612fa5565b610dc6611633565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610e2b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612a19565b8060056000610e38611633565b73ffffffffffffffffffffffffffffffffffffffff90811682526020808301939093526040918201600090812091871680825291909352912080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001692151592909217909155610ea7611633565b73ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610eec9190612739565b60405180910390a35050565b610f0484848484611729565b50505050565b610f12611633565b73ffffffffffffffffffffffffffffffffffffffff16610f30610d93565b73ffffffffffffffffffffffffffffffffffffffff1614610f7d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b601180547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016911515919091179055565b6060610fb982611609565b610fef576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612d7c565b6000610ff961177c565b905060008151116110195760405180602001604052806000815250611044565b806110238461178b565b6040516020016110349291906126a0565b6040516020818303038152906040525b9392505050565b611053611633565b73ffffffffffffffffffffffffffffffffffffffff16611071610d93565b73ffffffffffffffffffffffffffffffffffffffff16146110be576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b600080826110ca6108dc565b6110d49190612ef9565b9050600d5483600e546110e79190612ef9565b111561111c57600e54600d546110fd9190612f62565b6111056108dc565b61110f9190612ef9565b600d54600e559050611134565b82600e600082825461112e9190612ef9565b90915550505b600061113e6108dc565b611149906001612ef9565b90505b818111610f045761116660016111606108dc565b90611914565b9250600f54831161117b5761117b3384611920565b8061118581612ff9565b91505061114c565b611195611633565b73ffffffffffffffffffffffffffffffffffffffff166111b3610d93565b73ffffffffffffffffffffffffffffffffffffffff1614611200576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b600b80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b60115460ff16611283576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612b0a565b60018110156112be576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107329061295f565b600c548111156112fa576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612aad565b600f54611309826111606108dc565b1115611341576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612757565b6010543490611350908361193a565b1115611388576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610732906127b4565b60006113926108dc565b905060015b82811161085f576113b1336113ac8484611914565b611920565b806113bb81612ff9565b915050611397565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260056020908152604080832093909416825291909152205460ff1690565b60115460ff1681565b600d5481565b611415611633565b73ffffffffffffffffffffffffffffffffffffffff16611433610d93565b73ffffffffffffffffffffffffffffffffffffffff1614611480576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612cea565b73ffffffffffffffffffffffffffffffffffffffff81166114cd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610732906128cb565b600a5460405173ffffffffffffffffffffffffffffffffffffffff8084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600a80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b600f5481565b600e5490565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f80ac58cd0000000000000000000000000000000000000000000000000000000014806115fa57507fffffffff0000000000000000000000000000000000000000000000000000000082167f5b5e139f00000000000000000000000000000000000000000000000000000000145b80610657575061065782611946565b60009081526002602052604090205473ffffffffffffffffffffffffffffffffffffffff16151590565b3390565b600081815260046020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff8416908117909155819061169182610bd7565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6116e86116e2611633565b82611990565b61171e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612e36565b61085f838383611a5b565b61173a611734611633565b83611990565b611770576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612e36565b610f0484848484611c22565b60606012805461066e90612fa5565b6060816117cc575060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015261065a565b8160005b81156117f657806117e081612ff9565b91506117ef9050600a83612f11565b91506117d0565b60008167ffffffffffffffff811115611838577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015611862576020820181803683370190505b5090505b841561190c57611877600183612f62565b9150611884600a86613032565b61188f906030612ef9565b60f81b8183815181106118cb577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350611905600a86612f11565b9450611866565b949350505050565b60006110448284612ef9565b610a98828260405180602001604052806000815250611c6f565b60006110448284612f25565b7fffffffff0000000000000000000000000000000000000000000000000000000081167f01ffc9a70000000000000000000000000000000000000000000000000000000014919050565b600061199b82611609565b6119d1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612a50565b60006119dc83610bd7565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480611a4b57508373ffffffffffffffffffffffffffffffffffffffff16611a33846106f1565b73ffffffffffffffffffffffffffffffffffffffff16145b8061190c575061190c81856113c3565b8273ffffffffffffffffffffffffffffffffffffffff16611a7b82610bd7565b73ffffffffffffffffffffffffffffffffffffffff1614611ac8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612d1f565b73ffffffffffffffffffffffffffffffffffffffff8216611b15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610732906129bc565b611b20838383611cbc565b611b2b600082611637565b73ffffffffffffffffffffffffffffffffffffffff83166000908152600360205260408120805460019290611b61908490612f62565b909155505073ffffffffffffffffffffffffffffffffffffffff82166000908152600360205260408120805460019290611b9c908490612ef9565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff86811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b611c2d848484611a5b565b611c3984848484611d93565b610f04576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107329061286e565b611c798383611f31565b611c866000848484611d93565b61085f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107329061286e565b611cc783838361085f565b73ffffffffffffffffffffffffffffffffffffffff8316611cf057611ceb81612083565b611d2d565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614611d2d57611d2d83826120c7565b73ffffffffffffffffffffffffffffffffffffffff8216611d5657611d518161217e565b61085f565b8273ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161461085f5761085f82826122a2565b6000611db48473ffffffffffffffffffffffffffffffffffffffff166122f3565b15611f26578373ffffffffffffffffffffffffffffffffffffffff1663150b7a02611ddd611633565b8786866040518563ffffffff1660e01b8152600401611dff94939291906126f0565b602060405180830381600087803b158015611e1957600080fd5b505af1925050508015611e67575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0168201909252611e64918101906125dc565b60015b611edb573d808015611e95576040519150601f19603f3d011682016040523d82523d6000602084013e611e9a565b606091505b508051611ed3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107329061286e565b805181602001fd5b7fffffffff00000000000000000000000000000000000000000000000000000000167f150b7a020000000000000000000000000000000000000000000000000000000014905061190c565b506001949350505050565b73ffffffffffffffffffffffffffffffffffffffff8216611f7e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612c58565b611f8781611609565b15611fbe576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161073290612928565b611fca60008383611cbc565b73ffffffffffffffffffffffffffffffffffffffff82166000908152600360205260408120805460019290612000908490612ef9565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b600880546000838152600960205260408120829055600182018355919091527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee30155565b600060016120d484610c33565b6120de9190612f62565b60008381526007602052604090205490915080821461213e5773ffffffffffffffffffffffffffffffffffffffff841660009081526006602090815260408083208584528252808320548484528184208190558352600790915290208190555b50600091825260076020908152604080842084905573ffffffffffffffffffffffffffffffffffffffff9094168352600681528383209183525290812055565b60085460009061219090600190612f62565b600083815260096020526040812054600880549394509092849081106121df577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b906000526020600020015490508060088381548110612227577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6000918252602080832090910192909255828152600990915260408082208490558582528120556008805480612286577f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b6001900381819060005260206000200160009055905550505050565b60006122ad83610c33565b73ffffffffffffffffffffffffffffffffffffffff9093166000908152600660209081526040808320868452825280832085905593825260079052919091209190915550565b3b151590565b82805461230590612fa5565b90600052602060002090601f016020900481019282612327576000855561236d565b82601f1061234057805160ff191683800117855561236d565b8280016001018555821561236d579182015b8281111561236d578251825591602001919060010190612352565b5061237992915061237d565b5090565b5b80821115612379576000815560010161237e565b600067ffffffffffffffff808411156123ad576123ad6130a4565b60405160207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f87011682010181811083821117156123ef576123ef6130a4565b60405284815291508183850186101561240757600080fd5b8484602083013760006020868301015250509392505050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461065a57600080fd5b8035801515811461065a57600080fd5b600060208284031215612465578081fd5b61104482612420565b60008060408385031215612480578081fd5b61248983612420565b915061249760208401612420565b90509250929050565b6000806000606084860312156124b4578081fd5b6124bd84612420565b92506124cb60208501612420565b9150604084013590509250925092565b600080600080608085870312156124f0578081fd5b6124f985612420565b935061250760208601612420565b925060408501359150606085013567ffffffffffffffff811115612529578182fd5b8501601f81018713612539578182fd5b61254887823560208401612392565b91505092959194509250565b60008060408385031215612566578182fd5b61256f83612420565b915061249760208401612444565b6000806040838503121561258f578182fd5b61259883612420565b946020939093013593505050565b6000602082840312156125b7578081fd5b61104482612444565b6000602082840312156125d1578081fd5b8135611044816130d3565b6000602082840312156125ed578081fd5b8151611044816130d3565b600060208284031215612609578081fd5b813567ffffffffffffffff81111561261f578182fd5b8201601f8101841361262f578182fd5b61190c84823560208401612392565b60006020828403121561264f578081fd5b5035919050565b6000815180845261266e816020860160208601612f79565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b600083516126b2818460208801612f79565b8351908301906126c6818360208801612f79565b01949350505050565b73ffffffffffffffffffffffffffffffffffffffff91909116815260200190565b600073ffffffffffffffffffffffffffffffffffffffff80871683528086166020840152508360408301526080606083015261272f6080830184612656565b9695505050505050565b901515815260200190565b6000602082526110446020830184612656565b6020808252602c908201527f507572636861736520776f756c6420657863656564206d617820737570706c7960408201527f206f6620486976654d696e640000000000000000000000000000000000000000606082015260800190565b60208082526024908201527f56616c756520646f6573206e6f74206d6174636820726571756972656420616d60408201527f6f756e7400000000000000000000000000000000000000000000000000000000606082015260800190565b6020808252602b908201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560408201527f74206f6620626f756e6473000000000000000000000000000000000000000000606082015260800190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527f63656976657220696d706c656d656e7465720000000000000000000000000000606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201527f6464726573730000000000000000000000000000000000000000000000000000606082015260800190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b60208082526026908201527f4d757374206d696e74206174206c65617374206f6e6520746f6b656e2061742060408201527f612074696d650000000000000000000000000000000000000000000000000000606082015260800190565b60208082526024908201527f4552433732313a207472616e7366657220746f20746865207a65726f2061646460408201527f7265737300000000000000000000000000000000000000000000000000000000606082015260800190565b60208082526019908201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604082015260600190565b6020808252602c908201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860408201527f697374656e7420746f6b656e0000000000000000000000000000000000000000606082015260800190565b60208082526021908201527f43616e206f6e6c79206d696e7420323020746f6b656e7320617420612074696d60408201527f6500000000000000000000000000000000000000000000000000000000000000606082015260800190565b6020808252601d908201527f4d696e74696e672069732063757272656e746c792064697361626c6564000000604082015260600190565b60208082526038908201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760408201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606082015260800190565b6020808252602a908201527f4552433732313a2062616c616e636520717565727920666f7220746865207a6560408201527f726f206164647265737300000000000000000000000000000000000000000000606082015260800190565b60208082526029908201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460408201527f656e7420746f6b656e0000000000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b6020808252602c908201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860408201527f697374656e7420746f6b656e0000000000000000000000000000000000000000606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526029908201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960408201527f73206e6f74206f776e0000000000000000000000000000000000000000000000606082015260800190565b6020808252602f908201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60408201527f6e6578697374656e7420746f6b656e0000000000000000000000000000000000606082015260800190565b60208082526021908201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560408201527f7200000000000000000000000000000000000000000000000000000000000000606082015260800190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60408201527f776e6572206e6f7220617070726f766564000000000000000000000000000000606082015260800190565b6020808252602c908201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60408201527f7574206f6620626f756e64730000000000000000000000000000000000000000606082015260800190565b90815260200190565b60008219821115612f0c57612f0c613046565b500190565b600082612f2057612f20613075565b500490565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615612f5d57612f5d613046565b500290565b600082821015612f7457612f74613046565b500390565b60005b83811015612f94578181015183820152602001612f7c565b83811115610f045750506000910152565b600281046001821680612fb957607f821691505b60208210811415612ff3577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82141561302b5761302b613046565b5060010190565b60008261304157613041613075565b500690565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7fffffffff000000000000000000000000000000000000000000000000000000008116811461310157600080fd5b5056fea2646970667358221220b7f8929fb4e664a482d89651c0aa28fe3871691a9b40c40b10968a1e2a78eadf64736f6c6343000800003300000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000948697665204d696e64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064856454d4e440000000000000000000000000000000000000000000000000000

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

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000948697665204d696e64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064856454d4e440000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): Hive Mind
Arg [1] : symbol (string): HVEMND

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [3] : 48697665204d696e640000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [5] : 4856454d4e440000000000000000000000000000000000000000000000000000

336:4591:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;909:234:5;;;;;;;;;;-1:-1:-1;909:234:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2342:98:4;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3754:217::-;;;;;;;;;;-1:-1:-1;3754:217:4;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3305:388::-;;;;;;;;;;-1:-1:-1;3305:388:4;;;;;:::i;:::-;;:::i;:::-;;2468:97:8;;;;;;;;;;-1:-1:-1;2468:97:8;;;;;:::i;:::-;;:::i;1546:111:5:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4816:109:8:-;;;;;;;;;;-1:-1:-1;4816:109:8;;;;;:::i;:::-;;:::i;4013:173::-;;;;;;;;;;-1:-1:-1;4013:173:8;;;;;:::i;:::-;;:::i;1222:253:5:-;;;;;;;;;;-1:-1:-1;1222:253:5;;;;;:::i;:::-;;:::i;1412:140:8:-;;;;;;;;;;;;;:::i;3600:185::-;;;;;;;;;;-1:-1:-1;3600:185:8;;;;;:::i;:::-;;:::i;937:41::-;;;;;;;;;;;;;:::i;740:27::-;;;;;;;;;;;;;:::i;1729:230:5:-;;;;;;;;;;-1:-1:-1;1729:230:5;;;;;:::i;:::-;;:::i;4306:94:8:-;;;;;;;;;;-1:-1:-1;4306:94:8;;;;;:::i;:::-;;:::i;2045:235:4:-;;;;;;;;;;-1:-1:-1;2045:235:4;;;;;:::i;:::-;;:::i;1783:205::-;;;;;;;;;;-1:-1:-1;1783:205:4;;;;;:::i;:::-;;:::i;548:32:8:-;;;;;;;;;;;;;:::i;1693:145:19:-;;;;;;;;;;;;;:::i;1061:85::-;;;;;;;;;;;;;:::i;2504:102:4:-;;;;;;;;;;;;;:::i;4038:290::-;;;;;;;;;;-1:-1:-1;4038:290:4;;;;;:::i;:::-;;:::i;3791:216:8:-;;;;;;;;;;-1:-1:-1;3791:216:8;;;;;:::i;:::-;;:::i;2637:94::-;;;;;;;;;;-1:-1:-1;2637:94:8;;;;;:::i;:::-;;:::i;2672:353:4:-;;;;;;;;;;-1:-1:-1;2672:353:4;;;;;:::i;:::-;;:::i;1611:664:8:-;;;;;;;;;;-1:-1:-1;1611:664:8;;;;;:::i;:::-;;:::i;2319:106::-;;;;;;;;;;-1:-1:-1;2319:106:8;;;;;:::i;:::-;;:::i;2780:814::-;;;;;;:::i;:::-;;:::i;4394:162:4:-;;;;;;;;;;-1:-1:-1;4394:162:4;;;;;:::i;:::-;;:::i;1017:32:8:-;;;;;;;;;;;;;:::i;638:31::-;;;;;;;;;;;;;:::i;1987:240:19:-;;;;;;;;;;-1:-1:-1;1987:240:19;;;;;:::i;:::-;;:::i;863:45:8:-;;;;;;;;;;;;;:::i;4666:93::-;;;;;;;;;;;;;:::i;909:234:5:-;1011:4;1034:50;;;1049:35;1034:50;;:102;;;1100:36;1124:11;1100:23;:36::i;:::-;1027:109;;909:234;;;;:::o;2342:98:4:-;2396:13;2428:5;2421:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2342:98;:::o;3754:217::-;3830:7;3857:16;3865:7;3857;:16::i;:::-;3849:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;3940:24:4;;;;:15;:24;;;;;;;;;3754:217::o;3305:388::-;3385:13;3401:23;3416:7;3401:14;:23::i;:::-;3385:39;;3448:5;3442:11;;:2;:11;;;;3434:57;;;;;;;;;;;;:::i;:::-;3526:5;3510:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;3535:37;3552:5;3559:12;:10;:12::i;3535:37::-;3502:152;;;;;;;;;;;;:::i;:::-;3665:21;3674:2;3678:7;3665:8;:21::i;:::-;3305:388;;;:::o;2468:97:8:-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;2536:10:8::1;:22:::0;2468:97::o;1546:111:5:-;1633:10;:17;1546:111;:::o;4816:109:8:-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;4890:13:8::1;:28:::0;4816:109::o;4013:173::-;4142:37;4161:4;4167:2;4171:7;4142:18;:37::i;1222:253:5:-;1319:7;1354:23;1371:5;1354:16;:23::i;:::-;1346:5;:31;1338:87;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1442:19:5;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;1222:253::o;1412:140:8:-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;1516:10:8::1;::::0;1508:37:::1;::::0;1477:21:::1;::::0;1516:10:::1;;::::0;1508:37;::::1;;;::::0;1477:21;;1459:15:::1;1508:37:::0;1459:15;1508:37;1477:21;1516:10;1508:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;1343:1:19;1412:140:8:o:0;3600:185::-;3733:45;3756:4;3762:2;3766:7;3733:45;;;;;;;;;;;;:22;:45::i;937:41::-;;;;:::o;740:27::-;;;;:::o;1729:230:5:-;1804:7;1839:30;:28;:30::i;:::-;1831:5;:38;1823:95;;;;;;;;;;;;:::i;:::-;1935:10;1946:5;1935:17;;;;;;;;;;;;;;;;;;;;;;;;1928:24;;1729:230;;;:::o;4306:94:8:-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;4376:17:8;;::::1;::::0;:7:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;2045:235:4:-:0;2117:7;2152:16;;;:7;:16;;;;;;;;2186:19;2178:73;;;;;;;;;;;;:::i;1783:205::-;1855:7;1882:19;;;1874:74;;;;;;;;;;;;:::i;:::-;-1:-1:-1;1965:16:4;;;;;;:9;:16;;;;;;;1783:205::o;548:32:8:-;;;;:::o;1693:145:19:-;1284:12;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;1783:6:::1;::::0;1762:40:::1;::::0;1799:1:::1;::::0;1762:40:::1;1783:6;::::0;1762:40:::1;::::0;1799:1;;1762:40:::1;1812:6;:19:::0;;;::::1;::::0;;1693:145::o;1061:85::-;1133:6;;;;1061:85;:::o;2504:102:4:-;2560:13;2592:7;2585:14;;;;;:::i;4038:290::-;4152:12;:10;:12::i;:::-;4140:24;;:8;:24;;;;4132:62;;;;;;;;;;;;:::i;:::-;4250:8;4205:18;:32;4224:12;:10;:12::i;:::-;4205:32;;;;;;;;;;;;;;;;;;-1:-1:-1;4205:32:4;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;;4288:12;:10;:12::i;:::-;4273:48;;;4312:8;4273:48;;;;;;:::i;:::-;;;;;;;;4038:290;;:::o;3791:216:8:-;3952:48;3975:4;3981:2;3985:7;3994:5;3952:22;:48::i;:::-;3791:216;;;;:::o;2637:94::-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;2701:12:8::1;:23:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;2637:94::o;2672:353:4:-;2745:13;2778:16;2786:7;2778;:16::i;:::-;2770:76;;;;;;;;;;;;:::i;:::-;2857:21;2881:10;:8;:10::i;:::-;2857:34;;2932:1;2914:7;2908:21;:25;:110;;;;;;;;;;;;;;;;;2972:7;2981:18;:7;:16;:18::i;:::-;2955:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2908:110;2901:117;2672:353;-1:-1:-1;;;2672:353:4:o;1611:664:8:-;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;1674:15:8::1;1786:17:::0;1822:3:::1;1806:13;:11;:13::i;:::-;:19;;;;:::i;:::-;1786:39;;1861:10;;1855:3;1840:12;;:18;;;;:::i;:::-;:31;1836:206;;;1929:12;;1916:10;;:25;;;;:::i;:::-;1899:13;:11;:13::i;:::-;:43;;;;:::i;:::-;1971:10;::::0;1956:12:::1;:25:::0;1887:55;-1:-1:-1;1836:206:8::1;;;2028:3;2012:12;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;1836:206:8::1;2059:9;2071:13;:11;:13::i;:::-;:17;::::0;2087:1:::1;2071:17;:::i;:::-;2059:29;;2054:215;2095:9;2090:1;:14;2054:215;;2135:20;2153:1;2135:13;:11;:13::i;:::-;:17:::0;::::1;:20::i;:::-;2125:30;;2184:10;;2173:7;:21;2169:90;;2214:30;2224:10;2236:7;2214:9;:30::i;:::-;2106:3:::0;::::1;::::0;::::1;:::i;:::-;;;;2054:215;;2319:106:::0;1284:12:19;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;2392:10:8::1;:26:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;2319:106::o;2780:814::-;2853:12;;;;2845:54;;;;;;;;;;;;:::i;:::-;2948:1;2930:14;:19;;2909:104;;;;;;;;;;;;:::i;:::-;3062:12;;3044:14;:30;;3023:110;;;;;;;;;;;;:::i;:::-;3201:10;;3164:33;3182:14;3164:13;:11;:13::i;:33::-;:47;;3143:138;;;;;;;;;;;;:::i;:::-;3312:13;;3349:9;;3312:33;;3330:14;3312:17;:33::i;:::-;:46;;3291:129;;;;;;;;;;;;:::i;:::-;3431:19;3453:13;:11;:13::i;:::-;3431:35;-1:-1:-1;3493:1:8;3476:112;3501:14;3496:1;:19;3476:112;;3536:41;3546:10;3558:18;:11;3574:1;3558:15;:18::i;:::-;3536:9;:41::i;:::-;3517:3;;;;:::i;:::-;;;;3476:112;;4394:162:4;4514:25;;;;4491:4;4514:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4394:162::o;1017:32:8:-;;;;;;:::o;638:31::-;;;;:::o;1987:240:19:-;1284:12;:10;:12::i;:::-;1273:23;;:7;:5;:7::i;:::-;:23;;;1265:68;;;;;;;;;;;;:::i;:::-;2075:22:::1;::::0;::::1;2067:73;;;;;;;;;;;;:::i;:::-;2176:6;::::0;2155:38:::1;::::0;::::1;::::0;;::::1;::::0;2176:6:::1;::::0;2155:38:::1;::::0;2176:6:::1;::::0;2155:38:::1;2203:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;1987:240::o;863:45:8:-;;;;:::o;4666:93::-;4740:12;;4666:93;:::o;1436:288:4:-;1538:4;1561:40;;;1576:25;1561:40;;:104;;-1:-1:-1;1617:48:4;;;1632:33;1617:48;1561:104;:156;;;;1681:36;1705:11;1681:23;:36::i;6915:125::-;6980:4;7003:16;;;:7;:16;;;;;;:30;:16;:30;;;6915:125::o;586:96:1:-;665:10;586:96;:::o;10672:171:4:-;10746:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;10799:23;10746:24;10799:14;:23::i;:::-;10790:46;;;;;;;;;;;;10672:171;;:::o;4618:300::-;4777:41;4796:12;:10;:12::i;:::-;4810:7;4777:18;:41::i;:::-;4769:103;;;;;;;;;;;;:::i;:::-;4883:28;4893:4;4899:2;4903:7;4883:9;:28::i;5199:282::-;5330:41;5349:12;:10;:12::i;:::-;5363:7;5330:18;:41::i;:::-;5322:103;;;;;;;;;;;;:::i;:::-;5435:39;5449:4;5455:2;5459:7;5468:5;5435:13;:39::i;4531:106:8:-;4591:13;4623:7;4616:14;;;;;:::i;271:703:22:-;327:13;544:10;540:51;;-1:-1:-1;570:10:22;;;;;;;;;;;;;;;;;;;540:51;615:5;600:12;654:75;661:9;;654:75;;686:8;;;;:::i;:::-;;-1:-1:-1;708:10:22;;-1:-1:-1;716:2:22;708:10;;:::i;:::-;;;654:75;;;738:19;770:6;760:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;760:17:22;;738:39;;787:150;794:10;;787:150;;820:11;830:1;820:11;;:::i;:::-;;-1:-1:-1;888:10:22;896:2;888:5;:10;:::i;:::-;875:24;;:2;:24;:::i;:::-;862:39;;845:6;852;845:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;-1:-1:-1;915:11:22;924:2;915:11;;:::i;:::-;;;787:150;;;960:6;271:703;-1:-1:-1;;;;271:703:22:o;2672:96:21:-;2730:7;2756:5;2760:1;2756;:5;:::i;7872:108:4:-;7947:26;7957:2;7961:7;7947:26;;;;;;;;;;;;:9;:26::i;3382:96:21:-;3440:7;3466:5;3470:1;3466;:5;:::i;763:155:3:-;871:40;;;886:25;871:40;763:155;;;:::o;7198:344:4:-;7291:4;7315:16;7323:7;7315;:16::i;:::-;7307:73;;;;;;;;;;;;:::i;:::-;7390:13;7406:23;7421:7;7406:14;:23::i;:::-;7390:39;;7458:5;7447:16;;:7;:16;;;:51;;;;7491:7;7467:31;;:20;7479:7;7467:11;:20::i;:::-;:31;;;7447:51;:87;;;;7502:32;7519:5;7526:7;7502:16;:32::i;10031:530::-;10155:4;10128:31;;:23;10143:7;10128:14;:23::i;:::-;:31;;;10120:85;;;;;;;;;;;;:::i;:::-;10223:16;;;10215:65;;;;;;;;;;;;:::i;:::-;10291:39;10312:4;10318:2;10322:7;10291:20;:39::i;:::-;10392:29;10409:1;10413:7;10392:8;:29::i;:::-;10432:15;;;;;;;:9;:15;;;;;:20;;10451:1;;10432:15;:20;;10451:1;;10432:20;:::i;:::-;;;;-1:-1:-1;;10462:13:4;;;;;;;:9;:13;;;;;:18;;10479:1;;10462:13;:18;;10479:1;;10462:18;:::i;:::-;;;;-1:-1:-1;;10490:16:4;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;10527:27;;10490:16;;10527:27;;;;;;;10031:530;;;:::o;6343:269::-;6456:28;6466:4;6472:2;6476:7;6456:9;:28::i;:::-;6502:48;6525:4;6531:2;6535:7;6544:5;6502:22;:48::i;:::-;6494:111;;;;;;;;;;;;:::i;8201:247::-;8296:18;8302:2;8306:7;8296:5;:18::i;:::-;8332:54;8363:1;8367:2;8371:7;8380:5;8332:22;:54::i;:::-;8324:117;;;;;;;;;;;;:::i;2555:542:5:-;2664:45;2691:4;2697:2;2701:7;2664:26;:45::i;:::-;2724:18;;;2720:183;;2758:40;2790:7;2758:31;:40::i;:::-;2720:183;;;2827:2;2819:10;;:4;:10;;;2815:88;;2845:47;2878:4;2884:7;2845:32;:47::i;:::-;2916:16;;;2912:179;;2948:45;2985:7;2948:36;:45::i;:::-;2912:179;;;3020:4;3014:10;;:2;:10;;;3010:81;;3040:40;3068:2;3072:7;3040:27;:40::i;11396:824:4:-;11516:4;11540:15;:2;:13;;;:15::i;:::-;11536:678;;;11591:2;11575:36;;;11612:12;:10;:12::i;:::-;11626:4;11632:7;11641:5;11575:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11575:72:4;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;11571:591;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11818:13:4;;11814:334;;11860:60;;;;;;;;;;:::i;11814:334::-;12100:6;12094:13;12085:6;12081:2;12077:15;12070:38;11571:591;11697:55;;11707:45;11697:55;;-1:-1:-1;11690:62:4;;11536:678;-1:-1:-1;12199:4:4;11396:824;;;;;;:::o;8770:372::-;8849:16;;;8841:61;;;;;;;;;;;;:::i;:::-;8921:16;8929:7;8921;:16::i;:::-;8920:17;8912:58;;;;;;;;;;;;:::i;:::-;8981:45;9010:1;9014:2;9018:7;8981:20;:45::i;:::-;9037:13;;;;;;;:9;:13;;;;;:18;;9054:1;;9037:13;:18;;9054:1;;9037:18;:::i;:::-;;;;-1:-1:-1;;9065:16:4;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;9102:33;;9065:16;;;9102:33;;9065:16;;9102:33;8770:372;;:::o;3803:161:5:-;3906:10;:17;;3879:24;;;;:15;:24;;;;;:44;;;3933:24;;;;;;;;;;;;3803:161::o;4581:970::-;4843:22;4893:1;4868:22;4885:4;4868:16;:22::i;:::-;:26;;;;:::i;:::-;4904:18;4925:26;;;:17;:26;;;;;;4843:51;;-1:-1:-1;5055:28:5;;;5051:323;;5121:18;;;5099:19;5121:18;;;:12;:18;;;;;;;;:34;;;;;;;;;5170:30;;;;;;:44;;;5286:30;;:17;:30;;;;;:43;;;5051:323;-1:-1:-1;5467:26:5;;;;:17;:26;;;;;;;;5460:33;;;5510:18;;;;;;:12;:18;;;;;:34;;;;;;;5503:41;4581:970::o;5839:1061::-;6113:10;:17;6088:22;;6113:21;;6133:1;;6113:21;:::i;:::-;6144:18;6165:24;;;:15;:24;;;;;;6533:10;:26;;6088:46;;-1:-1:-1;6165:24:5;;6088:46;;6533:26;;;;;;;;;;;;;;;;;;;;;;6511:48;;6595:11;6570:10;6581;6570:22;;;;;;;;;;;;;;;;;;;;;;;;;;;:36;;;;6674:28;;;:15;:28;;;;;;;:41;;;6843:24;;;;;6836:31;6877:10;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5839:1061;;;;:::o;3391:217::-;3475:14;3492:20;3509:2;3492:16;:20::i;:::-;3522:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;3566:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;3391:217:5:o;718:413:0:-;1078:20;1116:8;;;718:413::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:666:23;;110:18;151:2;143:6;140:14;137:2;;;157:18;;:::i;:::-;206:2;200:9;345:4;275:66;268:4;260:6;256:17;252:90;244:6;240:103;236:114;400:6;388:10;385:22;380:2;368:10;365:18;362:46;359:2;;;411:18;;:::i;:::-;447:2;440:22;495;;;480:6;-1:-1:-1;480:6:23;532:16;;;529:25;-1:-1:-1;526:2:23;;;567:1;564;557:12;526:2;617:6;612:3;605:4;597:6;593:17;580:44;672:1;665:4;656:6;648;644:19;640:30;633:41;;;90:590;;;;;:::o;685:198::-;755:20;;815:42;804:54;;794:65;;784:2;;873:1;870;863:12;888:162;955:20;;1011:13;;1004:21;994:32;;984:2;;1040:1;1037;1030:12;1055:198;;1167:2;1155:9;1146:7;1142:23;1138:32;1135:2;;;1188:6;1180;1173:22;1135:2;1216:31;1237:9;1216:31;:::i;1258:274::-;;;1387:2;1375:9;1366:7;1362:23;1358:32;1355:2;;;1408:6;1400;1393:22;1355:2;1436:31;1457:9;1436:31;:::i;:::-;1426:41;;1486:40;1522:2;1511:9;1507:18;1486:40;:::i;:::-;1476:50;;1345:187;;;;;:::o;1537:342::-;;;;1683:2;1671:9;1662:7;1658:23;1654:32;1651:2;;;1704:6;1696;1689:22;1651:2;1732:31;1753:9;1732:31;:::i;:::-;1722:41;;1782:40;1818:2;1807:9;1803:18;1782:40;:::i;:::-;1772:50;;1869:2;1858:9;1854:18;1841:32;1831:42;;1641:238;;;;;:::o;1884:702::-;;;;;2056:3;2044:9;2035:7;2031:23;2027:33;2024:2;;;2078:6;2070;2063:22;2024:2;2106:31;2127:9;2106:31;:::i;:::-;2096:41;;2156:40;2192:2;2181:9;2177:18;2156:40;:::i;:::-;2146:50;;2243:2;2232:9;2228:18;2215:32;2205:42;;2298:2;2287:9;2283:18;2270:32;2325:18;2317:6;2314:30;2311:2;;;2362:6;2354;2347:22;2311:2;2390:22;;2443:4;2435:13;;2431:27;-1:-1:-1;2421:2:23;;2477:6;2469;2462:22;2421:2;2505:75;2572:7;2567:2;2554:16;2549:2;2545;2541:11;2505:75;:::i;:::-;2495:85;;;2014:572;;;;;;;:::o;2591:268::-;;;2717:2;2705:9;2696:7;2692:23;2688:32;2685:2;;;2738:6;2730;2723:22;2685:2;2766:31;2787:9;2766:31;:::i;:::-;2756:41;;2816:37;2849:2;2838:9;2834:18;2816:37;:::i;2864:266::-;;;2993:2;2981:9;2972:7;2968:23;2964:32;2961:2;;;3014:6;3006;2999:22;2961:2;3042:31;3063:9;3042:31;:::i;:::-;3032:41;3120:2;3105:18;;;;3092:32;;-1:-1:-1;;;2951:179:23:o;3135:192::-;;3244:2;3232:9;3223:7;3219:23;3215:32;3212:2;;;3265:6;3257;3250:22;3212:2;3293:28;3311:9;3293:28;:::i;3332:257::-;;3443:2;3431:9;3422:7;3418:23;3414:32;3411:2;;;3464:6;3456;3449:22;3411:2;3508:9;3495:23;3527:32;3553:5;3527:32;:::i;3594:261::-;;3716:2;3704:9;3695:7;3691:23;3687:32;3684:2;;;3737:6;3729;3722:22;3684:2;3774:9;3768:16;3793:32;3819:5;3793:32;:::i;3860:482::-;;3982:2;3970:9;3961:7;3957:23;3953:32;3950:2;;;4003:6;3995;3988:22;3950:2;4048:9;4035:23;4081:18;4073:6;4070:30;4067:2;;;4118:6;4110;4103:22;4067:2;4146:22;;4199:4;4191:13;;4187:27;-1:-1:-1;4177:2:23;;4233:6;4225;4218:22;4177:2;4261:75;4328:7;4323:2;4310:16;4305:2;4301;4297:11;4261:75;:::i;4347:190::-;;4459:2;4447:9;4438:7;4434:23;4430:32;4427:2;;;4480:6;4472;4465:22;4427:2;-1:-1:-1;4508:23:23;;4417:120;-1:-1:-1;4417:120:23:o;4542:318::-;;4623:5;4617:12;4650:6;4645:3;4638:19;4666:63;4722:6;4715:4;4710:3;4706:14;4699:4;4692:5;4688:16;4666:63;:::i;:::-;4774:2;4762:15;4779:66;4758:88;4749:98;;;;4849:4;4745:109;;4593:267;-1:-1:-1;;4593:267:23:o;4865:470::-;;5082:6;5076:13;5098:53;5144:6;5139:3;5132:4;5124:6;5120:17;5098:53;:::i;:::-;5214:13;;5173:16;;;;5236:57;5214:13;5173:16;5270:4;5258:17;;5236:57;:::i;:::-;5309:20;;5052:283;-1:-1:-1;;;;5052:283:23:o;5340:226::-;5516:42;5504:55;;;;5486:74;;5474:2;5459:18;;5441:125::o;5571:513::-;;5794:42;5875:2;5867:6;5863:15;5852:9;5845:34;5927:2;5919:6;5915:15;5910:2;5899:9;5895:18;5888:43;;5967:6;5962:2;5951:9;5947:18;5940:34;6010:3;6005:2;5994:9;5990:18;5983:31;6031:47;6073:3;6062:9;6058:19;6050:6;6031:47;:::i;:::-;6023:55;5774:310;-1:-1:-1;;;;;;5774:310:23:o;6089:187::-;6254:14;;6247:22;6229:41;;6217:2;6202:18;;6184:92::o;6281:221::-;;6430:2;6419:9;6412:21;6450:46;6492:2;6481:9;6477:18;6469:6;6450:46;:::i;6507:408::-;6709:2;6691:21;;;6748:2;6728:18;;;6721:30;6787:34;6782:2;6767:18;;6760:62;6858:14;6853:2;6838:18;;6831:42;6905:3;6890:19;;6681:234::o;6920:400::-;7122:2;7104:21;;;7161:2;7141:18;;;7134:30;7200:34;7195:2;7180:18;;7173:62;7271:6;7266:2;7251:18;;7244:34;7310:3;7295:19;;7094:226::o;7325:407::-;7527:2;7509:21;;;7566:2;7546:18;;;7539:30;7605:34;7600:2;7585:18;;7578:62;7676:13;7671:2;7656:18;;7649:41;7722:3;7707:19;;7499:233::o;7737:414::-;7939:2;7921:21;;;7978:2;7958:18;;;7951:30;8017:34;8012:2;7997:18;;7990:62;8088:20;8083:2;8068:18;;8061:48;8141:3;8126:19;;7911:240::o;8156:402::-;8358:2;8340:21;;;8397:2;8377:18;;;8370:30;8436:34;8431:2;8416:18;;8409:62;8507:8;8502:2;8487:18;;8480:36;8548:3;8533:19;;8330:228::o;8563:352::-;8765:2;8747:21;;;8804:2;8784:18;;;8777:30;8843;8838:2;8823:18;;8816:58;8906:2;8891:18;;8737:178::o;8920:402::-;9122:2;9104:21;;;9161:2;9141:18;;;9134:30;9200:34;9195:2;9180:18;;9173:62;9271:8;9266:2;9251:18;;9244:36;9312:3;9297:19;;9094:228::o;9327:400::-;9529:2;9511:21;;;9568:2;9548:18;;;9541:30;9607:34;9602:2;9587:18;;9580:62;9678:6;9673:2;9658:18;;9651:34;9717:3;9702:19;;9501:226::o;9732:349::-;9934:2;9916:21;;;9973:2;9953:18;;;9946:30;10012:27;10007:2;9992:18;;9985:55;10072:2;10057:18;;9906:175::o;10086:408::-;10288:2;10270:21;;;10327:2;10307:18;;;10300:30;10366:34;10361:2;10346:18;;10339:62;10437:14;10432:2;10417:18;;10410:42;10484:3;10469:19;;10260:234::o;10499:397::-;10701:2;10683:21;;;10740:2;10720:18;;;10713:30;10779:34;10774:2;10759:18;;10752:62;10850:3;10845:2;10830:18;;10823:31;10886:3;10871:19;;10673:223::o;10901:353::-;11103:2;11085:21;;;11142:2;11122:18;;;11115:30;11181:31;11176:2;11161:18;;11154:59;11245:2;11230:18;;11075:179::o;11259:420::-;11461:2;11443:21;;;11500:2;11480:18;;;11473:30;11539:34;11534:2;11519:18;;11512:62;11610:26;11605:2;11590:18;;11583:54;11669:3;11654:19;;11433:246::o;11684:406::-;11886:2;11868:21;;;11925:2;11905:18;;;11898:30;11964:34;11959:2;11944:18;;11937:62;12035:12;12030:2;12015:18;;12008:40;12080:3;12065:19;;11858:232::o;12095:405::-;12297:2;12279:21;;;12336:2;12316:18;;;12309:30;12375:34;12370:2;12355:18;;12348:62;12446:11;12441:2;12426:18;;12419:39;12490:3;12475:19;;12269:231::o;12505:356::-;12707:2;12689:21;;;12726:18;;;12719:30;12785:34;12780:2;12765:18;;12758:62;12852:2;12837:18;;12679:182::o;12866:408::-;13068:2;13050:21;;;13107:2;13087:18;;;13080:30;13146:34;13141:2;13126:18;;13119:62;13217:14;13212:2;13197:18;;13190:42;13264:3;13249:19;;13040:234::o;13279:356::-;13481:2;13463:21;;;13500:18;;;13493:30;13559:34;13554:2;13539:18;;13532:62;13626:2;13611:18;;13453:182::o;13640:405::-;13842:2;13824:21;;;13881:2;13861:18;;;13854:30;13920:34;13915:2;13900:18;;13893:62;13991:11;13986:2;13971:18;;13964:39;14035:3;14020:19;;13814:231::o;14050:411::-;14252:2;14234:21;;;14291:2;14271:18;;;14264:30;14330:34;14325:2;14310:18;;14303:62;14401:17;14396:2;14381:18;;14374:45;14451:3;14436:19;;14224:237::o;14466:397::-;14668:2;14650:21;;;14707:2;14687:18;;;14680:30;14746:34;14741:2;14726:18;;14719:62;14817:3;14812:2;14797:18;;14790:31;14853:3;14838:19;;14640:223::o;14868:413::-;15070:2;15052:21;;;15109:2;15089:18;;;15082:30;15148:34;15143:2;15128:18;;15121:62;15219:19;15214:2;15199:18;;15192:47;15271:3;15256:19;;15042:239::o;15286:408::-;15488:2;15470:21;;;15527:2;15507:18;;;15500:30;15566:34;15561:2;15546:18;;15539:62;15637:14;15632:2;15617:18;;15610:42;15684:3;15669:19;;15460:234::o;15699:177::-;15845:25;;;15833:2;15818:18;;15800:76::o;15881:128::-;;15952:1;15948:6;15945:1;15942:13;15939:2;;;15958:18;;:::i;:::-;-1:-1:-1;15994:9:23;;15929:80::o;16014:120::-;;16080:1;16070:2;;16085:18;;:::i;:::-;-1:-1:-1;16119:9:23;;16060:74::o;16139:228::-;;16305:1;16237:66;16233:74;16230:1;16227:81;16222:1;16215:9;16208:17;16204:105;16201:2;;;16312:18;;:::i;:::-;-1:-1:-1;16352:9:23;;16191:176::o;16372:125::-;;16440:1;16437;16434:8;16431:2;;;16445:18;;:::i;:::-;-1:-1:-1;16482:9:23;;16421:76::o;16502:258::-;16574:1;16584:113;16598:6;16595:1;16592:13;16584:113;;;16674:11;;;16668:18;16655:11;;;16648:39;16620:2;16613:10;16584:113;;;16715:6;16712:1;16709:13;16706:2;;;-1:-1:-1;;16750:1:23;16732:16;;16725:27;16555:205::o;16765:437::-;16850:1;16840:12;;16897:1;16887:12;;;16908:2;;16962:4;16954:6;16950:17;16940:27;;16908:2;17015;17007:6;17004:14;16984:18;16981:38;16978:2;;;17052:77;17049:1;17042:88;17153:4;17150:1;17143:15;17181:4;17178:1;17171:15;16978:2;;16820:382;;;:::o;17207:195::-;;17277:66;17270:5;17267:77;17264:2;;;17347:18;;:::i;:::-;-1:-1:-1;17394:1:23;17383:13;;17254:148::o;17407:112::-;;17465:1;17455:2;;17470:18;;:::i;:::-;-1:-1:-1;17504:9:23;;17445:74::o;17524:184::-;17576:77;17573:1;17566:88;17673:4;17670:1;17663:15;17697:4;17694:1;17687:15;17713:184;17765:77;17762:1;17755:88;17862:4;17859:1;17852:15;17886:4;17883:1;17876:15;17902:184;17954:77;17951:1;17944:88;18051:4;18048:1;18041:15;18075:4;18072:1;18065:15;18091:179;18178:66;18171:5;18167:78;18160:5;18157:89;18147:2;;18260:1;18257;18250:12;18147:2;18137:133;:::o

ipfs://b7f8929fb4e664a482d89651c0aa28fe3871691a9b40c40b10968a1e2a78eadf