Token

Quantum Creatures (QCC)

ERC-721

Overview

Max Total Supply

654 QCC

Holders

143

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x947a2e766f5e7a6002f02c08eabe6f236cc41c9b

Filtered by Token Holder

0x40030D0b7F15B43dF0594e570bfA36E5c0fd3b1d

loochifer.eth

Balance

1 QCC

0x40030d0b7f15b43df0594e570bfa36e5c0fd3b1d

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

QuantumCreatures

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-25
*/

// SPDX-License-Identifier: MIT
// 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;
}


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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

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

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

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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _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 || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

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

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

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

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

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

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

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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





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, _msgSender());
        _;
    }

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


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


pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


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


pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}





pragma solidity ^0.8.4;


error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        if (operator == _msgSender()) revert ApproveToCaller();

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        _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 {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex &&
            !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * 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, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}



pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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



contract QuantumCreatures is ERC721A, ReentrancyGuard, Ownable {



    // Minting Variables
    uint256 public mintPrice = 0.002 ether;
    uint256 public maxPurchase = 5;
    uint256 public maxSupply = 777;
    address public ogAddress = 0x514D7700782FBb17d9B0E478c9B14329E1e23937;
    uint256 public maxPublicMints = 400;
    uint256 public publicMints = 0;
    uint256 public mintProceeds = 0;
    uint256 public royaltiesPercentage = 2; // Royalties percentage (e.g., 2%)

    struct TokenListing {
        bool isListed;
        address seller;
        uint256 price;
    }

    mapping(uint256 => TokenListing) public tokenListings;
    

    struct Bid {
        uint256 amount;
        address bidder;
        bool isActive;
    }

    mapping(uint256 => Bid) public bids;
    uint256 public numBids;


    struct Offer {
        uint256 amount;
        address bidder;
        bool isActive;
    }

    // Mapping from token ID to offer
    mapping(uint256 => Offer) public tokenOffers;



    mapping(address => uint256[]) public bidderToBids;


    // Sale Status
    bool public saleIsActive = false;
    bool public holderSaleIsActive = false;

    // mappings
    mapping(uint256 => bool) public claimedSpys;
    mapping(address => uint) public addressesThatMinted;


    // Metadata
    string _baseTokenURI = "ipfs://bafybeickbczbls54haseef4rmzy2aq2yqjpznmkjakksdak3ptizw6pviq/";


    // Events
    event SaleActivation(bool isActive);
    event HolderSaleActivation(bool isActive);

    constructor() ERC721A("Quantum Creatures", "QCC")  {

    }

    //Holder status validation
    function isSpyAvailable(uint256 _tokenId) public view returns(bool) {
        return claimedSpys[_tokenId] != true;
    }

    // Minting
    function ownerMint(address _to, uint256 _count) external onlyOwner {
        require(
            totalSupply() + _count <= maxSupply,
            "SOLD_OUT"
        );
        _safeMint(_to, _count);
    }

    function airdopMint(address[] calldata _to) external onlyOwner {
        for (uint256 i = 0; i < _to.length; i++) {
        _safeMint(_to[i], 1);
        }
    }


    function holderFreeMint(uint256[] calldata _spyIds, uint256 _count) external nonReentrant {
        require(holderSaleIsActive);
        require(
            _count == _spyIds.length,
            "INSUFFICIENT_OG_TOKENS"
        );
        require(
            totalSupply() + _count <= maxSupply,
            "SOLD_OUT"
        );

        ERC721Enumerable ogSpys = ERC721Enumerable(ogAddress);
        require(ogSpys.balanceOf(msg.sender) > 0);
        for (uint256 i = 0; i < _spyIds.length; i++) {
            require(isSpyAvailable(_spyIds[i]), "OG_ALREADY_CLAIMED");
            require(ogSpys.ownerOf(_spyIds[i]) == msg.sender, "NOT_SPY_OWNER");
            claimedSpys[_spyIds[i]] = true;
        }

        _safeMint(msg.sender, _count);
    }

    function mint(uint256 _count) external payable nonReentrant {
        require(saleIsActive, "SALE_INACTIVE");
        require(((addressesThatMinted[msg.sender] + _count) ) <= maxPurchase , "this would exceed mint max allowance");

        require(
            totalSupply() + _count <= maxSupply,
            "SOLD_OUT"
        );
        require(
            publicMints + _count <= maxPublicMints,
            "PUBLIC_SOLD_OUT"
        );
        require(
            mintPrice * _count <= msg.value,
            "INCORRECT_ETHER_VALUE"
        );
            publicMints += _count;
            mintProceeds += msg.value;
            _safeMint(msg.sender, _count);
            addressesThatMinted[msg.sender] += _count;
        }

    function setMaxPublicMints(uint256 _maxPublicMints) external onlyOwner {
        maxPublicMints = _maxPublicMints;
    }

    function toggleHolderSaleStatus() external onlyOwner {
        holderSaleIsActive = !holderSaleIsActive;
        emit HolderSaleActivation(holderSaleIsActive);
    }

    function toggleSaleStatus() external onlyOwner {
        saleIsActive = !saleIsActive;
        emit SaleActivation(saleIsActive);
    }

    function setMintPrice(uint256 _mintPrice) external onlyOwner {
        mintPrice = _mintPrice;
    }


    function setMaxPurchase(uint256 _maxPurchase) external onlyOwner {
        maxPurchase = _maxPurchase;
    }


    function getWalletOfOwner(address owner) external view returns (uint256[] memory) {
    unchecked {
        uint256[] memory a = new uint256[](balanceOf(owner));
        uint256 end = _currentIndex;
        uint256 tokenIdsIdx;
        address currOwnershipAddr;
        for (uint256 i; i < end; i++) {
            TokenOwnership memory ownership = _ownerships[i];
            if (ownership.burned) {
                continue;
            }
            if (ownership.addr != address(0)) {
                currOwnershipAddr = ownership.addr;
            }
            if (currOwnershipAddr == owner) {
                a[tokenIdsIdx++] = i;
            }
        }
        return a;
    }
    }

    function getTotalSupply() external view returns (uint256) {
        return totalSupply();
    }

    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }


   function tokenURI(uint256 tokenId) public view override returns (string memory){
        return string(abi.encodePacked(super.tokenURI(tokenId), ".json"));
        
    }


    function setRoyaltiesPercentage(uint256 _newRoyaltiesPercentage) external onlyOwner {
        require(_newRoyaltiesPercentage <= 10, "Invalid royalties percentage");
        royaltiesPercentage = _newRoyaltiesPercentage;
    }


    function acceptBid(uint256 _tokenId, uint256 _bidIndex) external nonReentrant {
        require(_bidIndex <= numBids, "Invalid bid index");


        Bid storage acceptedBid = bids[_bidIndex];

        require(acceptedBid.isActive, "Bid not active");
        require(msg.sender == ownerOf(_tokenId), "Token not owned by accepter");

        uint256 royaltiesAmount = (acceptedBid.amount * royaltiesPercentage) / 100;
        uint256 sellerAmount = acceptedBid.amount - royaltiesAmount;

        acceptedBid.isActive = false; // Mark bid as inactive

                // Update listing status to inactive
        if (tokenListings[_tokenId].isListed) {
            tokenListings[_tokenId].isListed = false;
        }

        safeTransferFrom(msg.sender, acceptedBid.bidder, _tokenId); 
        payable(msg.sender).transfer(sellerAmount); // Send funds to the seller
        payable(owner()).transfer(royaltiesAmount); // Send royalties to the owner
    }


    function buyToken(uint256 _tokenId) external payable nonReentrant {
        TokenListing storage listing = tokenListings[_tokenId];

        require(listing.isListed, "Token not listed");
        require(msg.value >= listing.price, "Insufficient payment");
        require(ownerOf(_tokenId) == listing.seller, "Token not owned by seller");

        uint256 royaltiesAmount = (msg.value * royaltiesPercentage) / 100;
        uint256 sellerAmount = msg.value - royaltiesAmount;

        tokenListings[_tokenId].isListed = false; // Mark listing as inactive
        _approve(msg.sender, _tokenId, listing.seller);
        safeTransferFrom(listing.seller, msg.sender, _tokenId); 
       


        payable(listing.seller).transfer(sellerAmount); // Send funds to the seller
        payable(owner()).transfer(royaltiesAmount); // Send royalties to the owner
    }

    function removeTokenListings(uint256[] memory _tokenIds) external {
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            require(msg.sender == tokenListings[_tokenIds[i]].seller, "Not the seller");
            tokenListings[_tokenIds[i]].isListed = false; // Mark listing as inactive
        }
    }


    function listTokens(uint256[] memory _tokenIds, uint256[] memory _prices) external {
        require(_tokenIds.length == _prices.length, "Array lengths must match");

        for (uint256 i = 0; i < _tokenIds.length; i++) {
            require(ownerOf(_tokenIds[i]) == msg.sender, "Not the token owner");
            tokenListings[_tokenIds[i]] = TokenListing(true, msg.sender, _prices[i]);
        }
    }

    function placeBid() external payable {
        require(msg.value > 0, "Bid amount must be greater than 0");

        numBids++;
        bids[numBids] = Bid(msg.value, msg.sender, true);
        bidderToBids[msg.sender].push(numBids);
    }

    function withdrawBid(uint256 _bidIndex) external nonReentrant {
        Bid storage bid = bids[_bidIndex];
        require(bid.bidder == msg.sender, "Not your bid");
        require(bid.isActive, "Bid not active");

        bid.isActive = false;
        payable(msg.sender).transfer(bid.amount);
    }

    function withdrawMintProceeds () external onlyOwner nonReentrant {
        payable(owner()).transfer(mintProceeds);
        mintProceeds -= mintProceeds;
    }

    // Place an offer on a specific token
    function placeOffer(uint256 _tokenId) external payable nonReentrant {
        require(_exists(_tokenId), "Token does not exist");
        require(msg.value > 0, "Offer amount must be greater than 0");

        Offer storage existingOffer = tokenOffers[_tokenId];

        if (existingOffer.isActive) {
            // Ensure the new offer is higher than the existing one
            require(msg.value > existingOffer.amount, "Offer must be higher than existing offer");
            
            // Return ETH to the previous offer's placer
            payable(existingOffer.bidder).transfer(existingOffer.amount);
        }

        tokenOffers[_tokenId] = Offer(msg.value, msg.sender, true);
    }


    // Accept an offer for a specific token
    function acceptOffer(uint256 _tokenId) external nonReentrant {
        require(_exists(_tokenId), "Token does not exist");

        Offer storage acceptedOffer = tokenOffers[_tokenId];

        require(acceptedOffer.isActive, "No active offer");
        require(ownerOf(_tokenId) == msg.sender, "Token not owned by accepter");

        

        acceptedOffer.isActive = false; // Mark offer as inactive


        uint256 royaltiesAmount = (acceptedOffer.amount * royaltiesPercentage) / 100;
        uint256 sellerAmount = acceptedOffer.amount- royaltiesAmount;

                // Update listing status to inactive
        if (tokenListings[_tokenId].isListed) {
            tokenListings[_tokenId].isListed = false;
        }


        safeTransferFrom(msg.sender, acceptedOffer.bidder, _tokenId);
        payable(msg.sender).transfer(sellerAmount); // Send funds to the seller
        payable(owner()).transfer(royaltiesAmount); // Send royalties to the owner
    }


    // Remove an offer for a specific token
    function withdrawOffer(uint256 _tokenId) external nonReentrant {
        require(_exists(_tokenId), "Token does not exist");

        Offer storage offer = tokenOffers[_tokenId];
        require(offer.bidder == msg.sender, "Not the offer creator");
        require(offer.isActive, "Offer not active");

        offer.isActive = false;
        payable(msg.sender).transfer(offer.amount);
    }


    function getActiveOffersForWallet(address wallet) external view returns (uint256[] memory) {
        uint256 numActiveOffers = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            Offer storage offer = tokenOffers[tokenId];
            if (offer.isActive && offer.bidder == wallet) {
                numActiveOffers++;
            }
        }

        uint256[] memory activeOffers = new uint256[](numActiveOffers);
        uint256 activeOfferIndex = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            Offer storage offer = tokenOffers[tokenId];
            if (offer.isActive && offer.bidder == wallet) {
                activeOffers[activeOfferIndex] = tokenId;
                activeOfferIndex++;
            }
        }

        return activeOffers;
    }

    function getActiveListingsForWallet(address wallet) external view returns (uint256[] memory) {
        uint256 numActiveListings = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            TokenListing storage listing = tokenListings[tokenId];
            if (listing.isListed && listing.seller == wallet) {
                numActiveListings++;
            }
        }

        uint256[] memory activeListings = new uint256[](numActiveListings);
        uint256 activeListingIndex = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            TokenListing storage listing = tokenListings[tokenId];
            if (listing.isListed && listing.seller == wallet) {
                activeListings[activeListingIndex] = tokenId;
                activeListingIndex++;
            }
        }

        return activeListings;
    }

    function getActiveBidsForWallet(address wallet) external view returns (uint256[] memory) {
        uint256 numActiveBids = 0;

        for (uint256 bidIndex = 1; bidIndex <= numBids; bidIndex++) {
            Bid storage bid = bids[bidIndex];
            if (bid.isActive && bid.bidder == wallet) {
                numActiveBids++;
            }
        }

        uint256[] memory activeBids = new uint256[](numActiveBids);
        uint256 activeBidIndex = 0;

        for (uint256 bidIndex = 1; bidIndex <= numBids; bidIndex++) {
            Bid storage bid = bids[bidIndex];
            if (bid.isActive && bid.bidder == wallet) {
                activeBids[activeBidIndex] = bidIndex;
                activeBidIndex++;
            }
        }

        return activeBids;
    }

    function getAllActiveListings() external view returns (uint256[] memory) {
        uint256 numActiveListings = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            if (tokenListings[tokenId].isListed) {
                numActiveListings++;
            }
        }

        uint256[] memory activeListings = new uint256[](numActiveListings);
        uint256 activeListingIndex = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            if (tokenListings[tokenId].isListed) {
                activeListings[activeListingIndex] = tokenId;
                activeListingIndex++;
            }
        }

        return activeListings;
    }


    function getAllActiveOffers() external view returns (uint256[] memory) {
        uint256 numActiveOffers = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            if (tokenOffers[tokenId].isActive) {
                numActiveOffers++;
            }
        }

        uint256[] memory activeOffers = new uint256[](numActiveOffers);
        uint256 activeOfferIndex = 0;

        for (uint256 tokenId = 0; tokenId < totalSupply(); tokenId++) {
            if (tokenOffers[tokenId].isActive) {
                activeOffers[activeOfferIndex] = tokenId;
                activeOfferIndex++;
            }
        }

        return activeOffers;
    }


    function getAllActiveBids() external view returns (uint256[] memory) {
        uint256 numActiveBids = 0;

        for (uint256 bidIndex = 1; bidIndex <= numBids; bidIndex++) {
            if (bids[bidIndex].isActive) {
                numActiveBids++;
            }
        }

        uint256[] memory activeBids = new uint256[](numActiveBids);
        uint256 activeBidIndex = 0;

        for (uint256 bidIndex = 1; bidIndex <= numBids; bidIndex++) {
            if (bids[bidIndex].isActive) {
                activeBids[activeBidIndex] = bidIndex;
                activeBidIndex++;
            }
        }

        return activeBids;
    }



}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"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":"bool","name":"isActive","type":"bool"}],"name":"HolderSaleActivation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isActive","type":"bool"}],"name":"SaleActivation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_bidIndex","type":"uint256"}],"name":"acceptBid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"acceptOffer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressesThatMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_to","type":"address[]"}],"name":"airdopMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"bidderToBids","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bids","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"bidder","type":"address"},{"internalType":"bool","name":"isActive","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"buyToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimedSpys","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getActiveBidsForWallet","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getActiveListingsForWallet","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getActiveOffersForWallet","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllActiveBids","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllActiveListings","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllActiveOffers","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getWalletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_spyIds","type":"uint256[]"},{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"holderFreeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"holderSaleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isSpyAvailable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_prices","type":"uint256[]"}],"name":"listTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxPublicMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintProceeds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numBids","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ogAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"placeBid","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"placeOffer","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"removeTokenListings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"royaltiesPercentage","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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxPublicMints","type":"uint256"}],"name":"setMaxPublicMints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxPurchase","type":"uint256"}],"name":"setMaxPurchase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newRoyaltiesPercentage","type":"uint256"}],"name":"setRoyaltiesPercentage","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":[],"name":"toggleHolderSaleStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleSaleStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenListings","outputs":[{"internalType":"bool","name":"isListed","type":"bool"},{"internalType":"address","name":"seller","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenOffers","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"bidder","type":"address"},{"internalType":"bool","name":"isActive","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_bidIndex","type":"uint256"}],"name":"withdrawBid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawMintProceeds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"withdrawOffer","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

