Token

IMPERIVM (IMP)

ERC-721

Overview

Max Total Supply

334 IMP

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x29ba4ebb316dd2c93a13e1f02010db54415113b2

Filtered by Token Holder

0xD9aE9c37B3ec30486996f86ED7052C62C9dC6eA8

Balance

1 IMP

0xd9ae9c37b3ec30486996f86ed7052c62c9dc6ea8

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NFT

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-06-14
*/

// File: @openzeppelin/contracts/utils/Counters.sol


// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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");

        (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");

        (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");

        (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");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

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 `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/interfaces/IERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * 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;

    /**
     * @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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `tokenId` must be already minted.
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @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}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden 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 {
        _setApprovalForAll(_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 || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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);

        _afterTokenTransfer(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);

        _afterTokenTransfer(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 from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(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 Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @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.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    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` and `to` are never both zero.
     *
     * 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.0;



/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        require(!paused(), "ERC721Pausable: token transfer while paused");
    }
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @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 override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



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

// File: @openzeppelin/contracts/access/IAccessControl.sol


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// File: @openzeppelin/contracts/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.6.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;





/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(uint160(account), 20),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File: @openzeppelin/contracts/access/IAccessControlEnumerable.sol


// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)

pragma solidity ^0.8.0;


/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable is IAccessControl {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

// File: @openzeppelin/contracts/access/AccessControlEnumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)

pragma solidity ^0.8.0;




/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }
}

// File: imperium.sol


pragma solidity ^0.8.7;







contract AccessControlContract is AccessControlEnumerable {
    bytes32 public constant NFT_ROLE = keccak256("NFT_ROLE");
    bytes32 public constant WHITELIST_ROLE = keccak256("WHITELIST_ROLE");
    bytes32 public constant BACKEND_ROLE = keccak256("BACKEND_ROLE");

    constructor() {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
        
        super._setRoleAdmin(NFT_ROLE, DEFAULT_ADMIN_ROLE);
        super._setRoleAdmin(WHITELIST_ROLE, DEFAULT_ADMIN_ROLE);  
        super._setRoleAdmin(BACKEND_ROLE, DEFAULT_ADMIN_ROLE);

        _setupRole(NFT_ROLE, _msgSender());
        _setupRole(WHITELIST_ROLE, _msgSender());
        _setupRole(BACKEND_ROLE, _msgSender());
    }

    function ifNftRole(address addressNft) public view returns (bool) {
        return hasRole(NFT_ROLE,addressNft);
    }

    function ifWhiteListRole(address addressWhiteList) public view returns (bool) {
        return hasRole(WHITELIST_ROLE,addressWhiteList);
    }

    function ifBackEndRole(address addressBackend) public view returns (bool) {
        return hasRole(BACKEND_ROLE,addressBackend);
    }    
}

contract NFT is ERC721Enumerable,ERC721Pausable,ERC721URIStorage,ERC2981 {
    AccessControlContract accessControl;
    using Counters for Counters.Counter;
    Counters.Counter private nftIds;

    uint96 feeNumerator;

    mapping (uint256 => address) creatoraddress;

    constructor(address accessControlAddress,uint96 _feeNumerator, string memory name, string memory symbol) ERC721(name, symbol) {
        accessControl = AccessControlContract(accessControlAddress); 
        feeNumerator=_feeNumerator;       
    }

    modifier onlyNftRole() {
        require(accessControl.ifNftRole(msg.sender), "must have nft role to nft contract");
        _;
    }

    function mint(address mintAddress, string memory _tokenURI) public onlyNftRole returns(uint256) {
        nftIds.increment();
        uint256 idNft = nftIds.current();
        _safeMint(mintAddress,idNft);
        _setTokenURI(idNft, _tokenURI);
        creatoraddress[idNft]=mintAddress;

        return idNft;
    }

    function burn(uint256 tokenId) public onlyNftRole {
         _burn(tokenId);
    }

    function pause() public onlyNftRole virtual {
         _pause();
    }

    function unpause() public onlyNftRole virtual {
        _unpause();
    }

    function setRoyalties(uint96 newroyalties) public onlyNftRole virtual{
        require(newroyalties <= 10000,"ERC2981: royalty fee will exceed salePrice");
        feeNumerator = newroyalties;
    }

    /* override methods */
    function _beforeTokenTransfer(address from,address to,uint256 tokenId) internal  override(ERC721, ERC721Enumerable, ERC721Pausable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC2981, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
    
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
        super._burn(tokenId);
    }
    
    function tokenURI(uint256 tokenId) public view  override(ERC721, ERC721URIStorage) returns (string memory) {
        return super.tokenURI(tokenId);
    }

    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256){
        uint256 royaltyAmount = (_salePrice * feeNumerator) / 10000;

        return (creatoraddress[_tokenId], royaltyAmount);
    }

    function getFee () view public onlyNftRole returns (uint96){
        return feeNumerator;
    }
}

contract WhiteList {
    mapping(address => bool)[2] whitelist;
    uint256 statoWhite=0;
    AccessControlContract accessControl;
    bool paused; 

    constructor(address accessControlAddress,address[] memory walletsList1, address[] memory walletsList2) {
        accessControl = AccessControlContract(accessControlAddress);
        for(uint i=0; i < walletsList1.length; i++){
            whitelist[statoWhite][walletsList1[i]] = true; 
        }
        for(uint i=0; i < walletsList2.length; i++){
            whitelist[1][walletsList2[i]] = true; 
        }
    }

    modifier onlyWhiteListerRole() {
        require(accessControl.ifWhiteListRole(msg.sender), "must have white lister role to whitelist");
        _;
    }

    function pauseWhiteList() public onlyWhiteListerRole {
        paused = true; 
    }

    function unpauseWhiteList() public onlyWhiteListerRole {
        paused = false; 
    }

    function addWalletWhiteList(address walletWhiteList) public onlyWhiteListerRole {
        whitelist[statoWhite][walletWhiteList] = true;
    }

    function removeWalletWhiteList(address walletWhiteList) public onlyWhiteListerRole {
        delete whitelist[statoWhite][walletWhiteList];
    }

    function clearWhiteList() public onlyWhiteListerRole{
            require(statoWhite==0,"Whitelist Already Clreared");
            statoWhite=1;
    }

    function isWhiteList(address walletWhiteList) public view returns (bool) {
        return whitelist[statoWhite][walletWhiteList];
    }

    function isPauseWhiteList() public view returns (bool) {
        return paused;
    }
}