100214:16237:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;115073:697;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75848:305;;;;;;;;;;-1:-1:-1;75848:305:0;;;;;:::i;:::-;;:::i;:::-;;;1202:14:1;;1195:22;1177:41;;1165:2;1150:18;75848:305:0;1037:187:1;106132:975:0;;;;;;;;;;-1:-1:-1;106132:975:0;;;;;:::i;:::-;;:::i;:::-;;104272:138;;;;;;;;;;;;;:::i;78961:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;80472:204::-;;;;;;;;;;-1:-1:-1;80472:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2587:32:1;;;2569:51;;2557:2;2542:18;80472:204:0;2423:203:1;80027:379:0;;;;;;;;;;-1:-1:-1;80027:379:0;;;;;:::i;:::-;;:::i;109005:308::-;;;;;;;;;;-1:-1:-1;109005:308:0;;;;;:::i;:::-;;:::i;75097:303::-;;;;;;;;;;-1:-1:-1;75351:12:0;;75141:7;75335:13;:28;75097:303;;;3233:25:1;;;3221:2;3206:18;75097:303:0;3087:177:1;102427:772:0;;;;;;;;;;-1:-1:-1;102427:772:0;;;;;:::i;:::-;;:::i;101885:123::-;;;;;;;;;;-1:-1:-1;101885:123:0;;;;;:::i;:::-;101947:4;101971:21;;;:11;:21;;;;;;;;:29;;:21;:29;;;101885:123;100553:30;;;;;;;;;;;;;;;;81337:170;;;;;;;;;;-1:-1:-1;81337:170:0;;;;;:::i;:::-;;:::i;109534:712::-;;;;;;:::i;:::-;;:::i;115780:662::-;;;;;;;;;;;;;:::i;107117:876::-;;;;;;:::i;:::-;;:::i;101445:43::-;;;;;;;;;;-1:-1:-1;101445:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;112621:903;;;;;;;;;;-1:-1:-1;112621:903:0;;;;;:::i;:::-;;:::i;109321:162::-;;;;;;;;;;;;;:::i;81578:185::-;;;;;;;;;;-1:-1:-1;81578:185:0;;;;;:::i;:::-;;:::i;100988:35::-;;;;;;;;;;-1:-1:-1;100988:35:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;100988:35:0;;;-1:-1:-1;;;100988:35:0;;;;;;;;;;5060:25:1;;;-1:-1:-1;;;;;5121:32:1;;;5116:2;5101:18;;5094:60;5197:14;5190:22;5170:18;;;5163:50;5048:2;5033:18;100988:35:0;4864:355:1;102032:212:0;;;;;;;;;;-1:-1:-1;102032:212:0;;;;;:::i;:::-;;:::i;104096:168::-;;;;;;;;;;;;;:::i;105475:104::-;;;;;;;;;;-1:-1:-1;105475:104:0;;;;;:::i;:::-;;:::i;104650:712::-;;;;;;;;;;-1:-1:-1;104650:712:0;;;;;:::i;:::-;;:::i;78769:125::-;;;;;;;;;;-1:-1:-1;78769:125:0;;;;;:::i;:::-;;:::i;100316:38::-;;;;;;;;;;;;;;;;100590:31;;;;;;;;;;;;;;;;114342:721;;;;;;;;;;;;;:::i;76217:206::-;;;;;;;;;;-1:-1:-1;76217:206:0;;;;;:::i;:::-;;:::i;104530:110::-;;;;;;;;;;-1:-1:-1;104530:110:0;;;;;:::i;:::-;;:::i;65971:103::-;;;;;;;;;;;;;:::i;100435:69::-;;;;;;;;;;-1:-1:-1;100435:69:0;;;;-1:-1:-1;;;;;100435:69:0;;;111349:401;;;;;;;;;;-1:-1:-1;111349:401:0;;;;;:::i;:::-;;:::i;65320:87::-;;;;;;;;;;-1:-1:-1;65393:6:0;;-1:-1:-1;;;;;65393:6:0;65320:87;;111760:853;;;;;;;;;;-1:-1:-1;111760:853:0;;;;;:::i;:::-;;:::i;105893:229::-;;;;;;;;;;-1:-1:-1;105893:229:0;;;;;:::i;:::-;;:::i;79130:104::-;;;;;;;;;;;;;:::i;100361:30::-;;;;;;;;;;;;;;;;102252:165;;;;;;;;;;-1:-1:-1;102252:165:0;;;;;:::i;:::-;;:::i;103207:751::-;;;;;;:::i;:::-;;:::i;80748:287::-;;;;;;;;;;-1:-1:-1;80748:287:0;;;;;:::i;:::-;;:::i;103966:122::-;;;;;;;;;;-1:-1:-1;103966:122:0;;;;;:::i;:::-;;:::i;101495:51::-;;;;;;;;;;-1:-1:-1;101495:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;81834:369;;;;;;;;;;-1:-1:-1;81834:369:0;;;;;:::i;:::-;;:::i;100819:53::-;;;;;;;;;;-1:-1:-1;100819:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;100819:53:0;;;;;;;;8388:14:1;;8381:22;8363:41;;-1:-1:-1;;;;;8440:32:1;;;8435:2;8420:18;;8413:60;8489:18;;;8482:34;8351:2;8336:18;100819:53:0;8167:355:1;105370:97:0;;;;;;;;;;;;;:::i;100511:35::-;;;;;;;;;;;;;;;;110301:993;;;;;;;;;;-1:-1:-1;110301:993:0;;;;;:::i;:::-;;:::i;105710:173::-;;;;;;;;;;-1:-1:-1;105710:173:0;;;;;:::i;:::-;;:::i;101205:44::-;;;;;;;;;;-1:-1:-1;101205:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;101205:44:0;;;-1:-1:-1;;;101205:44:0;;;;;;100628:38;;;;;;;;;;;;;;;;101030:22;;;;;;;;;;;;;;;;101381:38;;;;;;;;;;-1:-1:-1;101381:38:0;;;;;;;;;;;100398:30;;;;;;;;;;;;;;;;81106:164;;;;;;;;;;-1:-1:-1;81106:164:0;;;;;:::i;:::-;;:::i;101262:49::-;;;;;;;;;;-1:-1:-1;101262:49:0;;;;;:::i;:::-;;:::i;101342:32::-;;;;;;;;;;-1:-1:-1;101342:32:0;;;;;;;;113532:802;;;;;;;;;;-1:-1:-1;113532:802:0;;;;;:::i;:::-;;:::i;108001:320::-;;;;;;;;;;-1:-1:-1;108001:320:0;;;;;:::i;:::-;;:::i;108752:245::-;;;:::i;66229:201::-;;;;;;;;;;-1:-1:-1;66229:201:0;;;;;:::i;:::-;;:::i;104418:102::-;;;;;;;;;;-1:-1:-1;104418:102:0;;;;;:::i;:::-;;:::i;108331:413::-;;;;;;;;;;-1:-1:-1;108331:413:0;;;;;:::i;:::-;;:::i;115073:697::-;115126:16;115155:23;115200:15;115195:175;75351:12;;75141:7;75335:13;:28;115221:7;:23;115195:175;;;115276:20;;;;:11;:20;;;;;:29;;;-1:-1:-1;;;115276:29:0;;;;115272:87;;;115326:17;;;;:::i;:::-;;;;115272:87;115246:9;;;;:::i;:::-;;;;115195:175;;;;115382:29;115428:15;-1:-1:-1;;;;;115414:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;115414:30:0;;115382:62;;115455:24;115501:15;115496:235;75351:12;;75141:7;75335:13;:28;115522:7;:23;115496:235;;;115577:20;;;;:11;:20;;;;;:29;;;-1:-1:-1;;;115577:29:0;;;;115573:147;;;115660:7;115627:12;115640:16;115627:30;;;;;;;;:::i;:::-;;;;;;;;;;:40;115686:18;;;;:::i;:::-;;;;115573:147;115547:9;;;;:::i;:::-;;;;115496:235;;;-1:-1:-1;115750:12:0;;115073:697;-1:-1:-1;;;115073:697:0:o;75848:305::-;75950:4;-1:-1:-1;;;;;;75987:40:0;;-1:-1:-1;;;75987:40:0;;:105;;-1:-1:-1;;;;;;;76044:48:0;;-1:-1:-1;;;76044:48:0;75987:105;:158;;;-1:-1:-1;;;;;;;;;;36189:40:0;;;76109:36;75967:178;75848:305;-1:-1:-1;;75848:305:0:o;106132:975::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;;;;;;;;;70705:1;71436:7;:18;106242:7:::1;::::0;106229:20;::::1;;106221:50;;;::::0;-1:-1:-1;;;106221:50:0;;11556:2:1;106221:50:0::1;::::0;::::1;11538:21:1::0;11595:2;11575:18;;;11568:30;-1:-1:-1;;;11614:18:1;;;11607:47;11671:18;;106221:50:0::1;11354:341:1::0;106221:50:0::1;106286:23;106312:15:::0;;;:4:::1;:15;::::0;;;;106348:20:::1;::::0;::::1;::::0;-1:-1:-1;;;106348:20:0;::::1;;;106340:47;;;::::0;-1:-1:-1;;;106340:47:0;;11902:2:1;106340:47:0::1;::::0;::::1;11884:21:1::0;11941:2;11921:18;;;11914:30;-1:-1:-1;;;11960:18:1;;;11953:44;12014:18;;106340:47:0::1;11700:338:1::0;106340:47:0::1;106420:17;106428:8;106420:7;:17::i;:::-;-1:-1:-1::0;;;;;106406:31:0::1;:10;-1:-1:-1::0;;;;;106406:31:0::1;;106398:71;;;::::0;-1:-1:-1;;;106398:71:0;;12245:2:1;106398:71:0::1;::::0;::::1;12227:21:1::0;12284:2;12264:18;;;12257:30;12323:29;12303:18;;;12296:57;12370:18;;106398:71:0::1;12043:351:1::0;106398:71:0::1;106482:23;106553:3;106530:19;;106509:11;:18;;;:40;;;;:::i;:::-;106508:48;;;;:::i;:::-;106482:74;;106567:20;106611:15;106590:11;:18;;;:36;;;;:::i;:::-;106639:20;::::0;::::1;:28:::0;;-1:-1:-1;;;;106639:28:0::1;::::0;;106662:5:::1;106762:23:::0;;;:13:::1;:23;::::0;;;;:32;106567:59;;-1:-1:-1;106639:28:0::1;106762:32;106758:105;;;106846:5;106811:23:::0;;;:13:::1;:23;::::0;;;;:40;;-1:-1:-1;;106811:40:0::1;::::0;;106758:105:::1;106904:18;::::0;::::1;::::0;106875:58:::1;::::0;106892:10:::1;::::0;-1:-1:-1;;;;;106904:18:0::1;106924:8:::0;106875:16:::1;:58::i;:::-;106945:42;::::0;106953:10:::1;::::0;106945:42;::::1;;;::::0;106974:12;;106945:42:::1;::::0;;;106974:12;106953:10;106945:42;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;65393:6:0;;107026:42:::1;::::0;-1:-1:-1;;;;;65393:6:0;;;;107026:42;::::1;;;::::0;107052:15;;107026:42:::1;::::0;;;107052:15;65393:6;107026:42;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;70661:1:0;71615:7;:22;-1:-1:-1;;;;106132:975:0:o;104272:138::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;104346:12:::1;::::0;;::::1;::::0;;::::1;104345:13;-1:-1:-1::0;;104330:28:0;;::::1;::::0;::::1;::::0;;;104374::::1;::::0;104389:12;;1202:14:1;1195:22;1177:41;;104374:28:0::1;::::0;1165:2:1;1150:18;104374:28:0::1;;;;;;;;104272:138::o:0;78961:100::-;79015:13;79048:5;79041:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78961:100;:::o;80472:204::-;80540:7;80565:16;80573:7;80565;:16::i;:::-;80560:64;;80590:34;;-1:-1:-1;;;80590:34:0;;;;;;;;;;;80560:64;-1:-1:-1;80644:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;80644:24:0;;80472:204::o;80027:379::-;80108:13;80124:24;80140:7;80124:15;:24::i;:::-;80108:40;;80169:5;-1:-1:-1;;;;;80163:11:0;:2;-1:-1:-1;;;;;80163:11:0;;80159:48;;80183:24;;-1:-1:-1;;;80183:24:0;;;;;;;;;;;80159:48;33209:10;-1:-1:-1;;;;;80224:21:0;;;;;;:63;;-1:-1:-1;80250:37:0;80267:5;33209:10;81106:164;:::i;80250:37::-;80249:38;80224:63;80220:138;;;80311:35;;-1:-1:-1;;;80311:35:0;;;;;;;;;;;80220:138;80370:28;80379:2;80383:7;80392:5;80370:8;:28::i;:::-;80097:309;80027:379;;:::o;109005:308::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;109078:15:::1;109096::::0;;;:4:::1;:15;::::0;;;;109130:10:::1;::::0;::::1;::::0;-1:-1:-1;;;;;109130:10:0::1;109144;109130:24;109122:49;;;::::0;-1:-1:-1;;;109122:49:0;;13910:2:1;109122:49:0::1;::::0;::::1;13892:21:1::0;13949:2;13929:18;;;13922:30;-1:-1:-1;;;13968:18:1;;;13961:42;14020:18;;109122:49:0::1;13708:336:1::0;109122:49:0::1;109190:12;::::0;::::1;::::0;-1:-1:-1;;;109190:12:0;::::1;;;109182:39;;;::::0;-1:-1:-1;;;109182:39:0;;11902:2:1;109182:39:0::1;::::0;::::1;11884:21:1::0;11941:2;11921:18;;;11914:30;-1:-1:-1;;;11960:18:1;;;11953:44;12014:18;;109182:39:0::1;11700:338:1::0;109182:39:0::1;109234:12;::::0;::::1;:20:::0;;-1:-1:-1;;;;109234:20:0::1;::::0;;109294:10;;109265:40:::1;::::0;109273:10:::1;::::0;109265:40;::::1;;;::::0;109249:5:::1;109265:40:::0;109249:5;109265:40;109294:10;109273;109265:40;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;70661:1:0;71615:7;:22;-1:-1:-1;109005:308:0:o;102427:772::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;102536::::1;::::0;::::1;::::0;::::1;;;102528:27;;;::::0;::::1;;102588:24:::0;;::::1;102566:96;;;::::0;-1:-1:-1;;;102566:96:0;;14251:2:1;102566:96:0::1;::::0;::::1;14233:21:1::0;14290:2;14270:18;;;14263:30;-1:-1:-1;;;14309:18:1;;;14302:52;14371:18;;102566:96:0::1;14049:346:1::0;102566:96:0::1;102721:9;;102711:6;102695:13;75351:12:::0;;75141:7;75335:13;:28;;75097:303;102695:13:::1;:22;;;;:::i;:::-;:35;;102673:93;;;;-1:-1:-1::0;;;102673:93:0::1;;;;;;;:::i;:::-;102822:9;::::0;102851:28:::1;::::0;-1:-1:-1;;;102851:28:0;;102868:10:::1;102851:28;::::0;::::1;2569:51:1::0;-1:-1:-1;;;;;102822:9:0;;::::1;::::0;102779:23:::1;::::0;102822:9;;102851:16:::1;::::0;2542:18:1;;102851:28:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:32;102843:41;;;::::0;::::1;;102900:9;102895:255;102915:18:::0;;::::1;102895:255;;;102963:26;102978:7;;102986:1;102978:10;;;;;;;:::i;:::-;;;;;;;101947:4:::0;101971:21;;;:11;:21;;;;;;;;:29;;:21;:29;;;101885:123;102963:26:::1;102955:57;;;::::0;-1:-1:-1;;;102955:57:0;;15257:2:1;102955:57:0::1;::::0;::::1;15239:21:1::0;15296:2;15276:18;;;15269:30;-1:-1:-1;;;15315:18:1;;;15308:48;15373:18;;102955:57:0::1;15055:342:1::0;102955:57:0::1;103065:10;-1:-1:-1::0;;;;;103035:14:0;::::1;;103050:7:::0;;103058:1;103050:10;;::::1;;;;;:::i;:::-;;;;;;;103035:26;;;;;;;;;;;;;3233:25:1::0;;3221:2;3206:18;;3087:177;103035:26:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;103035:40:0::1;;103027:66;;;::::0;-1:-1:-1;;;103027:66:0;;15860:2:1;103027:66:0::1;::::0;::::1;15842:21:1::0;15899:2;15879:18;;;15872:30;-1:-1:-1;;;15918:18:1;;;15911:43;15971:18;;103027:66:0::1;15658:337:1::0;103027:66:0::1;103134:4;103108:11;:23;103120:7;;103128:1;103120:10;;;;;;;:::i;:::-;;;;;;;103108:23;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;102935:3;;;;;:::i;:::-;;;;102895:255;;;;103162:29;103172:10;103184:6;103162:9;:29::i;:::-;-1:-1:-1::0;;70661:1:0;71615:7;:22;-1:-1:-1;;102427:772:0:o;81337:170::-;81471:28;81481:4;81487:2;81491:7;81471:9;:28::i;109534:712::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;109621:17:::1;109629:8:::0;109621:7:::1;:17::i;:::-;109613:50;;;;-1:-1:-1::0;;;109613:50:0::1;;;;;;;:::i;:::-;109694:1;109682:9;:13;109674:61;;;::::0;-1:-1:-1;;;109674:61:0;;16551:2:1;109674:61:0::1;::::0;::::1;16533:21:1::0;16590:2;16570:18;;;16563:30;16629:34;16609:18;;;16602:62;-1:-1:-1;;;16680:18:1;;;16673:33;16723:19;;109674:61:0::1;16349:399:1::0;109674:61:0::1;109748:27;109778:21:::0;;;:11:::1;:21;::::0;;;;109816:22:::1;::::0;::::1;::::0;-1:-1:-1;;;109816:22:0;::::1;;;109812:356;;;109944:20:::0;;109932:9:::1;:32;109924:85;;;::::0;-1:-1:-1;;;109924:85:0;;16955:2:1;109924:85:0::1;::::0;::::1;16937:21:1::0;16994:2;16974:18;;;16967:30;17033:34;17013:18;;;17006:62;-1:-1:-1;;;17084:18:1;;;17077:38;17132:19;;109924:85:0::1;16753:404:1::0;109924:85:0::1;110104:20;::::0;::::1;::::0;110135;;110096:60:::1;::::0;-1:-1:-1;;;;;110104:20:0;;::::1;::::0;110096:60;::::1;;;::::0;110135:20;110104::::1;110096:60:::0;110104:20;110096:60;110135:20;110104;110096:60;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;109812:356;-1:-1:-1::0;110204:34:0::1;::::0;;::::1;::::0;::::1;::::0;;110210:9:::1;110204:34:::0;;110221:10:::1;110204:34;::::0;;::::1;::::0;;;110233:4:::1;110204:34:::0;;;;;;-1:-1:-1;110180:21:0;;;:11:::1;:21:::0;;;;;;;:58;;;;;;;::::1;::::0;;;;::::1;;-1:-1:-1::0;;;110180:58:0::1;-1:-1:-1::0;;;;;;110180:58:0;;;-1:-1:-1;;;;;110180:58:0;;;::::1;::::0;;;;;;;::::1;::::0;;;71615:7;:22;109534:712::o;115780:662::-;115831:16;115860:21;115922:1;115898:165;115937:7;;115925:8;:19;115898:165;;115977:14;;;;:4;:14;;;;;:23;;;-1:-1:-1;;;115977:23:0;;;;115973:79;;;116021:15;;;;:::i;:::-;;;;115973:79;115946:10;;;;:::i;:::-;;;;115898:165;;;;116075:27;116119:13;-1:-1:-1;;;;;116105:28:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;116105:28:0;-1:-1:-1;116075:58:0;-1:-1:-1;116144:22:0;116207:1;116183:222;116222:7;;116210:8;:19;116183:222;;116262:14;;;;:4;:14;;;;;:23;;;-1:-1:-1;;;116262:23:0;;;;116258:136;;;116335:8;116306:10;116317:14;116306:26;;;;;;;;:::i;:::-;;;;;;;;;;:37;116362:16;;;;:::i;:::-;;;;116258:136;116231:10;;;;:::i;:::-;;;;116183:222;;107117:876;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;107194:28:::1;107225:23:::0;;;:13:::1;:23;::::0;;;;107269:16;;::::1;;107261:45;;;::::0;-1:-1:-1;;;107261:45:0;;17364:2:1;107261:45:0::1;::::0;::::1;17346:21:1::0;17403:2;17383:18;;;17376:30;-1:-1:-1;;;17422:18:1;;;17415:46;17478:18;;107261:45:0::1;17162:340:1::0;107261:45:0::1;107338:7;:13;;;107325:9;:26;;107317:59;;;::::0;-1:-1:-1;;;107317:59:0;;17709:2:1;107317:59:0::1;::::0;::::1;17691:21:1::0;17748:2;17728:18;;;17721:30;-1:-1:-1;;;17767:18:1;;;17760:50;17827:18;;107317:59:0::1;17507:344:1::0;107317:59:0::1;107416:14:::0;;::::1;::::0;::::1;-1:-1:-1::0;;;;;107416:14:0::1;107395:17;107403:8:::0;107395:7:::1;:17::i;:::-;-1:-1:-1::0;;;;;107395:35:0::1;;107387:73;;;::::0;-1:-1:-1;;;107387:73:0;;18058:2:1;107387:73:0::1;::::0;::::1;18040:21:1::0;18097:2;18077:18;;;18070:30;18136:27;18116:18;;;18109:55;18181:18;;107387:73:0::1;17856:349:1::0;107387:73:0::1;107473:23;107535:3;107512:19;;107500:9;:31;;;;:::i;:::-;107499:39;;;;:::i;:::-;107473:65:::0;-1:-1:-1;107549:20:0::1;107572:27;107473:65:::0;107572:9:::1;:27;:::i;:::-;107647:5;107612:23:::0;;;:13:::1;:23;::::0;;;;:40;;-1:-1:-1;;107612:40:0::1;::::0;;107722:14;;107549:50;;-1:-1:-1;107691:46:0::1;::::0;107700:10:::1;::::0;107612:23;;:40:::1;107722:14:::0;::::1;-1:-1:-1::0;;;;;107722:14:0::1;107691:8;:46::i;:::-;107765:14:::0;;107748:54:::1;::::0;107765:14:::1;::::0;::::1;-1:-1:-1::0;;;;;107765:14:0::1;107781:10;107793:8:::0;107748:16:::1;:54::i;:::-;107835:14:::0;;107827:46:::1;::::0;107835:14:::1;::::0;;::::1;-1:-1:-1::0;;;;;107835:14:0::1;::::0;107827:46:::1;::::0;::::1;;::::0;;;107835:14:::1;107827:46:::0;107835:14;107827:46;;107835:14;107827:46;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;65393:6:0;;107912:42:::1;::::0;-1:-1:-1;;;;;65393:6:0;;;;107912:42;::::1;;;::::0;107938:15;;107912:42:::1;::::0;;;107938:15;65393:6;107912:42;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;70661:1:0;71615:7;:22;-1:-1:-1;;;107117:876:0:o;112621:903::-;112696:16;112725:25;112772:15;112767:260;75351:12;;75141:7;75335:13;:28;112793:7;:23;112767:260;;;112844:28;112875:22;;;:13;:22;;;;;112916:16;;;;:44;;;;-1:-1:-1;112936:14:0;;-1:-1:-1;;;;;112936:24:0;;;:14;;;;;:24;112916:44;112912:104;;;112981:19;;;;:::i;:::-;;;;112912:104;-1:-1:-1;112818:9:0;;;;:::i;:::-;;;;112767:260;;;;113039:31;113087:17;-1:-1:-1;;;;;113073:32:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;113073:32:0;;113039:66;;113116:26;113164:15;113159:324;75351:12;;75141:7;75335:13;:28;113185:7;:23;113159:324;;;113236:28;113267:22;;;:13;:22;;;;;113308:16;;;;:44;;;;-1:-1:-1;113328:14:0;;-1:-1:-1;;;;;113328:24:0;;;:14;;;;;:24;113308:44;113304:168;;;113410:7;113373:14;113388:18;113373:34;;;;;;;;:::i;:::-;;;;;;;;;;:44;113436:20;;;;:::i;:::-;;;;113304:168;-1:-1:-1;113210:9:0;;;;:::i;:::-;;;;113159:324;;;-1:-1:-1;113502:14:0;;112621:903;-1:-1:-1;;;;112621:903:0:o;109321:162::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;70705:1:::1;71303:7;;:19:::0;71295:63:::1;;;;-1:-1:-1::0;;;71295:63:0::1;;;;;;;:::i;:::-;70705:1;71436:7;:18:::0;65393:6;;109423:12:::2;::::0;109397:39:::2;::::0;-1:-1:-1;;;;;65393:6:0;;;;109397:39;::::2;;;::::0;109423:12;109397:39:::2;::::0;;;109423:12;65393:6;109397:39;::::2;;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;109463:12:0::2;::::0;;;109447::::2;:28;109463:12:::0;;109447:28:::2;:::i;:::-;::::0;;;-1:-1:-1;;70661:1:0::1;71615:7;:22:::0;109321:162::o;81578:185::-;81716:39;81733:4;81739:2;81743:7;81716:39;;;;;;;;;;;;:16;:39::i;102032:212::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;102158:9:::1;;102148:6;102132:13;75351:12:::0;;75141:7;75335:13;:28;;75097:303;102132:13:::1;:22;;;;:::i;:::-;:35;;102110:93;;;;-1:-1:-1::0;;;102110:93:0::1;;;;;;;:::i;:::-;102214:22;102224:3;102229:6;102214:9;:22::i;:::-;102032:212:::0;;:::o;104096:168::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;104182:18:::1;::::0;;::::1;;::::0;;::::1;::::0;::::1;104181:19;104160:40:::0;::::1;-1:-1:-1::0;;104160:40:0;;::::1;::::0;;;::::1;::::0;;;;104216::::1;::::0;::::1;::::0;::::1;::::0;104237:18;::::1;::::0;;::::1;1202:14:1::0;1195:22;1177:41;;1165:2;1150:18;;1037:187;105475:104:0;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;105548:13:::1;:23;105564:7:::0;105548:13;:23:::1;:::i;104650:712::-:0;104714:16;104760:18;104795:16;104805:5;104795:9;:16::i;:::-;-1:-1:-1;;;;;104781:31:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;104781:31:0;-1:-1:-1;104823:11:0;104837:13;;104760:52;;-1:-1:-1;104823:11:0;;104927:402;104947:3;104943:1;:7;104927:402;;;104972:31;105006:14;;;:11;:14;;;;;;;;;104972:48;;;;;;;;;-1:-1:-1;;;;;104972:48:0;;;;-1:-1:-1;;;104972:48:0;;-1:-1:-1;;;;;104972:48:0;;;;;;;;-1:-1:-1;;;104972:48:0;;;;;;;;;;;;;;;;105035:65;;105076:8;;;105035:65;105118:14;;-1:-1:-1;;;;;105118:28:0;;105114:103;;105187:14;;;-1:-1:-1;105114:103:0;105256:5;-1:-1:-1;;;;;105235:26:0;:17;-1:-1:-1;;;;;105235:26:0;;105231:87;;105301:1;105282;105284:13;;;;;;105282:16;;;;;;;;:::i;:::-;;;;;;:20;;;;;105231:87;104957:372;104927:402;104952:3;;104927:402;;;-1:-1:-1;105346:1:0;;104650:712;-1:-1:-1;;;;;104650:712:0:o;78769:125::-;78833:7;78860:21;78873:7;78860:12;:21::i;:::-;:26;;78769:125;-1:-1:-1;;78769:125:0:o;114342:721::-;114397:16;114426:25;114473:15;114468:179;75351:12;;75141:7;75335:13;:28;114494:7;:23;114468:179;;;114549:22;;;;:13;:22;;;;;:31;;;114545:91;;;114601:19;;;;:::i;:::-;;;;114545:91;114519:9;;;;:::i;:::-;;;;114468:179;;;;114659:31;114707:17;-1:-1:-1;;;;;114693:32:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;114693:32:0;;114659:66;;114736:26;114784:15;114779:243;75351:12;;75141:7;75335:13;:28;114805:7;:23;114779:243;;;114860:22;;;;:13;:22;;;;;:31;;;114856:155;;;114949:7;114912:14;114927:18;114912:34;;;;;;;;:::i;:::-;;;;;;;;;;:44;114975:20;;;;:::i;:::-;;;;114856:155;114830:9;;;;:::i;:::-;;;;114779:243;;76217:206;76281:7;-1:-1:-1;;;;;76305:19:0;;76301:60;;76333:28;;-1:-1:-1;;;76333:28:0;;;;;;;;;;;76301:60;-1:-1:-1;;;;;;76387:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;76387:27:0;;76217:206::o;104530:110::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;104606:11:::1;:26:::0;104530:110::o;65971:103::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;66036:30:::1;66063:1;66036:18;:30::i;:::-;65971:103::o:0;111349:401::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;111431:17:::1;111439:8:::0;111431:7:::1;:17::i;:::-;111423:50;;;;-1:-1:-1::0;;;111423:50:0::1;;;;;;;:::i;:::-;111486:19;111508:21:::0;;;:11:::1;:21;::::0;;;;111548:12:::1;::::0;::::1;::::0;-1:-1:-1;;;;;111548:12:0::1;111564:10;111548:26;111540:60;;;::::0;-1:-1:-1;;;111540:60:0;;20616:2:1;111540:60:0::1;::::0;::::1;20598:21:1::0;20655:2;20635:18;;;20628:30;-1:-1:-1;;;20674:18:1;;;20667:51;20735:18;;111540:60:0::1;20414:345:1::0;111540:60:0::1;111619:14;::::0;::::1;::::0;-1:-1:-1;;;111619:14:0;::::1;;;111611:43;;;::::0;-1:-1:-1;;;111611:43:0;;20966:2:1;111611:43:0::1;::::0;::::1;20948:21:1::0;21005:2;20985:18;;;20978:30;-1:-1:-1;;;21024:18:1;;;21017:46;21080:18;;111611:43:0::1;20764:340:1::0;111760:853:0;111833:16;111862:23;111907:15;111902:243;75351:12;;75141:7;75335:13;:28;111928:7;:23;111902:243;;;111979:19;112001:20;;;:11;:20;;;;;112040:14;;;;-1:-1:-1;;;112040:14:0;;;;:40;;;;-1:-1:-1;112058:12:0;;;;-1:-1:-1;;;;;112058:22:0;;;:12;;:22;112040:40;112036:98;;;112101:17;;;;:::i;:::-;;;;112036:98;-1:-1:-1;111953:9:0;;;;:::i;:::-;;;;111902:243;;;;112157:29;112203:15;-1:-1:-1;;;;;112189:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;112189:30:0;;112157:62;;112230:24;112276:15;112271:303;75351:12;;75141:7;75335:13;:28;112297:7;:23;112271:303;;;112348:19;112370:20;;;:11;:20;;;;;112409:14;;;;-1:-1:-1;;;112409:14:0;;;;:40;;;;-1:-1:-1;112427:12:0;;;;-1:-1:-1;;;;;112427:22:0;;;:12;;:22;112409:40;112405:158;;;112503:7;112470:12;112483:16;112470:30;;;;;;;;:::i;:::-;;;;;;;;;;:40;112529:18;;;;:::i;:::-;;;;112405:158;-1:-1:-1;112322:9:0;;;;:::i;:::-;;;;112271:303;;105893:229;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;106023:2:::1;105996:23;:29;;105988:70;;;::::0;-1:-1:-1;;;105988:70:0;;21311:2:1;105988:70:0::1;::::0;::::1;21293:21:1::0;21350:2;21330:18;;;21323:30;21389;21369:18;;;21362:58;21437:18;;105988:70:0::1;21109:352:1::0;105988:70:0::1;106069:19;:45:::0;105893:229::o;79130:104::-;79186:13;79219:7;79212:14;;;;;:::i;102252:165::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;102331:9:::1;102326:84;102346:14:::0;;::::1;102326:84;;;102378:20;102388:3;;102392:1;102388:6;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;102396:1;102378:9;:20::i;:::-;102362:3:::0;::::1;::::0;::::1;:::i;:::-;;;;102326:84;;103207:751:::0;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;103286:12:::1;::::0;::::1;;103278:38;;;::::0;-1:-1:-1;;;103278:38:0;;21668:2:1;103278:38:0::1;::::0;::::1;21650:21:1::0;21707:2;21687:18;;;21680:30;-1:-1:-1;;;21726:18:1;;;21719:43;21779:18;;103278:38:0::1;21466:337:1::0;103278:38:0::1;103384:11;::::0;103357:10:::1;103337:31;::::0;;;:19:::1;:31;::::0;;;;;:40:::1;::::0;103371:6;;103337:40:::1;:::i;:::-;103335:60;;103327:110;;;::::0;-1:-1:-1;;;103327:110:0;;22010:2:1;103327:110:0::1;::::0;::::1;21992:21:1::0;22049:2;22029:18;;;22022:30;22088:34;22068:18;;;22061:62;-1:-1:-1;;;22139:18:1;;;22132:34;22183:19;;103327:110:0::1;21808:400:1::0;103327:110:0::1;103498:9;;103488:6;103472:13;75351:12:::0;;75141:7;75335:13;:28;;75097:303;103472:13:::1;:22;;;;:::i;:::-;:35;;103450:93;;;;-1:-1:-1::0;;;103450:93:0::1;;;;;;;:::i;:::-;103600:14;;103590:6;103576:11;;:20;;;;:::i;:::-;:38;;103554:103;;;::::0;-1:-1:-1;;;103554:103:0;;22415:2:1;103554:103:0::1;::::0;::::1;22397:21:1::0;22454:2;22434:18;;;22427:30;-1:-1:-1;;;22473:18:1;;;22466:45;22528:18;;103554:103:0::1;22213:339:1::0;103554:103:0::1;103712:9;103702:6;103690:9;;:18;;;;:::i;:::-;:31;;103668:102;;;::::0;-1:-1:-1;;;103668:102:0;;22759:2:1;103668:102:0::1;::::0;::::1;22741:21:1::0;22798:2;22778:18;;;22771:30;-1:-1:-1;;;22817:18:1;;;22810:51;22878:18;;103668:102:0::1;22557:345:1::0;103668:102:0::1;103800:6;103785:11;;:21;;;;;;;:::i;:::-;;;;;;;;103837:9;103821:12;;:25;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;103861:29:0::1;::::0;-1:-1:-1;103871:10:0::1;103883:6:::0;103861:9:::1;:29::i;:::-;103925:10;103905:31;::::0;;;:19:::1;:31;::::0;;;;:41;;103940:6;;103905:31;:41:::1;::::0;103940:6;;103905:41:::1;:::i;:::-;::::0;;;-1:-1:-1;;70661:1:0;71615:7;:22;-1:-1:-1;103207:751:0:o;80748:287::-;33209:10;-1:-1:-1;;;;;80847:24:0;;;80843:54;;80880:17;;-1:-1:-1;;;80880:17:0;;;;;;;;;;;80843:54;33209:10;80910:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;80910:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;80910:53:0;;;;;;;;;;80979:48;;1177:41:1;;;80910:42:0;;33209:10;80979:48;;1150:18:1;80979:48:0;;;;;;;80748:287;;:::o;103966:122::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;104048:14:::1;:32:::0;103966:122::o;81834:369::-;82001:28;82011:4;82017:2;82021:7;82001:9;:28::i;:::-;-1:-1:-1;;;;;82044:13:0;;25554:20;25602:8;;82044:76;;;;;82064:56;82095:4;82101:2;82105:7;82114:5;82064:30;:56::i;:::-;82063:57;82044:76;82040:156;;;82144:40;;-1:-1:-1;;;82144:40:0;;;;;;;;;;;82040:156;81834:369;;;;:::o;105370:97::-;105419:7;105446:13;75351:12;;75141:7;75335:13;:28;;75097:303;105446:13;105439:20;;105370:97;:::o;110301:993::-;70705:1;71303:7;;:19;71295:63;;;;-1:-1:-1;;;71295:63:0;;;;;;;:::i;:::-;70705:1;71436:7;:18;110381:17:::1;110389:8:::0;110381:7:::1;:17::i;:::-;110373:50;;;;-1:-1:-1::0;;;110373:50:0::1;;;;;;;:::i;:::-;110436:27;110466:21:::0;;;:11:::1;:21;::::0;;;;110508:22:::1;::::0;::::1;::::0;-1:-1:-1;;;110508:22:0;::::1;;;110500:50;;;::::0;-1:-1:-1;;;110500:50:0;;23109:2:1;110500:50:0::1;::::0;::::1;23091:21:1::0;23148:2;23128:18;;;23121:30;-1:-1:-1;;;23167:18:1;;;23160:45;23222:18;;110500:50:0::1;22907:339:1::0;110500:50:0::1;110590:10;110569:17;110577:8:::0;110569:7:::1;:17::i;:::-;-1:-1:-1::0;;;;;110569:31:0::1;;110561:71;;;::::0;-1:-1:-1;;;110561:71:0;;12245:2:1;110561:71:0::1;::::0;::::1;12227:21:1::0;12284:2;12264:18;;;12257:30;12323:29;12303:18;;;12296:57;12370:18;;110561:71:0::1;12043:351:1::0;110561:71:0::1;110657:22;::::0;::::1;:30:::0;;-1:-1:-1;;;;110657:30:0::1;::::0;;110778:19:::1;::::0;110755:20;;110682:5:::1;::::0;110801:3:::1;::::0;110755:42:::1;::::0;110778:19;110755:42:::1;:::i;:::-;110754:50;;;;:::i;:::-;110728:76;;110815:20;110860:15;110838:13;:20;;;:37;;;;:::i;:::-;110946:23;::::0;;;:13:::1;:23;::::0;;;;:32;110815:60;;-1:-1:-1;110946:32:0::1;;110942:105;;;111030:5;110995:23:::0;;;:13:::1;:23;::::0;;;;:40;;-1:-1:-1;;110995:40:0::1;::::0;;110942:105:::1;111090:20;::::0;::::1;::::0;111061:60:::1;::::0;111078:10:::1;::::0;-1:-1:-1;;;;;111090:20:0::1;111112:8:::0;111061:16:::1;:60::i;:::-;111132:42;::::0;111140:10:::1;::::0;111132:42;::::1;;;::::0;111161:12;;111132:42:::1;::::0;;;111161:12;111140:10;111132:42;::::1;;;;;;;;;;;;;::::0;::::1;;;;105710:173:::0;105775:13;105831:23;105846:7;105831:14;:23::i;:::-;105814:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;105800:65;;105710:173;;;:::o;81106:164::-;-1:-1:-1;;;;;81227:25:0;;;81203:4;81227:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;81106:164::o;101262:49::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;113532:802::-;113603:16;113632:21;113694:1;113670:225;113709:7;;113697:8;:19;113670:225;;113745:15;113763:14;;;:4;:14;;;;;113796:12;;;;-1:-1:-1;;;113796:12:0;;;;:36;;;;-1:-1:-1;113812:10:0;;;;-1:-1:-1;;;;;113812:20:0;;;:10;;:20;113796:36;113792:92;;;113853:15;;;;:::i;:::-;;;;113792:92;-1:-1:-1;113718:10:0;;;;:::i;:::-;;;;113670:225;;;;113907:27;113951:13;-1:-1:-1;;;;;113937:28:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;113937:28:0;-1:-1:-1;113907:58:0;-1:-1:-1;113976:22:0;114039:1;114015:282;114054:7;;114042:8;:19;114015:282;;114090:15;114108:14;;;:4;:14;;;;;114141:12;;;;-1:-1:-1;;;114141:12:0;;;;:36;;;;-1:-1:-1;114157:10:0;;;;-1:-1:-1;;;;;114157:20:0;;;:10;;:20;114141:36;114137:149;;;114227:8;114198:10;114209:14;114198:26;;;;;;;;:::i;:::-;;;;;;;;;;:37;114254:16;;;;:::i;:::-;;;;114137:149;-1:-1:-1;114063:10:0;;;;:::i;:::-;;;;114015:282;;108001:320;108083:9;108078:236;108102:9;:16;108098:1;:20;108078:236;;;108162:13;:27;108176:9;108186:1;108176:12;;;;;;;;:::i;:::-;;;;;;;108162:27;;;;;;;;;;;:34;;;;;;;;;;-1:-1:-1;;;;;108162:34:0;-1:-1:-1;;;;;108148:48:0;:10;-1:-1:-1;;;;;108148:48:0;;108140:75;;;;-1:-1:-1;;;108140:75:0;;23914:2:1;108140:75:0;;;23896:21:1;23953:2;23933:18;;;23926:30;-1:-1:-1;;;23972:18:1;;;23965:44;24026:18;;108140:75:0;23712:338:1;108140:75:0;108269:5;108230:13;:27;108244:9;108254:1;108244:12;;;;;;;;:::i;:::-;;;;;;;;;;;;108230:27;;;;;;;;;;-1:-1:-1;108230:27:0;:44;;-1:-1:-1;;108230:44:0;;;;;;;;;;108120:3;;;;:::i;:::-;;;;108078:236;;108752:245;108820:1;108808:9;:13;108800:59;;;;-1:-1:-1;;;108800:59:0;;24257:2:1;108800:59:0;;;24239:21:1;24296:2;24276:18;;;24269:30;24335:34;24315:18;;;24308:62;-1:-1:-1;;;24386:18:1;;;24379:31;24427:19;;108800:59:0;24055:397:1;108800:59:0;108872:7;:9;;;:7;:9;;;:::i;:::-;;;;-1:-1:-1;;108908:32:0;;;;;;;;108912:9;108908:32;;108923:10;108908:32;;;;;;;108935:4;108908:32;;;;;;108897:7;;;-1:-1:-1;108892:13:0;;;:4;:13;;;;;:48;;;;;;;;;;;;;;;-1:-1:-1;;;108892:48:0;-1:-1:-1;;;;;;108892:48:0;;;-1:-1:-1;;;;;108892:48:0;;;;;;;;;;;;;;;108951:24;;;:12;:24;;;;;108981:7;;108951:38;;;;;;;;;;;;;;;;;108752:245::o;66229:201::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66318:22:0;::::1;66310:73;;;::::0;-1:-1:-1;;;66310:73:0;;24659:2:1;66310:73:0::1;::::0;::::1;24641:21:1::0;24698:2;24678:18;;;24671:30;24737:34;24717:18;;;24710:62;-1:-1:-1;;;24788:18:1;;;24781:36;24834:19;;66310:73:0::1;24457:402:1::0;66310:73:0::1;66394:28;66413:8;66394:18;:28::i;:::-;66229:201:::0;:::o;104418:102::-;65393:6;;-1:-1:-1;;;;;65393:6:0;33209:10;65540:23;65532:68;;;;-1:-1:-1;;;65532:68:0;;;;;;;:::i;:::-;104490:9:::1;:22:::0;104418:102::o;108331:413::-;108453:7;:14;108433:9;:16;:34;108425:71;;;;-1:-1:-1;;;108425:71:0;;25066:2:1;108425:71:0;;;25048:21:1;25105:2;25085:18;;;25078:30;25144:26;25124:18;;;25117:54;25188:18;;108425:71:0;24864:348:1;108425:71:0;108514:9;108509:228;108533:9;:16;108529:1;:20;108509:228;;;108604:10;-1:-1:-1;;;;;108579:35:0;:21;108587:9;108597:1;108587:12;;;;;;;;:::i;:::-;;;;;;;108579:7;:21::i;:::-;-1:-1:-1;;;;;108579:35:0;;108571:67;;;;-1:-1:-1;;;108571:67:0;;25419:2:1;108571:67:0;;;25401:21:1;25458:2;25438:18;;;25431:30;-1:-1:-1;;;25477:18:1;;;25470:49;25536:18;;108571:67:0;25217:343:1;108571:67:0;108683:42;;;;;;;;108696:4;108683:42;;;;;;108702:10;-1:-1:-1;;;;;108683:42:0;;;;;108714:7;108722:1;108714:10;;;;;;;;:::i;:::-;;;;;;;108683:42;;;108653:13;:27;108667:9;108677:1;108667:12;;;;;;;;:::i;:::-;;;;;;;;;;;;108653:27;;;;;;;;;;;;;-1:-1:-1;108653:27:0;:72;;;;;;;;-1:-1:-1;;;;;;108653:72:0;;;;;;-1:-1:-1;;;;;;108653:72:0;;;-1:-1:-1;;;;;108653:72:0;;;;;;;;;;;;;;;;;;-1:-1:-1;108653:72:0;;;;108551:3;;;;:::i;:::-;;;;108509:228;;82458:187;82515:4;82579:13;;82569:7;:23;82539:98;;;;-1:-1:-1;;82610:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;82610:27:0;;;;82609:28;;82458:187::o;90628:197::-;90744:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;90744:29:0;-1:-1:-1;;;;;90744:29:0;;;;;;;;;90789:28;;90744:24;;90789:28;;;;;;;90628:197;;;:::o;82653:104::-;82722:27;82732:2;82736:8;82722:27;;;;;;;;;;;;:9;:27::i;85571:2130::-;85686:35;85724:21;85737:7;85724:12;:21::i;:::-;85686:59;;85784:4;-1:-1:-1;;;;;85762:26:0;:13;:18;;;-1:-1:-1;;;;;85762:26:0;;85758:67;;85797:28;;-1:-1:-1;;;85797:28:0;;;;;;;;;;;85758:67;85838:22;33209:10;-1:-1:-1;;;;;85864:20:0;;;;:73;;-1:-1:-1;85901:36:0;85918:4;33209:10;81106:164;:::i;85901:36::-;85864:126;;;-1:-1:-1;33209:10:0;85954:20;85966:7;85954:11;:20::i;:::-;-1:-1:-1;;;;;85954:36:0;;85864:126;85838:153;;86009:17;86004:66;;86035:35;;-1:-1:-1;;;86035:35:0;;;;;;;;;;;86004:66;-1:-1:-1;;;;;86085:16:0;;86081:52;;86110:23;;-1:-1:-1;;;86110:23:0;;;;;;;;;;;86081:52;86254:35;86271:1;86275:7;86284:4;86254:8;:35::i;:::-;-1:-1:-1;;;;;86585:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;86585:31:0;;;-1:-1:-1;;;;;86585:31:0;;;-1:-1:-1;;86585:31:0;;;;;;;86631:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;86631:29:0;;;;;;;;;;;86711:20;;;:11;:20;;;;;;86746:18;;-1:-1:-1;;;;;;86779:49:0;;;;-1:-1:-1;;;86812:15:0;86779:49;;;;;;;;;;87102:11;;87162:24;;;;;87205:13;;86711:20;;87162:24;;87205:13;87201:384;;87415:13;;87400:11;:28;87396:174;;87453:20;;87522:28;;;;-1:-1:-1;;;;;87496:54:0;-1:-1:-1;;;87496:54:0;-1:-1:-1;;;;;;87496:54:0;;;-1:-1:-1;;;;;87453:20:0;;87496:54;;;;87396:174;86560:1036;;;87632:7;87628:2;-1:-1:-1;;;;;87613:27:0;87622:4;-1:-1:-1;;;;;87613:27:0;;;;;;;;;;;87651:42;85675:2026;;85571:2130;;;:::o;77598:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;77709:7:0;77792:13;;77785:4;:20;77754:886;;;77826:31;77860:17;;;:11;:17;;;;;;;;;77826:51;;;;;;;;;-1:-1:-1;;;;;77826:51:0;;;;-1:-1:-1;;;77826:51:0;;-1:-1:-1;;;;;77826:51:0;;;;;;;;-1:-1:-1;;;77826:51:0;;;;;;;;;;;;;;77896:729;;77946:14;;-1:-1:-1;;;;;77946:28:0;;77942:101;;78010:9;77598:1109;-1:-1:-1;;;77598:1109:0:o;77942:101::-;-1:-1:-1;;;78385:6:0;78430:17;;;;:11;:17;;;;;;;;;78418:29;;;;;;;;;-1:-1:-1;;;;;78418:29:0;;;;;-1:-1:-1;;;78418:29:0;;-1:-1:-1;;;;;78418:29:0;;;;;;;;-1:-1:-1;;;78418:29:0;;;;;;;;;;;;;78478:28;78474:109;;78546:9;77598:1109;-1:-1:-1;;;77598:1109:0:o;78474:109::-;78345:261;;;77807:833;77754:886;78668:31;;-1:-1:-1;;;78668:31:0;;;;;;;;;;;66590:191;66683:6;;;-1:-1:-1;;;;;66700:17:0;;;-1:-1:-1;;;;;;66700:17:0;;;;;;;66733:40;;66683:6;;;66700:17;66683:6;;66733:40;;66664:16;;66733:40;66653:128;66590:191;:::o;91317:667::-;91501:72;;-1:-1:-1;;;91501:72:0;;91480:4;;-1:-1:-1;;;;;91501:36:0;;;;;:72;;33209:10;;91552:4;;91558:7;;91567:5;;91501:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;91501:72:0;;;;;;;;-1:-1:-1;;91501:72:0;;;;;;;;;;;;:::i;:::-;;;91497:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91735:6;:13;91752:1;91735:18;91731:235;;91781:40;;-1:-1:-1;;;91781:40:0;;;;;;;;;;;91731:235;91924:6;91918:13;91909:6;91905:2;91901:15;91894:38;91497:480;-1:-1:-1;;;;;;91620:55:0;-1:-1:-1;;;91620:55:0;;-1:-1:-1;91497:480:0;91317:667;;;;;;:::o;79305:318::-;79378:13;79409:16;79417:7;79409;:16::i;:::-;79404:59;;79434:29;;-1:-1:-1;;;79434:29:0;;;;;;;;;;;79404:59;79476:21;79500:10;:8;:10::i;:::-;79476:34;;79534:7;79528:21;79553:1;79528:26;:87;;;;;;;;;;;;;;;;;79581:7;79590:18;:7;:16;:18::i;:::-;79564:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;79528:87;79521:94;79305:318;-1:-1:-1;;;79305:318:0:o;83120:163::-;83243:32;83249:2;83253:8;83263:5;83270:4;83243:5;:32::i;105587:114::-;105647:13;105680;105673:20;;;;;:::i;33596:723::-;33652:13;33873:5;33882:1;33873:10;33869:53;;-1:-1:-1;;33900:10:0;;;;;;;;;;;;-1:-1:-1;;;33900:10:0;;;;;33596:723::o;33869:53::-;33947:5;33932:12;33988:78;33995:9;;33988:78;;34021:8;;;;:::i;:::-;;-1:-1:-1;34044:10:0;;-1:-1:-1;34052:2:0;34044:10;;:::i;:::-;;;33988:78;;;34076:19;34108:6;-1:-1:-1;;;;;34098:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34098:17:0;;34076:39;;34126:154;34133:10;;34126:154;;34160:11;34170:1;34160:11;;:::i;:::-;;-1:-1:-1;34229:10:0;34237:2;34229:5;:10;:::i;:::-;34216:24;;:2;:24;:::i;:::-;34203:39;;34186:6;34193;34186:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;34186:56:0;;;;;;;;-1:-1:-1;34257:11:0;34266:2;34257:11;;:::i;:::-;;;34126:154;;83542:1775;83681:20;83704:13;-1:-1:-1;;;;;83732:16:0;;83728:48;;83757:19;;-1:-1:-1;;;83757:19:0;;;;;;;;;;;83728:48;83791:8;83803:1;83791:13;83787:44;;83813:18;;-1:-1:-1;;;83813:18:0;;;;;;;;;;;83787:44;-1:-1:-1;;;;;84182:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;84241:49:0;;-1:-1:-1;;;;;84182:44:0;;;;;;;84241:49;;;;-1:-1:-1;;84182:44:0;;;;;;84241:49;;;;;;;;;;;;;;;;84307:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;84357:66:0;;;;-1:-1:-1;;;84407:15:0;84357:66;;;;;;;;;;84307:25;84504:23;;;84548:4;:23;;;;-1:-1:-1;;;;;;84556:13:0;;25554:20;25602:8;;84556:15;84544:641;;;84592:314;84623:38;;84648:12;;-1:-1:-1;;;;;84623:38:0;;;84640:1;;84623:38;;84640:1;;84623:38;84689:69;84728:1;84732:2;84736:14;;;;;;84752:5;84689:30;:69::i;:::-;84684:174;;84794:40;;-1:-1:-1;;;84794:40:0;;;;;;;;;;;84684:174;84901:3;84885:12;:19;84592:314;;84987:12;84970:13;;:29;84966:43;;85001:8;;;84966:43;84544:641;;;85050:120;85081:40;;85106:14;;;;;-1:-1:-1;;;;;85081:40:0;;;85098:1;;85081:40;;85098:1;;85081:40;85165:3;85149:12;:19;85050:120;;84544:641;-1:-1:-1;85199:13:0;:28;85249:60;81834:369;14:632:1;185:2;237:21;;;307:13;;210:18;;;329:22;;;156:4;;185:2;408:15;;;;382:2;367:18;;;156:4;451:169;465:6;462:1;459:13;451:169;;;526:13;;514:26;;595:15;;;;560:12;;;;487:1;480:9;451:169;;;-1:-1:-1;637:3:1;;14:632;-1:-1:-1;;;;;;14:632:1:o;651:131::-;-1:-1:-1;;;;;;725:32:1;;715:43;;705:71;;772:1;769;762:12;787:245;845:6;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;953:9;940:23;972:30;996:5;972:30;:::i;1229:248::-;1297:6;1305;1358:2;1346:9;1337:7;1333:23;1329:32;1326:52;;;1374:1;1371;1364:12;1326:52;-1:-1:-1;;1397:23:1;;;1467:2;1452:18;;;1439:32;;-1:-1:-1;1229:248:1:o;1482:250::-;1567:1;1577:113;1591:6;1588:1;1585:13;1577:113;;;1667:11;;;1661:18;1648:11;;;1641:39;1613:2;1606:10;1577:113;;;-1:-1:-1;;1724:1:1;1706:16;;1699:27;1482:250::o;1737:271::-;1779:3;1817:5;1811:12;1844:6;1839:3;1832:19;1860:76;1929:6;1922:4;1917:3;1913:14;1906:4;1899:5;1895:16;1860:76;:::i;:::-;1990:2;1969:15;-1:-1:-1;;1965:29:1;1956:39;;;;1997:4;1952:50;;1737:271;-1:-1:-1;;1737:271:1:o;2013:220::-;2162:2;2151:9;2144:21;2125:4;2182:45;2223:2;2212:9;2208:18;2200:6;2182:45;:::i;2238:180::-;2297:6;2350:2;2338:9;2329:7;2325:23;2321:32;2318:52;;;2366:1;2363;2356:12;2318:52;-1:-1:-1;2389:23:1;;2238:180;-1:-1:-1;2238:180:1:o;2631:131::-;-1:-1:-1;;;;;2706:31:1;;2696:42;;2686:70;;2752:1;2749;2742:12;2767:315;2835:6;2843;2896:2;2884:9;2875:7;2871:23;2867:32;2864:52;;;2912:1;2909;2902:12;2864:52;2951:9;2938:23;2970:31;2995:5;2970:31;:::i;:::-;3020:5;3072:2;3057:18;;;;3044:32;;-1:-1:-1;;;2767:315:1:o;3269:367::-;3332:8;3342:6;3396:3;3389:4;3381:6;3377:17;3373:27;3363:55;;3414:1;3411;3404:12;3363:55;-1:-1:-1;3437:20:1;;-1:-1:-1;;;;;3469:30:1;;3466:50;;;3512:1;3509;3502:12;3466:50;3549:4;3541:6;3537:17;3525:29;;3609:3;3602:4;3592:6;3589:1;3585:14;3577:6;3573:27;3569:38;3566:47;3563:67;;;3626:1;3623;3616:12;3563:67;3269:367;;;;;:::o;3641:505::-;3736:6;3744;3752;3805:2;3793:9;3784:7;3780:23;3776:32;3773:52;;;3821:1;3818;3811:12;3773:52;3861:9;3848:23;-1:-1:-1;;;;;3886:6:1;3883:30;3880:50;;;3926:1;3923;3916:12;3880:50;3965:70;4027:7;4018:6;4007:9;4003:22;3965:70;:::i;:::-;4054:8;;3939:96;;-1:-1:-1;4136:2:1;4121:18;;;;4108:32;;3641:505;-1:-1:-1;;;;3641:505:1:o;4151:456::-;4228:6;4236;4244;4297:2;4285:9;4276:7;4272:23;4268:32;4265:52;;;4313:1;4310;4303:12;4265:52;4352:9;4339:23;4371:31;4396:5;4371:31;:::i;:::-;4421:5;-1:-1:-1;4478:2:1;4463:18;;4450:32;4491:33;4450:32;4491:33;:::i;:::-;4151:456;;4543:7;;-1:-1:-1;;;4597:2:1;4582:18;;;;4569:32;;4151:456::o;4612:247::-;4671:6;4724:2;4712:9;4703:7;4699:23;4695:32;4692:52;;;4740:1;4737;4730:12;4692:52;4779:9;4766:23;4798:31;4823:5;4798:31;:::i;5224:127::-;5285:10;5280:3;5276:20;5273:1;5266:31;5316:4;5313:1;5306:15;5340:4;5337:1;5330:15;5356:275;5427:2;5421:9;5492:2;5473:13;;-1:-1:-1;;5469:27:1;5457:40;;-1:-1:-1;;;;;5512:34:1;;5548:22;;;5509:62;5506:88;;;5574:18;;:::i;:::-;5610:2;5603:22;5356:275;;-1:-1:-1;5356:275:1:o;5636:407::-;5701:5;-1:-1:-1;;;;;5727:6:1;5724:30;5721:56;;;5757:18;;:::i;:::-;5795:57;5840:2;5819:15;;-1:-1:-1;;5815:29:1;5846:4;5811:40;5795:57;:::i;:::-;5786:66;;5875:6;5868:5;5861:21;5915:3;5906:6;5901:3;5897:16;5894:25;5891:45;;;5932:1;5929;5922:12;5891:45;5981:6;5976:3;5969:4;5962:5;5958:16;5945:43;6035:1;6028:4;6019:6;6012:5;6008:18;6004:29;5997:40;5636:407;;;;;:::o;6048:451::-;6117:6;6170:2;6158:9;6149:7;6145:23;6141:32;6138:52;;;6186:1;6183;6176:12;6138:52;6226:9;6213:23;-1:-1:-1;;;;;6251:6:1;6248:30;6245:50;;;6291:1;6288;6281:12;6245:50;6314:22;;6367:4;6359:13;;6355:27;-1:-1:-1;6345:55:1;;6396:1;6393;6386:12;6345:55;6419:74;6485:7;6480:2;6467:16;6462:2;6458;6454:11;6419:74;:::i;6504:437::-;6590:6;6598;6651:2;6639:9;6630:7;6626:23;6622:32;6619:52;;;6667:1;6664;6657:12;6619:52;6707:9;6694:23;-1:-1:-1;;;;;6732:6:1;6729:30;6726:50;;;6772:1;6769;6762:12;6726:50;6811:70;6873:7;6864:6;6853:9;6849:22;6811:70;:::i;:::-;6900:8;;6785:96;;-1:-1:-1;6504:437:1;-1:-1:-1;;;;6504:437:1:o;6946:416::-;7011:6;7019;7072:2;7060:9;7051:7;7047:23;7043:32;7040:52;;;7088:1;7085;7078:12;7040:52;7127:9;7114:23;7146:31;7171:5;7146:31;:::i;:::-;7196:5;-1:-1:-1;7253:2:1;7238:18;;7225:32;7295:15;;7288:23;7276:36;;7266:64;;7326:1;7323;7316:12;7266:64;7349:7;7339:17;;;6946:416;;;;;:::o;7367:795::-;7462:6;7470;7478;7486;7539:3;7527:9;7518:7;7514:23;7510:33;7507:53;;;7556:1;7553;7546:12;7507:53;7595:9;7582:23;7614:31;7639:5;7614:31;:::i;:::-;7664:5;-1:-1:-1;7721:2:1;7706:18;;7693:32;7734:33;7693:32;7734:33;:::i;:::-;7786:7;-1:-1:-1;7840:2:1;7825:18;;7812:32;;-1:-1:-1;7895:2:1;7880:18;;7867:32;-1:-1:-1;;;;;7911:30:1;;7908:50;;;7954:1;7951;7944:12;7908:50;7977:22;;8030:4;8022:13;;8018:27;-1:-1:-1;8008:55:1;;8059:1;8056;8049:12;8008:55;8082:74;8148:7;8143:2;8130:16;8125:2;8121;8117:11;8082:74;:::i;:::-;8072:84;;;7367:795;;;;;;;:::o;8527:388::-;8595:6;8603;8656:2;8644:9;8635:7;8631:23;8627:32;8624:52;;;8672:1;8669;8662:12;8624:52;8711:9;8698:23;8730:31;8755:5;8730:31;:::i;:::-;8780:5;-1:-1:-1;8837:2:1;8822:18;;8809:32;8850:33;8809:32;8850:33;:::i;8920:712::-;8974:5;9027:3;9020:4;9012:6;9008:17;9004:27;8994:55;;9045:1;9042;9035:12;8994:55;9081:6;9068:20;9107:4;-1:-1:-1;;;;;9126:2:1;9123:26;9120:52;;;9152:18;;:::i;:::-;9198:2;9195:1;9191:10;9221:28;9245:2;9241;9237:11;9221:28;:::i;:::-;9283:15;;;9353;;;9349:24;;;9314:12;;;;9385:15;;;9382:35;;;9413:1;9410;9403:12;9382:35;9449:2;9441:6;9437:15;9426:26;;9461:142;9477:6;9472:3;9469:15;9461:142;;;9543:17;;9531:30;;9494:12;;;;9581;;;;9461:142;;;9621:5;8920:712;-1:-1:-1;;;;;;;8920:712:1:o;9637:348::-;9721:6;9774:2;9762:9;9753:7;9749:23;9745:32;9742:52;;;9790:1;9787;9780:12;9742:52;9830:9;9817:23;-1:-1:-1;;;;;9855:6:1;9852:30;9849:50;;;9895:1;9892;9885:12;9849:50;9918:61;9971:7;9962:6;9951:9;9947:22;9918:61;:::i;9990:595::-;10108:6;10116;10169:2;10157:9;10148:7;10144:23;10140:32;10137:52;;;10185:1;10182;10175:12;10137:52;10225:9;10212:23;-1:-1:-1;;;;;10295:2:1;10287:6;10284:14;10281:34;;;10311:1;10308;10301:12;10281:34;10334:61;10387:7;10378:6;10367:9;10363:22;10334:61;:::i;:::-;10324:71;;10448:2;10437:9;10433:18;10420:32;10404:48;;10477:2;10467:8;10464:16;10461:36;;;10493:1;10490;10483:12;10461:36;;10516:63;10571:7;10560:8;10549:9;10545:24;10516:63;:::i;:::-;10506:73;;;9990:595;;;;;:::o;10590:127::-;10651:10;10646:3;10642:20;10639:1;10632:31;10682:4;10679:1;10672:15;10706:4;10703:1;10696:15;10722:135;10761:3;10782:17;;;10779:43;;10802:18;;:::i;:::-;-1:-1:-1;10849:1:1;10838:13;;10722:135::o;10862:127::-;10923:10;10918:3;10914:20;10911:1;10904:31;10954:4;10951:1;10944:15;10978:4;10975:1;10968:15;10994:355;11196:2;11178:21;;;11235:2;11215:18;;;11208:30;11274:33;11269:2;11254:18;;11247:61;11340:2;11325:18;;10994:355::o;12399:168::-;12472:9;;;12503;;12520:15;;;12514:22;;12500:37;12490:71;;12541:18;;:::i;12572:127::-;12633:10;12628:3;12624:20;12621:1;12614:31;12664:4;12661:1;12654:15;12688:4;12685:1;12678:15;12704:120;12744:1;12770;12760:35;;12775:18;;:::i;:::-;-1:-1:-1;12809:9:1;;12704:120::o;12829:128::-;12896:9;;;12917:11;;;12914:37;;;12931:18;;:::i;12962:356::-;13164:2;13146:21;;;13183:18;;;13176:30;13242:34;13237:2;13222:18;;13215:62;13309:2;13294:18;;12962:356::o;13323:380::-;13402:1;13398:12;;;;13445;;;13466:61;;13520:4;13512:6;13508:17;13498:27;;13466:61;13573:2;13565:6;13562:14;13542:18;13539:38;13536:161;;13619:10;13614:3;13610:20;13607:1;13600:31;13654:4;13651:1;13644:15;13682:4;13679:1;13672:15;13536:161;;13323:380;;;:::o;14400:125::-;14465:9;;;14486:10;;;14483:36;;;14499:18;;:::i;14530:331::-;14732:2;14714:21;;;14771:1;14751:18;;;14744:29;-1:-1:-1;;;14804:2:1;14789:18;;14782:38;14852:2;14837:18;;14530:331::o;14866:184::-;14936:6;14989:2;14977:9;14968:7;14964:23;14960:32;14957:52;;;15005:1;15002;14995:12;14957:52;-1:-1:-1;15028:16:1;;14866:184;-1:-1:-1;14866:184:1:o;15402:251::-;15472:6;15525:2;15513:9;15504:7;15500:23;15496:32;15493:52;;;15541:1;15538;15531:12;15493:52;15573:9;15567:16;15592:31;15617:5;15592:31;:::i;16000:344::-;16202:2;16184:21;;;16241:2;16221:18;;;16214:30;-1:-1:-1;;;16275:2:1;16260:18;;16253:50;16335:2;16320:18;;16000:344::o;18336:545::-;18438:2;18433:3;18430:11;18427:448;;;18474:1;18499:5;18495:2;18488:17;18544:4;18540:2;18530:19;18614:2;18602:10;18598:19;18595:1;18591:27;18585:4;18581:38;18650:4;18638:10;18635:20;18632:47;;;-1:-1:-1;18673:4:1;18632:47;18728:2;18723:3;18719:12;18716:1;18712:20;18706:4;18702:31;18692:41;;18783:82;18801:2;18794:5;18791:13;18783:82;;;18846:17;;;18827:1;18816:13;18783:82;;;18787:3;;;18336:545;;;:::o;19057:1352::-;19183:3;19177:10;-1:-1:-1;;;;;19202:6:1;19199:30;19196:56;;;19232:18;;:::i;:::-;19261:97;19351:6;19311:38;19343:4;19337:11;19311:38;:::i;:::-;19305:4;19261:97;:::i;:::-;19413:4;;19477:2;19466:14;;19494:1;19489:663;;;;20196:1;20213:6;20210:89;;;-1:-1:-1;20265:19:1;;;20259:26;20210:89;-1:-1:-1;;19014:1:1;19010:11;;;19006:24;19002:29;18992:40;19038:1;19034:11;;;18989:57;20312:81;;19459:944;;19489:663;18283:1;18276:14;;;18320:4;18307:18;;-1:-1:-1;;19525:20:1;;;19643:236;19657:7;19654:1;19651:14;19643:236;;;19746:19;;;19740:26;19725:42;;19838:27;;;;19806:1;19794:14;;;;19673:19;;19643:236;;;19647:3;19907:6;19898:7;19895:19;19892:201;;;19968:19;;;19962:26;-1:-1:-1;;20051:1:1;20047:14;;;20063:3;20043:24;20039:37;20035:42;20020:58;20005:74;;19892:201;-1:-1:-1;;;;;20139:1:1;20123:14;;;20119:22;20106:36;;-1:-1:-1;19057:1352:1:o;23251:456::-;23483:3;23521:6;23515:13;23537:66;23596:6;23591:3;23584:4;23576:6;23572:17;23537:66;:::i;:::-;-1:-1:-1;;;23625:16:1;;23650:22;;;-1:-1:-1;23699:1:1;23688:13;;23251:456;-1:-1:-1;23251:456:1:o;25565:489::-;-1:-1:-1;;;;;25834:15:1;;;25816:34;;25886:15;;25881:2;25866:18;;25859:43;25933:2;25918:18;;25911:34;;;25981:3;25976:2;25961:18;;25954:31;;;25759:4;;26002:46;;26028:19;;26020:6;26002:46;:::i;:::-;25994:54;25565:489;-1:-1:-1;;;;;;25565:489:1:o;26059:249::-;26128:6;26181:2;26169:9;26160:7;26156:23;26152:32;26149:52;;;26197:1;26194;26187:12;26149:52;26229:9;26223:16;26248:30;26272:5;26248:30;:::i;26313:496::-;26492:3;26530:6;26524:13;26546:66;26605:6;26600:3;26593:4;26585:6;26581:17;26546:66;:::i;:::-;26675:13;;26634:16;;;;26697:70;26675:13;26634:16;26744:4;26732:17;;26697:70;:::i;:::-;26783:20;;26313:496;-1:-1:-1;;;;26313:496:1:o;26814:112::-;26846:1;26872;26862:35;;26877:18;;:::i;:::-;-1:-1:-1;26911:9:1;;26814:112::o

Swarm Source

ipfs://b3f299bebe369f5dbe40975b0cd50c25b722583c00144eee651f9d27b50addea

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