contract Implementation {
    NFT nft;
    WhiteList whiteList; 
    AccessControlContract accessControl;
    
    constructor(address accessControlAddress,address nftAddress, address whiteListAddress) {
        accessControl = AccessControlContract(accessControlAddress);
        nft = NFT(nftAddress); 
        whiteList = WhiteList(whiteListAddress); 
    }

    modifier onlyBackEndRole() {
        require(accessControl.ifBackEndRole(msg.sender), "must have back end role to backend call");
        _;
    }

    modifier permitMint(address mintWallet) {
        require(whiteList.isPauseWhiteList() || isWhiteList(mintWallet), "the current wallet is not present in the whitelist");
        _;
    }

    function mint(address mintWallet, string memory uri) public onlyBackEndRole permitMint(mintWallet) returns (uint256) {
        return nft.mint(mintWallet,uri); 
    }

    function getFee() view public onlyBackEndRole returns (uint96){
        return nft.getFee();
    }

    function setFee(uint96 fee) public onlyBackEndRole{
        nft.setRoyalties(fee);
    }

    function burn(uint256 tokenId) public onlyBackEndRole {
        nft.burn(tokenId); 
    }    

    function pauseNFT() public onlyBackEndRole {
         nft.pause();
    }

    function unpauseNFT() public onlyBackEndRole {
         nft.unpause();
    }

    function isWhiteList(address walletWhiteList) public onlyBackEndRole view returns (bool) {
        return whiteList.isWhiteList(walletWhiteList); 
    }

    function pauseWhiteList() public onlyBackEndRole {
        whiteList.pauseWhiteList(); 
    }

    function unpauseWhiteList() public onlyBackEndRole {
        whiteList.unpauseWhiteList(); 
    }

    function addWalletWhiteList(address walletWhiteList) public onlyBackEndRole {
        whiteList.addWalletWhiteList(walletWhiteList); 
    }

    function removeWalletWhiteList(address walletWhiteList) public onlyBackEndRole {
        whiteList.removeWalletWhiteList(walletWhiteList); 
    }

    function clearWhiteList () public onlyBackEndRole{
        whiteList.clearWhiteList();
    }

    function tokenURI(uint256 tokenId) public onlyBackEndRole view returns (string memory) {
        return nft.tokenURI(tokenId); 
    }

    function ownerOf(uint256 tokenId) public onlyBackEndRole view returns (address) {
        return nft.ownerOf(tokenId); 
    }

    function totalNft() public onlyBackEndRole view returns (uint256) {
        return nft.totalSupply(); 
    }

    function balanceOf(address addressOwner) public onlyBackEndRole view returns (uint256) {
        return nft.balanceOf(addressOwner); 
    }    
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"accessControlAddress","type":"address"},{"internalType":"uint96","name":"_feeNumerator","type":"uint96"},{"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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"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":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFee","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"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":"address","name":"mintAddress","type":"address"},{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"newroyalties","type":"uint96"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000c2177119fd537b5db4f1a7d1296e826a2a34a55d00000000000000000000000000000000000000000000000000000000000002bc000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000008494d50455249564d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003494d500000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : accessControlAddress (address): 0xc2177119FD537b5Db4f1a7d1296E826A2A34a55d
Arg [1] : _feeNumerator (uint96): 700
Arg [2] : name (string): IMPERIVM
Arg [3] : symbol (string): IMP

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000c2177119fd537b5db4f1a7d1296e826a2a34a55d
Arg [1] : 00000000000000000000000000000000000000000000000000000000000002bc
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 494d50455249564d000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 494d500000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

83289:2558:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85003:180;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45112:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46672:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46195:411;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61898:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47422:339;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85486:253;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;61566:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84562:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84479:75;;;:::i;:::-;;47832:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84307:84;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62088:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41574:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44806:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44536:208;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84399:72;;;:::i;:::-;;45281:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46965:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48088:328;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85322:156;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;85747:97;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83974:325;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47191:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;85003:180;85115:4;85139:36;85163:11;85139:23;:36::i;:::-;85132:43;;85003:180;;;:::o;45112:100::-;45166:13;45199:5;45192:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45112:100;:::o;46672:221::-;46748:7;46776:16;46784:7;46776;:16::i;:::-;46768:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;46861:15;:24;46877:7;46861:24;;;;;;;;;;;;;;;;;;;;;46854:31;;46672:221;;;:::o;46195:411::-;46276:13;46292:23;46307:7;46292:14;:23::i;:::-;46276:39;;46340:5;46334:11;;:2;:11;;;46326:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;46434:5;46418:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;46443:37;46460:5;46467:12;:10;:12::i;:::-;46443:16;:37::i;:::-;46418:62;46396:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;46577:21;46586:2;46590:7;46577:8;:21::i;:::-;46265:341;46195:411;;:::o;61898:113::-;61959:7;61986:10;:17;;;;61979:24;;61898:113;:::o;47422:339::-;47617:41;47636:12;:10;:12::i;:::-;47650:7;47617:18;:41::i;:::-;47609:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;47725:28;47735:4;47741:2;47745:7;47725:9;:28::i;:::-;47422:339;;;:::o;85486:253::-;85583:7;85592;85611:21;85665:5;85649:12;;;;;;;;;;;85636:25;;:10;:25;;;;:::i;:::-;85635:35;;;;:::i;:::-;85611:59;;85691:14;:24;85706:8;85691:24;;;;;;;;;;;;;;;;;;;;;85717:13;85683:48;;;;;85486:253;;;;;:::o;61566:256::-;61663:7;61699:23;61716:5;61699:16;:23::i;:::-;61691:5;:31;61683:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;61788:12;:19;61801:5;61788:19;;;;;;;;;;;;;;;:26;61808:5;61788:26;;;;;;;;;;;;61781:33;;61566:256;;;;:::o;84562:201::-;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;84666:5:::1;84650:12;:21;;;;84642:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;84743:12;84728;;:27;;;;;;;;;;;;;;;;;;84562:201:::0;:::o;84479:75::-;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;84536:10:::1;:8;:10::i;:::-;84479:75::o:0;47832:185::-;47970:39;47987:4;47993:2;47997:7;47970:39;;;;;;;;;;;;:16;:39::i;:::-;47832:185;;;:::o;84307:84::-;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;84369:14:::1;84375:7;84369:5;:14::i;:::-;84307:84:::0;:::o;62088:233::-;62163:7;62199:30;:28;:30::i;:::-;62191:5;:38;62183:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;62296:10;62307:5;62296:17;;;;;;;;:::i;:::-;;;;;;;;;;62289:24;;62088:233;;;:::o;41574:86::-;41621:4;41645:7;;;;;;;;;;;41638:14;;41574:86;:::o;44806:239::-;44878:7;44898:13;44914:7;:16;44922:7;44914:16;;;;;;;;;;;;;;;;;;;;;44898:32;;44966:1;44949:19;;:5;:19;;;44941:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;45032:5;45025:12;;;44806:239;;;:::o;44536:208::-;44608:7;44653:1;44636:19;;:5;:19;;;44628:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;44720:9;:16;44730:5;44720:16;;;;;;;;;;;;;;;;44713:23;;44536:208;;;:::o;84399:72::-;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;84455:8:::1;:6;:8::i;:::-;84399:72::o:0;45281:104::-;45337:13;45370:7;45363:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45281:104;:::o;46965:155::-;47060:52;47079:12;:10;:12::i;:::-;47093:8;47103;47060:18;:52::i;:::-;46965:155;;:::o;48088:328::-;48263:41;48282:12;:10;:12::i;:::-;48296:7;48263:18;:41::i;:::-;48255:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;48369:39;48383:4;48389:2;48393:7;48402:5;48369:13;:39::i;:::-;48088:328;;;;:::o;85322:156::-;85414:13;85447:23;85462:7;85447:14;:23::i;:::-;85440:30;;85322:156;;;:::o;85747:97::-;85799:6;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;85824:12:::1;;;;;;;;;;;85817:19;;85747:97:::0;:::o;83974:325::-;84061:7;83872:13;;;;;;;;;;;:23;;;83896:10;83872:35;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83864:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;84081:18:::1;:6;:16;:18::i;:::-;84110:13;84126:16;:6;:14;:16::i;:::-;84110:32;;84153:28;84163:11;84175:5;84153:9;:28::i;:::-;84192:30;84205:5;84212:9;84192:12;:30::i;:::-;84255:11;84233:14;:21;84248:5;84233:21;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;84286:5;84279:12;;;83974:325:::0;;;;:::o;47191:164::-;47288:4;47312:18;:25;47331:5;47312:25;;;;;;;;;;;;;;;:35;47338:8;47312:35;;;;;;;;;;;;;;;;;;;;;;;;;47305:42;;47191:164;;;;:::o;34614:215::-;34716:4;34755:26;34740:41;;;:11;:41;;;;:81;;;;34785:36;34809:11;34785:23;:36::i;:::-;34740:81;34733:88;;34614:215;;;:::o;49926:127::-;49991:4;50043:1;50015:30;;:7;:16;50023:7;50015:16;;;;;;;;;;;;;;;;;;;;;:30;;;;50008:37;;49926:127;;;:::o;40228:98::-;40281:7;40308:10;40301:17;;40228:98;:::o;54072:174::-;54174:2;54147:15;:24;54163:7;54147:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;54230:7;54226:2;54192:46;;54201:23;54216:7;54201:14;:23::i;:::-;54192:46;;;;;;;;;;;;54072:174;;:::o;50220:348::-;50313:4;50338:16;50346:7;50338;:16::i;:::-;50330:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;50414:13;50430:23;50445:7;50430:14;:23::i;:::-;50414:39;;50483:5;50472:16;;:7;:16;;;:52;;;;50492:32;50509:5;50516:7;50492:16;:32::i;:::-;50472:52;:87;;;;50552:7;50528:31;;:20;50540:7;50528:11;:20::i;:::-;:31;;;50472:87;50464:96;;;50220:348;;;;:::o;53329:625::-;53488:4;53461:31;;:23;53476:7;53461:14;:23::i;:::-;:31;;;53453:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53567:1;53553:16;;:2;:16;;;53545:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;53623:39;53644:4;53650:2;53654:7;53623:20;:39::i;:::-;53727:29;53744:1;53748:7;53727:8;:29::i;:::-;53788:1;53769:9;:15;53779:4;53769:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;53817:1;53800:9;:13;53810:2;53800:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;53848:2;53829:7;:16;53837:7;53829:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;53887:7;53883:2;53868:27;;53877:4;53868:27;;;;;;;;;;;;53908:38;53928:4;53934:2;53938:7;53908:19;:38::i;:::-;53329:625;;;:::o;42633:120::-;42177:8;:6;:8::i;:::-;42169:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;42702:5:::1;42692:7;;:15;;;;;;;;;;;;;;;;;;42723:22;42732:12;:10;:12::i;:::-;42723:22;;;;;;:::i;:::-;;;;;;;;42633:120::o:0;85195:115::-;85282:20;85294:7;85282:11;:20::i;:::-;85195:115;:::o;42374:118::-;41900:8;:6;:8::i;:::-;41899:9;41891:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;42444:4:::1;42434:7;;:14;;;;;;;;;;;;;;;;;;42464:20;42471:12;:10;:12::i;:::-;42464:20;;;;;;:::i;:::-;;;;;;;;42374:118::o:0;54388:315::-;54543:8;54534:17;;:5;:17;;;54526:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;54630:8;54592:18;:25;54611:5;54592:25;;;;;;;;;;;;;;;:35;54618:8;54592:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;54676:8;54654:41;;54669:5;54654:41;;;54686:8;54654:41;;;;;;:::i;:::-;;;;;;;;54388:315;;;:::o;49298:::-;49455:28;49465:4;49471:2;49475:7;49455:9;:28::i;:::-;49502:48;49525:4;49531:2;49535:7;49544:5;49502:22;:48::i;:::-;49494:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;49298:315;;;;:::o;58753:679::-;58826:13;58860:16;58868:7;58860;:16::i;:::-;58852:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;58943:23;58969:10;:19;58980:7;58969:19;;;;;;;;;;;58943:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58999:18;59020:10;:8;:10::i;:::-;58999:31;;59128:1;59112:4;59106:18;:23;59102:72;;59153:9;59146:16;;;;;;59102:72;59304:1;59284:9;59278:23;:27;59274:108;;;59353:4;59359:9;59336:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59322:48;;;;;;59274:108;59401:23;59416:7;59401:14;:23::i;:::-;59394:30;;;;58753:679;;;;:::o;994:127::-;1101:1;1083:7;:14;;;:19;;;;;;;;;;;994:127;:::o;872:114::-;937:7;964;:14;;;957:21;;872:114;;;:::o;50910:110::-;50986:26;50996:2;51000:7;50986:26;;;;;;;;;;;;:9;:26::i;:::-;50910:110;;:::o;59588:217::-;59688:16;59696:7;59688;:16::i;:::-;59680:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;59788:9;59766:10;:19;59777:7;59766:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;59588:217;;:::o;61258:224::-;61360:4;61399:35;61384:50;;;:11;:50;;;;:90;;;;61438:36;61462:11;61438:23;:36::i;:::-;61384:90;61377:97;;61258:224;;;:::o;84799:196::-;84942:45;84969:4;84975:2;84979:7;84942:26;:45::i;:::-;84799:196;;;:::o;57150:125::-;;;;:::o;60034:206::-;60103:20;60115:7;60103:11;:20::i;:::-;60177:1;60146:10;:19;60157:7;60146:19;;;;;;;;;;;60140:33;;;;;:::i;:::-;;;:38;60136:97;;60202:10;:19;60213:7;60202:19;;;;;;;;;;;;60195:26;;;;:::i;:::-;60136:97;60034:206;:::o;55268:799::-;55423:4;55444:15;:2;:13;;;:15::i;:::-;55440:620;;;55496:2;55480:36;;;55517:12;:10;:12::i;:::-;55531:4;55537:7;55546:5;55480:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55476:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55739:1;55722:6;:13;:18;55718:272;;55765:60;;;;;;;;;;:::i;:::-;;;;;;;;55718:272;55940:6;55934:13;55925:6;55921:2;55917:15;55910:38;55476:529;55613:41;;;55603:51;;;:6;:51;;;;55596:58;;;;;55440:620;56044:4;56037:11;;55268:799;;;;;;;:::o;46039:94::-;46090:13;46116:9;;;;;;;;;;;;;;46039:94;:::o;45456:334::-;45529:13;45563:16;45571:7;45563;:16::i;:::-;45555:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;45644:21;45668:10;:8;:10::i;:::-;45644:34;;45720:1;45702:7;45696:21;:25;:86;;;;;;;;;;;;;;;;;45748:7;45757:18;:7;:16;:18::i;:::-;45731:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45696:86;45689:93;;;45456:334;;;:::o;51247:321::-;51377:18;51383:2;51387:7;51377:5;:18::i;:::-;51428:54;51459:1;51463:2;51467:7;51476:5;51428:22;:54::i;:::-;51406:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;51247:321;;;:::o;44167:305::-;44269:4;44321:25;44306:40;;;:11;:40;;;;:105;;;;44378:33;44363:48;;;:11;:48;;;;44306:105;:158;;;;44428:36;44452:11;44428:23;:36::i;:::-;44306:158;44286:178;;44167:305;;;:::o;57960:275::-;58104:45;58131:4;58137:2;58141:7;58104:26;:45::i;:::-;58171:8;:6;:8::i;:::-;58170:9;58162:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;57960:275;;;:::o;52572:420::-;52632:13;52648:23;52663:7;52648:14;:23::i;:::-;52632:39;;52684:48;52705:5;52720:1;52724:7;52684:20;:48::i;:::-;52773:29;52790:1;52794:7;52773:8;:29::i;:::-;52835:1;52815:9;:16;52825:5;52815:16;;;;;;;;;;;;;;;;:21;;;;;;;:::i;:::-;;;;;;;;52854:7;:16;52862:7;52854:16;;;;;;;;;;;;52847:23;;;;;;;;;;;52916:7;52912:1;52888:36;;52897:5;52888:36;;;;;;;;;;;;52937:47;52957:5;52972:1;52976:7;52937:19;:47::i;:::-;52621:371;52572:420;:::o;2698:326::-;2758:4;3015:1;2993:7;:19;;;:23;2986:30;;2698:326;;;:::o;37790:723::-;37846:13;38076:1;38067:5;:10;38063:53;;38094:10;;;;;;;;;;;;;;;;;;;;;38063:53;38126:12;38141:5;38126:20;;38157:14;38182:78;38197:1;38189:4;:9;38182:78;;38215:8;;;;;:::i;:::-;;;;38246:2;38238:10;;;;;:::i;:::-;;;38182:78;;;38270:19;38302:6;38292:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38270:39;;38320:154;38336:1;38327:5;:10;38320:154;;38364:1;38354:11;;;;;:::i;:::-;;;38431:2;38423:5;:10;;;;:::i;:::-;38410:2;:24;;;;:::i;:::-;38397:39;;38380:6;38387;38380:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;38460:2;38451:11;;;;;:::i;:::-;;;38320:154;;;38498:6;38484:21;;;;;37790:723;;;;:::o;51904:439::-;51998:1;51984:16;;:2;:16;;;51976:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;52057:16;52065:7;52057;:16::i;:::-;52056:17;52048:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;52119:45;52148:1;52152:2;52156:7;52119:20;:45::i;:::-;52194:1;52177:9;:13;52187:2;52177:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;52225:2;52206:7;:16;52214:7;52206:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;52270:7;52266:2;52245:33;;52262:1;52245:33;;;;;;;;;;;;52291:44;52319:1;52323:2;52327:7;52291:19;:44::i;:::-;51904:439;;:::o;33064:157::-;33149:4;33188:25;33173:40;;;:11;:40;;;;33166:47;;33064:157;;;:::o;62934:589::-;63078:45;63105:4;63111:2;63115:7;63078:26;:45::i;:::-;63156:1;63140:18;;:4;:18;;;63136:187;;63175:40;63207:7;63175:31;:40::i;:::-;63136:187;;;63245:2;63237:10;;:4;:10;;;63233:90;;63264:47;63297:4;63303:7;63264:32;:47::i;:::-;63233:90;63136:187;63351:1;63337:16;;:2;:16;;;63333:183;;63370:45;63407:7;63370:36;:45::i;:::-;63333:183;;;63443:4;63437:10;;:2;:10;;;63433:83;;63464:40;63492:2;63496:7;63464:27;:40::i;:::-;63433:83;63333:183;62934:589;;;:::o;56639:126::-;;;;:::o;64246:164::-;64350:10;:17;;;;64323:15;:24;64339:7;64323:24;;;;;;;;;;;:44;;;;64378:10;64394:7;64378:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64246:164;:::o;65037:988::-;65303:22;65353:1;65328:22;65345:4;65328:16;:22::i;:::-;:26;;;;:::i;:::-;65303:51;;65365:18;65386:17;:26;65404:7;65386:26;;;;;;;;;;;;65365:47;;65533:14;65519:10;:28;65515:328;;65564:19;65586:12;:18;65599:4;65586:18;;;;;;;;;;;;;;;:34;65605:14;65586:34;;;;;;;;;;;;65564:56;;65670:11;65637:12;:18;65650:4;65637:18;;;;;;;;;;;;;;;:30;65656:10;65637:30;;;;;;;;;;;:44;;;;65787:10;65754:17;:30;65772:11;65754:30;;;;;;;;;;;:43;;;;65549:294;65515:328;65939:17;:26;65957:7;65939:26;;;;;;;;;;;65932:33;;;65983:12;:18;65996:4;65983:18;;;;;;;;;;;;;;;:34;66002:14;65983:34;;;;;;;;;;;65976:41;;;65118:907;;65037:988;;:::o;66320:1079::-;66573:22;66618:1;66598:10;:17;;;;:21;;;;:::i;:::-;66573:46;;66630:18;66651:15;:24;66667:7;66651:24;;;;;;;;;;;;66630:45;;67002:19;67024:10;67035:14;67024:26;;;;;;;;:::i;:::-;;;;;;;;;;67002:48;;67088:11;67063:10;67074;67063:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;67199:10;67168:15;:28;67184:11;67168:28;;;;;;;;;;;:41;;;;67340:15;:24;67356:7;67340:24;;;;;;;;;;;67333:31;;;67375:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;66391:1008;;;66320:1079;:::o;63824:221::-;63909:14;63926:20;63943:2;63926:16;:20::i;:::-;63909:37;;63984:7;63957:12;:16;63970:2;63957:16;;;;;;;;;;;;;;;:24;63974:6;63957:24;;;;;;;;;;;:34;;;;64031:6;64002:17;:26;64020:7;64002:26;;;;;;;;;;;:35;;;;63898:147;63824:221;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:474::-;5983:6;5991;6040:2;6028:9;6019:7;6015:23;6011:32;6008:119;;;6046:79;;:::i;:::-;6008:119;6166:1;6191:53;6236:7;6227:6;6216:9;6212:22;6191:53;:::i;:::-;6181:63;;6137:117;6293:2;6319:53;6364:7;6355:6;6344:9;6340:22;6319:53;:::i;:::-;6309:63;;6264:118;5915:474;;;;;:::o;6395:332::-;6516:4;6554:2;6543:9;6539:18;6531:26;;6567:71;6635:1;6624:9;6620:17;6611:6;6567:71;:::i;:::-;6648:72;6716:2;6705:9;6701:18;6692:6;6648:72;:::i;:::-;6395:332;;;;;:::o;6733:109::-;6769:7;6809:26;6802:5;6798:38;6787:49;;6733:109;;;:::o;6848:120::-;6920:23;6937:5;6920:23;:::i;:::-;6913:5;6910:34;6900:62;;6958:1;6955;6948:12;6900:62;6848:120;:::o;6974:137::-;7019:5;7057:6;7044:20;7035:29;;7073:32;7099:5;7073:32;:::i;:::-;6974:137;;;;:::o;7117:327::-;7175:6;7224:2;7212:9;7203:7;7199:23;7195:32;7192:119;;;7230:79;;:::i;:::-;7192:119;7350:1;7375:52;7419:7;7410:6;7399:9;7395:22;7375:52;:::i;:::-;7365:62;;7321:116;7117:327;;;;:::o;7450:329::-;7509:6;7558:2;7546:9;7537:7;7533:23;7529:32;7526:119;;;7564:79;;:::i;:::-;7526:119;7684:1;7709:53;7754:7;7745:6;7734:9;7730:22;7709:53;:::i;:::-;7699:63;;7655:117;7450:329;;;;:::o;7785:116::-;7855:21;7870:5;7855:21;:::i;:::-;7848:5;7845:32;7835:60;;7891:1;7888;7881:12;7835:60;7785:116;:::o;7907:133::-;7950:5;7988:6;7975:20;7966:29;;8004:30;8028:5;8004:30;:::i;:::-;7907:133;;;;:::o;8046:468::-;8111:6;8119;8168:2;8156:9;8147:7;8143:23;8139:32;8136:119;;;8174:79;;:::i;:::-;8136:119;8294:1;8319:53;8364:7;8355:6;8344:9;8340:22;8319:53;:::i;:::-;8309:63;;8265:117;8421:2;8447:50;8489:7;8480:6;8469:9;8465:22;8447:50;:::i;:::-;8437:60;;8392:115;8046:468;;;;;:::o;8520:117::-;8629:1;8626;8619:12;8643:117;8752:1;8749;8742:12;8766:180;8814:77;8811:1;8804:88;8911:4;8908:1;8901:15;8935:4;8932:1;8925:15;8952:281;9035:27;9057:4;9035:27;:::i;:::-;9027:6;9023:40;9165:6;9153:10;9150:22;9129:18;9117:10;9114:34;9111:62;9108:88;;;9176:18;;:::i;:::-;9108:88;9216:10;9212:2;9205:22;8995:238;8952:281;;:::o;9239:129::-;9273:6;9300:20;;:::i;:::-;9290:30;;9329:33;9357:4;9349:6;9329:33;:::i;:::-;9239:129;;;:::o;9374:307::-;9435:4;9525:18;9517:6;9514:30;9511:56;;;9547:18;;:::i;:::-;9511:56;9585:29;9607:6;9585:29;:::i;:::-;9577:37;;9669:4;9663;9659:15;9651:23;;9374:307;;;:::o;9687:154::-;9771:6;9766:3;9761;9748:30;9833:1;9824:6;9819:3;9815:16;9808:27;9687:154;;;:::o;9847:410::-;9924:5;9949:65;9965:48;10006:6;9965:48;:::i;:::-;9949:65;:::i;:::-;9940:74;;10037:6;10030:5;10023:21;10075:4;10068:5;10064:16;10113:3;10104:6;10099:3;10095:16;10092:25;10089:112;;;10120:79;;:::i;:::-;10089:112;10210:41;10244:6;10239:3;10234;10210:41;:::i;:::-;9930:327;9847:410;;;;;:::o;10276:338::-;10331:5;10380:3;10373:4;10365:6;10361:17;10357:27;10347:122;;10388:79;;:::i;:::-;10347:122;10505:6;10492:20;10530:78;10604:3;10596:6;10589:4;10581:6;10577:17;10530:78;:::i;:::-;10521:87;;10337:277;10276:338;;;;:::o;10620:943::-;10715:6;10723;10731;10739;10788:3;10776:9;10767:7;10763:23;10759:33;10756:120;;;10795:79;;:::i;:::-;10756:120;10915:1;10940:53;10985:7;10976:6;10965:9;10961:22;10940:53;:::i;:::-;10930:63;;10886:117;11042:2;11068:53;11113:7;11104:6;11093:9;11089:22;11068:53;:::i;:::-;11058:63;;11013:118;11170:2;11196:53;11241:7;11232:6;11221:9;11217:22;11196:53;:::i;:::-;11186:63;;11141:118;11326:2;11315:9;11311:18;11298:32;11357:18;11349:6;11346:30;11343:117;;;11379:79;;:::i;:::-;11343:117;11484:62;11538:7;11529:6;11518:9;11514:22;11484:62;:::i;:::-;11474:72;;11269:287;10620:943;;;;;;;:::o;11569:115::-;11654:23;11671:5;11654:23;:::i;:::-;11649:3;11642:36;11569:115;;:::o;11690:218::-;11781:4;11819:2;11808:9;11804:18;11796:26;;11832:69;11898:1;11887:9;11883:17;11874:6;11832:69;:::i;:::-;11690:218;;;;:::o;11914:308::-;11976:4;12066:18;12058:6;12055:30;12052:56;;;12088:18;;:::i;:::-;12052:56;12126:29;12148:6;12126:29;:::i;:::-;12118:37;;12210:4;12204;12200:15;12192:23;;11914:308;;;:::o;12228:412::-;12306:5;12331:66;12347:49;12389:6;12347:49;:::i;:::-;12331:66;:::i;:::-;12322:75;;12420:6;12413:5;12406:21;12458:4;12451:5;12447:16;12496:3;12487:6;12482:3;12478:16;12475:25;12472:112;;;12503:79;;:::i;:::-;12472:112;12593:41;12627:6;12622:3;12617;12593:41;:::i;:::-;12312:328;12228:412;;;;;:::o;12660:340::-;12716:5;12765:3;12758:4;12750:6;12746:17;12742:27;12732:122;;12773:79;;:::i;:::-;12732:122;12890:6;12877:20;12915:79;12990:3;12982:6;12975:4;12967:6;12963:17;12915:79;:::i;:::-;12906:88;;12722:278;12660:340;;;;:::o;13006:654::-;13084:6;13092;13141:2;13129:9;13120:7;13116:23;13112:32;13109:119;;;13147:79;;:::i;:::-;13109:119;13267:1;13292:53;13337:7;13328:6;13317:9;13313:22;13292:53;:::i;:::-;13282:63;;13238:117;13422:2;13411:9;13407:18;13394:32;13453:18;13445:6;13442:30;13439:117;;;13475:79;;:::i;:::-;13439:117;13580:63;13635:7;13626:6;13615:9;13611:22;13580:63;:::i;:::-;13570:73;;13365:288;13006:654;;;;;:::o;13666:474::-;13734:6;13742;13791:2;13779:9;13770:7;13766:23;13762:32;13759:119;;;13797:79;;:::i;:::-;13759:119;13917:1;13942:53;13987:7;13978:6;13967:9;13963:22;13942:53;:::i;:::-;13932:63;;13888:117;14044:2;14070:53;14115:7;14106:6;14095:9;14091:22;14070:53;:::i;:::-;14060:63;;14015:118;13666:474;;;;;:::o;14146:180::-;14194:77;14191:1;14184:88;14291:4;14288:1;14281:15;14315:4;14312:1;14305:15;14332:320;14376:6;14413:1;14407:4;14403:12;14393:22;;14460:1;14454:4;14450:12;14481:18;14471:81;;14537:4;14529:6;14525:17;14515:27;;14471:81;14599:2;14591:6;14588:14;14568:18;14565:38;14562:84;;14618:18;;:::i;:::-;14562:84;14383:269;14332:320;;;:::o;14658:231::-;14798:34;14794:1;14786:6;14782:14;14775:58;14867:14;14862:2;14854:6;14850:15;14843:39;14658:231;:::o;14895:366::-;15037:3;15058:67;15122:2;15117:3;15058:67;:::i;:::-;15051:74;;15134:93;15223:3;15134:93;:::i;:::-;15252:2;15247:3;15243:12;15236:19;;14895:366;;;:::o;15267:419::-;15433:4;15471:2;15460:9;15456:18;15448:26;;15520:9;15514:4;15510:20;15506:1;15495:9;15491:17;15484:47;15548:131;15674:4;15548:131;:::i;:::-;15540:139;;15267:419;;;:::o;15692:220::-;15832:34;15828:1;15820:6;15816:14;15809:58;15901:3;15896:2;15888:6;15884:15;15877:28;15692:220;:::o;15918:366::-;16060:3;16081:67;16145:2;16140:3;16081:67;:::i;:::-;16074:74;;16157:93;16246:3;16157:93;:::i;:::-;16275:2;16270:3;16266:12;16259:19;;15918:366;;;:::o;16290:419::-;16456:4;16494:2;16483:9;16479:18;16471:26;;16543:9;16537:4;16533:20;16529:1;16518:9;16514:17;16507:47;16571:131;16697:4;16571:131;:::i;:::-;16563:139;;16290:419;;;:::o;16715:243::-;16855:34;16851:1;16843:6;16839:14;16832:58;16924:26;16919:2;16911:6;16907:15;16900:51;16715:243;:::o;16964:366::-;17106:3;17127:67;17191:2;17186:3;17127:67;:::i;:::-;17120:74;;17203:93;17292:3;17203:93;:::i;:::-;17321:2;17316:3;17312:12;17305:19;;16964:366;;;:::o;17336:419::-;17502:4;17540:2;17529:9;17525:18;17517:26;;17589:9;17583:4;17579:20;17575:1;17564:9;17560:17;17553:47;17617:131;17743:4;17617:131;:::i;:::-;17609:139;;17336:419;;;:::o;17761:236::-;17901:34;17897:1;17889:6;17885:14;17878:58;17970:19;17965:2;17957:6;17953:15;17946:44;17761:236;:::o;18003:366::-;18145:3;18166:67;18230:2;18225:3;18166:67;:::i;:::-;18159:74;;18242:93;18331:3;18242:93;:::i;:::-;18360:2;18355:3;18351:12;18344:19;;18003:366;;;:::o;18375:419::-;18541:4;18579:2;18568:9;18564:18;18556:26;;18628:9;18622:4;18618:20;18614:1;18603:9;18599:17;18592:47;18656:131;18782:4;18656:131;:::i;:::-;18648:139;;18375:419;;;:::o;18800:180::-;18848:77;18845:1;18838:88;18945:4;18942:1;18935:15;18969:4;18966:1;18959:15;18986:348;19026:7;19049:20;19067:1;19049:20;:::i;:::-;19044:25;;19083:20;19101:1;19083:20;:::i;:::-;19078:25;;19271:1;19203:66;19199:74;19196:1;19193:81;19188:1;19181:9;19174:17;19170:105;19167:131;;;19278:18;;:::i;:::-;19167:131;19326:1;19323;19319:9;19308:20;;18986:348;;;;:::o;19340:180::-;19388:77;19385:1;19378:88;19485:4;19482:1;19475:15;19509:4;19506:1;19499:15;19526:185;19566:1;19583:20;19601:1;19583:20;:::i;:::-;19578:25;;19617:20;19635:1;19617:20;:::i;:::-;19612:25;;19656:1;19646:35;;19661:18;;:::i;:::-;19646:35;19703:1;19700;19696:9;19691:14;;19526:185;;;;:::o;19717:230::-;19857:34;19853:1;19845:6;19841:14;19834:58;19926:13;19921:2;19913:6;19909:15;19902:38;19717:230;:::o;19953:366::-;20095:3;20116:67;20180:2;20175:3;20116:67;:::i;:::-;20109:74;;20192:93;20281:3;20192:93;:::i;:::-;20310:2;20305:3;20301:12;20294:19;;19953:366;;;:::o;20325:419::-;20491:4;20529:2;20518:9;20514:18;20506:26;;20578:9;20572:4;20568:20;20564:1;20553:9;20549:17;20542:47;20606:131;20732:4;20606:131;:::i;:::-;20598:139;;20325:419;;;:::o;20750:137::-;20804:5;20835:6;20829:13;20820:22;;20851:30;20875:5;20851:30;:::i;:::-;20750:137;;;;:::o;20893:345::-;20960:6;21009:2;20997:9;20988:7;20984:23;20980:32;20977:119;;;21015:79;;:::i;:::-;20977:119;21135:1;21160:61;21213:7;21204:6;21193:9;21189:22;21160:61;:::i;:::-;21150:71;;21106:125;20893:345;;;;:::o;21244:221::-;21384:34;21380:1;21372:6;21368:14;21361:58;21453:4;21448:2;21440:6;21436:15;21429:29;21244:221;:::o;21471:366::-;21613:3;21634:67;21698:2;21693:3;21634:67;:::i;:::-;21627:74;;21710:93;21799:3;21710:93;:::i;:::-;21828:2;21823:3;21819:12;21812:19;;21471:366;;;:::o;21843:419::-;22009:4;22047:2;22036:9;22032:18;22024:26;;22096:9;22090:4;22086:20;22082:1;22071:9;22067:17;22060:47;22124:131;22250:4;22124:131;:::i;:::-;22116:139;;21843:419;;;:::o;22268:229::-;22408:34;22404:1;22396:6;22392:14;22385:58;22477:12;22472:2;22464:6;22460:15;22453:37;22268:229;:::o;22503:366::-;22645:3;22666:67;22730:2;22725:3;22666:67;:::i;:::-;22659:74;;22742:93;22831:3;22742:93;:::i;:::-;22860:2;22855:3;22851:12;22844:19;;22503:366;;;:::o;22875:419::-;23041:4;23079:2;23068:9;23064:18;23056:26;;23128:9;23122:4;23118:20;23114:1;23103:9;23099:17;23092:47;23156:131;23282:4;23156:131;:::i;:::-;23148:139;;22875:419;;;:::o;23300:231::-;23440:34;23436:1;23428:6;23424:14;23417:58;23509:14;23504:2;23496:6;23492:15;23485:39;23300:231;:::o;23537:366::-;23679:3;23700:67;23764:2;23759:3;23700:67;:::i;:::-;23693:74;;23776:93;23865:3;23776:93;:::i;:::-;23894:2;23889:3;23885:12;23878:19;;23537:366;;;:::o;23909:419::-;24075:4;24113:2;24102:9;24098:18;24090:26;;24162:9;24156:4;24152:20;24148:1;24137:9;24133:17;24126:47;24190:131;24316:4;24190:131;:::i;:::-;24182:139;;23909:419;;;:::o;24334:180::-;24382:77;24379:1;24372:88;24479:4;24476:1;24469:15;24503:4;24500:1;24493:15;24520:228;24660:34;24656:1;24648:6;24644:14;24637:58;24729:11;24724:2;24716:6;24712:15;24705:36;24520:228;:::o;24754:366::-;24896:3;24917:67;24981:2;24976:3;24917:67;:::i;:::-;24910:74;;24993:93;25082:3;24993:93;:::i;:::-;25111:2;25106:3;25102:12;25095:19;;24754:366;;;:::o;25126:419::-;25292:4;25330:2;25319:9;25315:18;25307:26;;25379:9;25373:4;25369:20;25365:1;25354:9;25350:17;25343:47;25407:131;25533:4;25407:131;:::i;:::-;25399:139;;25126:419;;;:::o;25551:229::-;25691:34;25687:1;25679:6;25675:14;25668:58;25760:12;25755:2;25747:6;25743:15;25736:37;25551:229;:::o;25786:366::-;25928:3;25949:67;26013:2;26008:3;25949:67;:::i;:::-;25942:74;;26025:93;26114:3;26025:93;:::i;:::-;26143:2;26138:3;26134:12;26127:19;;25786:366;;;:::o;26158:419::-;26324:4;26362:2;26351:9;26347:18;26339:26;;26411:9;26405:4;26401:20;26397:1;26386:9;26382:17;26375:47;26439:131;26565:4;26439:131;:::i;:::-;26431:139;;26158:419;;;:::o;26583:231::-;26723:34;26719:1;26711:6;26707:14;26700:58;26792:14;26787:2;26779:6;26775:15;26768:39;26583:231;:::o;26820:366::-;26962:3;26983:67;27047:2;27042:3;26983:67;:::i;:::-;26976:74;;27059:93;27148:3;27059:93;:::i;:::-;27177:2;27172:3;27168:12;27161:19;;26820:366;;;:::o;27192:419::-;27358:4;27396:2;27385:9;27381:18;27373:26;;27445:9;27439:4;27435:20;27431:1;27420:9;27416:17;27409:47;27473:131;27599:4;27473:131;:::i;:::-;27465:139;;27192:419;;;:::o;27617:224::-;27757:34;27753:1;27745:6;27741:14;27734:58;27826:7;27821:2;27813:6;27809:15;27802:32;27617:224;:::o;27847:366::-;27989:3;28010:67;28074:2;28069:3;28010:67;:::i;:::-;28003:74;;28086:93;28175:3;28086:93;:::i;:::-;28204:2;28199:3;28195:12;28188:19;;27847:366;;;:::o;28219:419::-;28385:4;28423:2;28412:9;28408:18;28400:26;;28472:9;28466:4;28462:20;28458:1;28447:9;28443:17;28436:47;28500:131;28626:4;28500:131;:::i;:::-;28492:139;;28219:419;;;:::o;28644:223::-;28784:34;28780:1;28772:6;28768:14;28761:58;28853:6;28848:2;28840:6;28836:15;28829:31;28644:223;:::o;28873:366::-;29015:3;29036:67;29100:2;29095:3;29036:67;:::i;:::-;29029:74;;29112:93;29201:3;29112:93;:::i;:::-;29230:2;29225:3;29221:12;29214:19;;28873:366;;;:::o;29245:419::-;29411:4;29449:2;29438:9;29434:18;29426:26;;29498:9;29492:4;29488:20;29484:1;29473:9;29469:17;29462:47;29526:131;29652:4;29526:131;:::i;:::-;29518:139;;29245:419;;;:::o;29670:191::-;29710:4;29730:20;29748:1;29730:20;:::i;:::-;29725:25;;29764:20;29782:1;29764:20;:::i;:::-;29759:25;;29803:1;29800;29797:8;29794:34;;;29808:18;;:::i;:::-;29794:34;29853:1;29850;29846:9;29838:17;;29670:191;;;;:::o;29867:305::-;29907:3;29926:20;29944:1;29926:20;:::i;:::-;29921:25;;29960:20;29978:1;29960:20;:::i;:::-;29955:25;;30114:1;30046:66;30042:74;30039:1;30036:81;30033:107;;;30120:18;;:::i;:::-;30033:107;30164:1;30161;30157:9;30150:16;;29867:305;;;;:::o;30178:170::-;30318:22;30314:1;30306:6;30302:14;30295:46;30178:170;:::o;30354:366::-;30496:3;30517:67;30581:2;30576:3;30517:67;:::i;:::-;30510:74;;30593:93;30682:3;30593:93;:::i;:::-;30711:2;30706:3;30702:12;30695:19;;30354:366;;;:::o;30726:419::-;30892:4;30930:2;30919:9;30915:18;30907:26;;30979:9;30973:4;30969:20;30965:1;30954:9;30950:17;30943:47;31007:131;31133:4;31007:131;:::i;:::-;30999:139;;30726:419;;;:::o;31151:166::-;31291:18;31287:1;31279:6;31275:14;31268:42;31151:166;:::o;31323:366::-;31465:3;31486:67;31550:2;31545:3;31486:67;:::i;:::-;31479:74;;31562:93;31651:3;31562:93;:::i;:::-;31680:2;31675:3;31671:12;31664:19;;31323:366;;;:::o;31695:419::-;31861:4;31899:2;31888:9;31884:18;31876:26;;31948:9;31942:4;31938:20;31934:1;31923:9;31919:17;31912:47;31976:131;32102:4;31976:131;:::i;:::-;31968:139;;31695:419;;;:::o;32120:175::-;32260:27;32256:1;32248:6;32244:14;32237:51;32120:175;:::o;32301:366::-;32443:3;32464:67;32528:2;32523:3;32464:67;:::i;:::-;32457:74;;32540:93;32629:3;32540:93;:::i;:::-;32658:2;32653:3;32649:12;32642:19;;32301:366;;;:::o;32673:419::-;32839:4;32877:2;32866:9;32862:18;32854:26;;32926:9;32920:4;32916:20;32912:1;32901:9;32897:17;32890:47;32954:131;33080:4;32954:131;:::i;:::-;32946:139;;32673:419;;;:::o;33098:237::-;33238:34;33234:1;33226:6;33222:14;33215:58;33307:20;33302:2;33294:6;33290:15;33283:45;33098:237;:::o;33341:366::-;33483:3;33504:67;33568:2;33563:3;33504:67;:::i;:::-;33497:74;;33580:93;33669:3;33580:93;:::i;:::-;33698:2;33693:3;33689:12;33682:19;;33341:366;;;:::o;33713:419::-;33879:4;33917:2;33906:9;33902:18;33894:26;;33966:9;33960:4;33956:20;33952:1;33941:9;33937:17;33930:47;33994:131;34120:4;33994:131;:::i;:::-;33986:139;;33713:419;;;:::o;34138:236::-;34278:34;34274:1;34266:6;34262:14;34255:58;34347:19;34342:2;34334:6;34330:15;34323:44;34138:236;:::o;34380:366::-;34522:3;34543:67;34607:2;34602:3;34543:67;:::i;:::-;34536:74;;34619:93;34708:3;34619:93;:::i;:::-;34737:2;34732:3;34728:12;34721:19;;34380:366;;;:::o;34752:419::-;34918:4;34956:2;34945:9;34941:18;34933:26;;35005:9;34999:4;34995:20;34991:1;34980:9;34976:17;34969:47;35033:131;35159:4;35033:131;:::i;:::-;35025:139;;34752:419;;;:::o;35177:148::-;35279:11;35316:3;35301:18;;35177:148;;;;:::o;35331:377::-;35437:3;35465:39;35498:5;35465:39;:::i;:::-;35520:89;35602:6;35597:3;35520:89;:::i;:::-;35513:96;;35618:52;35663:6;35658:3;35651:4;35644:5;35640:16;35618:52;:::i;:::-;35695:6;35690:3;35686:16;35679:23;;35441:267;35331:377;;;;:::o;35714:435::-;35894:3;35916:95;36007:3;35998:6;35916:95;:::i;:::-;35909:102;;36028:95;36119:3;36110:6;36028:95;:::i;:::-;36021:102;;36140:3;36133:10;;35714:435;;;;;:::o;36155:233::-;36295:34;36291:1;36283:6;36279:14;36272:58;36364:16;36359:2;36351:6;36347:15;36340:41;36155:233;:::o;36394:366::-;36536:3;36557:67;36621:2;36616:3;36557:67;:::i;:::-;36550:74;;36633:93;36722:3;36633:93;:::i;:::-;36751:2;36746:3;36742:12;36735:19;;36394:366;;;:::o;36766:419::-;36932:4;36970:2;36959:9;36955:18;36947:26;;37019:9;37013:4;37009:20;37005:1;36994:9;36990:17;36983:47;37047:131;37173:4;37047:131;:::i;:::-;37039:139;;36766:419;;;:::o;37191:98::-;37242:6;37276:5;37270:12;37260:22;;37191:98;;;:::o;37295:168::-;37378:11;37412:6;37407:3;37400:19;37452:4;37447:3;37443:14;37428:29;;37295:168;;;;:::o;37469:360::-;37555:3;37583:38;37615:5;37583:38;:::i;:::-;37637:70;37700:6;37695:3;37637:70;:::i;:::-;37630:77;;37716:52;37761:6;37756:3;37749:4;37742:5;37738:16;37716:52;:::i;:::-;37793:29;37815:6;37793:29;:::i;:::-;37788:3;37784:39;37777:46;;37559:270;37469:360;;;;:::o;37835:640::-;38030:4;38068:3;38057:9;38053:19;38045:27;;38082:71;38150:1;38139:9;38135:17;38126:6;38082:71;:::i;:::-;38163:72;38231:2;38220:9;38216:18;38207:6;38163:72;:::i;:::-;38245;38313:2;38302:9;38298:18;38289:6;38245:72;:::i;:::-;38364:9;38358:4;38354:20;38349:2;38338:9;38334:18;38327:48;38392:76;38463:4;38454:6;38392:76;:::i;:::-;38384:84;;37835:640;;;;;;;:::o;38481:141::-;38537:5;38568:6;38562:13;38553:22;;38584:32;38610:5;38584:32;:::i;:::-;38481:141;;;;:::o;38628:349::-;38697:6;38746:2;38734:9;38725:7;38721:23;38717:32;38714:119;;;38752:79;;:::i;:::-;38714:119;38872:1;38897:63;38952:7;38943:6;38932:9;38928:22;38897:63;:::i;:::-;38887:73;;38843:127;38628:349;;;;:::o;38983:234::-;39123:34;39119:1;39111:6;39107:14;39100:58;39192:17;39187:2;39179:6;39175:15;39168:42;38983:234;:::o;39223:366::-;39365:3;39386:67;39450:2;39445:3;39386:67;:::i;:::-;39379:74;;39462:93;39551:3;39462:93;:::i;:::-;39580:2;39575:3;39571:12;39564:19;;39223:366;;;:::o;39595:419::-;39761:4;39799:2;39788:9;39784:18;39776:26;;39848:9;39842:4;39838:20;39834:1;39823:9;39819:17;39812:47;39876:131;40002:4;39876:131;:::i;:::-;39868:139;;39595:419;;;:::o;40020:230::-;40160:34;40156:1;40148:6;40144:14;40137:58;40229:13;40224:2;40216:6;40212:15;40205:38;40020:230;:::o;40256:366::-;40398:3;40419:67;40483:2;40478:3;40419:67;:::i;:::-;40412:74;;40495:93;40584:3;40495:93;:::i;:::-;40613:2;40608:3;40604:12;40597:19;;40256:366;;;:::o;40628:419::-;40794:4;40832:2;40821:9;40817:18;40809:26;;40881:9;40875:4;40871:20;40867:1;40856:9;40852:17;40845:47;40909:131;41035:4;40909:131;:::i;:::-;40901:139;;40628:419;;;:::o;41053:233::-;41092:3;41115:24;41133:5;41115:24;:::i;:::-;41106:33;;41161:66;41154:5;41151:77;41148:103;;41231:18;;:::i;:::-;41148:103;41278:1;41271:5;41267:13;41260:20;;41053:233;;;:::o;41292:176::-;41324:1;41341:20;41359:1;41341:20;:::i;:::-;41336:25;;41375:20;41393:1;41375:20;:::i;:::-;41370:25;;41414:1;41404:35;;41419:18;;:::i;:::-;41404:35;41460:1;41457;41453:9;41448:14;;41292:176;;;;:::o;41474:182::-;41614:34;41610:1;41602:6;41598:14;41591:58;41474:182;:::o;41662:366::-;41804:3;41825:67;41889:2;41884:3;41825:67;:::i;:::-;41818:74;;41901:93;41990:3;41901:93;:::i;:::-;42019:2;42014:3;42010:12;42003:19;;41662:366;;;:::o;42034:419::-;42200:4;42238:2;42227:9;42223:18;42215:26;;42287:9;42281:4;42277:20;42273:1;42262:9;42258:17;42251:47;42315:131;42441:4;42315:131;:::i;:::-;42307:139;;42034:419;;;:::o;42459:178::-;42599:30;42595:1;42587:6;42583:14;42576:54;42459:178;:::o;42643:366::-;42785:3;42806:67;42870:2;42865:3;42806:67;:::i;:::-;42799:74;;42882:93;42971:3;42882:93;:::i;:::-;43000:2;42995:3;42991:12;42984:19;;42643:366;;;:::o;43015:419::-;43181:4;43219:2;43208:9;43204:18;43196:26;;43268:9;43262:4;43258:20;43254:1;43243:9;43239:17;43232:47;43296:131;43422:4;43296:131;:::i;:::-;43288:139;;43015:419;;;:::o;43440:180::-;43488:77;43485:1;43478:88;43585:4;43582:1;43575:15;43609:4;43606:1;43599:15

Swarm Source

ipfs://566f189a59af318e0fa4d56744fda347ff82b5d16df1d9187329a600de397df1

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services