Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-02-22
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.17;

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

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


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

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

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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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


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


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

pragma solidity ^0.8.17;


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

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

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

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


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

pragma solidity ^0.8.17;


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

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.17;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

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

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.17;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


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

pragma solidity ^0.8.17;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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


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

pragma solidity ^0.8.17;


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

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

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

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


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

pragma solidity ^0.8.17;

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


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


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

pragma solidity ^0.8.17;

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

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


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

pragma solidity ^0.8.17;

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

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: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

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

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

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

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

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

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

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {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 an {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 Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256, /* firstTokenId */
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.17;



/**
 * @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 See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.17;


/**
 * @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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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);
    }
}

// File: contracts/SatoshiPass.sol



pragma solidity ^0.8.17;



contract SatoshiPass is ERC721Enumerable, Ownable {
  using Strings for uint256;

  string public baseURI;
  string public baseExtension = ".json";
  string public notRevealedUri;
  uint256 public cost = 0.001 ether;
  uint256 public maxSupply = 111;
  uint256 public maxMintAmount = 1;
  uint256 public nftPerAddressLimit = 1;
  bool public paused = false;
  bool public revealed = false;
  bool public onlyWhitelisted = true;
  address payable commissions = payable(0x573F28dB9bA30EfbAc1992a50B40a9dca64fe771);
  address[] public whitelistedAddresses;
  mapping(address => uint256) public addressMintedBalance;

  constructor(
    string memory _name,
    string memory _symbol,
    string memory _initBaseURI,
    string memory _initNotRevealedUri
  ) ERC721(_name, _symbol) {
    setBaseURI(_initBaseURI);
    setNotRevealedURI(_initNotRevealedUri);
  }

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

  // public
  function mint(uint256 _mintAmount) public payable {
    require(!paused, "the contract is paused");
    uint256 supply = totalSupply();
    require(_mintAmount > 0, "need to mint at least 1 NFT");
    require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
    require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");

    if (msg.sender != owner()) {
        if(onlyWhitelisted == true) {
            require(isWhitelisted(msg.sender), "user is not whitelisted");
            uint256 ownerMintedCount = addressMintedBalance[msg.sender];
            require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
        }
        if(onlyWhitelisted == false) {
            uint256 ownerMintedCount = addressMintedBalance[msg.sender];
            require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "max NFT per address exceeded");
        }
        require(msg.value >= cost * _mintAmount, "insufficient funds");
    }

    for (uint256 i = 1; i <= _mintAmount; i++) {
      addressMintedBalance[msg.sender]++;
      _safeMint(msg.sender, supply + i);
    }
    
    (bool success, ) = payable(commissions).call{value: msg.value * 6 / 100}("");
    require(success);
  }
  
  function isWhitelisted(address _user) public view returns (bool) {
    for (uint i = 0; i < whitelistedAddresses.length; i++) {
      if (whitelistedAddresses[i] == _user) {
          return true;
      }
    }
    return false;
  }

  function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
  {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
      tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
  }

  function tokenURI(uint256 tokenId)
    public
    view
    virtual
    override
    returns (string memory)
  {
    require(
      _exists(tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );
    
    if(revealed == false) {
        return notRevealedUri;
    }

    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
        : "";
  }

  //only owner
  function reveal() public onlyOwner {
      revealed = true;
  }
  
  function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
    nftPerAddressLimit = _limit;
  }
  
  function setCost(uint256 _newCost) public onlyOwner {
    cost = _newCost;
  }

  function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
    maxMintAmount = _newmaxMintAmount;
  }

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

  function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
    baseExtension = _newBaseExtension;
  }
  
  function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
    notRevealedUri = _notRevealedURI;
  }

  function pause(bool _state) public onlyOwner {
    paused = _state;
  }
  
  function setOnlyWhitelisted(bool _state) public onlyOwner {
    onlyWhitelisted = _state;
  }
  
  function whitelistUsers(address[] calldata _users) public onlyOwner {
    delete whitelistedAddresses;
    whitelistedAddresses = _users;
  }
 
  function withdraw() public payable onlyOwner {

    (bool os, ) = payable(owner()).call{value: address(this).balance}("");
    require(os);
    
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_initBaseURI","type":"string"},{"internalType":"string","name":"_initNotRevealedUri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressMintedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","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":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","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":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftPerAddressLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"onlyWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setNftPerAddressLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setOnlyWhitelisted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_users","type":"address[]"}],"name":"whitelistUsers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"whitelistedAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000180000000000000000000000000000000000000000000000000000000000000000c5361746f7368692050617373000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055350415353000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d524d786d6d576d4e7846477272657a78504a525a547458595a504666433563417261756239416d444a736b552f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d524d786d6d576d4e7846477272657a78504a525a547458595a504666433563417261756239416d444a736b552f000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Satoshi Pass
Arg [1] : _symbol (string): SPASS
Arg [2] : _initBaseURI (string): https://gateway.pinata.cloud/ipfs/QmRMxmmWmNxFGrrezxPJRZTtXYZPFfC5cAraub9AmDJskU/
Arg [3] : _initNotRevealedUri (string): https://gateway.pinata.cloud/ipfs/QmRMxmmWmNxFGrrezxPJRZTtXYZPFfC5cAraub9AmDJskU/

-----Encoded View---------------
16 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [5] : 5361746f73686920506173730000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 5350415353000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [9] : 68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066
Arg [10] : 732f516d524d786d6d576d4e7846477272657a78504a525a547458595a504666
Arg [11] : 433563417261756239416d444a736b552f000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [13] : 68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066
Arg [14] : 732f516d524d786d6d576d4e7846477272657a78504a525a547458595a504666
Arg [15] : 433563417261756239416d444a736b552f000000000000000000000000000000

62532:4670:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53822:224;;;;;;;;;;-1:-1:-1;53822:224:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;53822:224:0;;;;;;;;66711:73;;;;;;;;;;-1:-1:-1;66711:73:0;;;;;:::i;:::-;;:::i;:::-;;37883:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;39395:171::-;;;;;;;;;;-1:-1:-1;39395:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2047:32:1;;;2029:51;;2017:2;2002:18;39395:171:0;1883:203:1;62687:28:0;;;;;;;;;;;;;:::i;38913:416::-;;;;;;;;;;-1:-1:-1;38913:416:0;;;;;:::i;:::-;;:::i;62720:33::-;;;;;;;;;;;;;;;;;;;2674:25:1;;;2662:2;2647:18;62720:33:0;2528:177:1;54462:113:0;;;;;;;;;;-1:-1:-1;54550:10:0;:17;54462:113;;63103:55;;;;;;;;;;-1:-1:-1;63103:55:0;;;;;:::i;:::-;;;;;;;;;;;;;;62793:32;;;;;;;;;;;;;;;;40095:335;;;;;;;;;;-1:-1:-1;40095:335:0;;;;;:::i;:::-;;:::i;54130:256::-;;;;;;;;;;-1:-1:-1;54130:256:0;;;;;:::i;:::-;;:::i;64840:239::-;;;;;;;;;;-1:-1:-1;64840:239:0;;;;;:::i;:::-;;:::i;66792:95::-;;;;;;;;;;-1:-1:-1;66792:95:0;;;;;:::i;:::-;;:::i;67046:153::-;;;:::i;40501:185::-;;;;;;;;;;-1:-1:-1;40501:185:0;;;;;:::i;:::-;;:::i;65085:348::-;;;;;;;;;;-1:-1:-1;65085:348:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;66143:80::-;;;;;;;;;;-1:-1:-1;66143:80:0;;;;;:::i;:::-;;:::i;54652:233::-;;;;;;;;;;-1:-1:-1;54652:233:0;;;;;:::i;:::-;;:::i;62903:28::-;;;;;;;;;;-1:-1:-1;62903:28:0;;;;;;;;;;;66351:98;;;;;;;;;;-1:-1:-1;66351:98:0;;;;;:::i;:::-;;:::i;62872:26::-;;;;;;;;;;-1:-1:-1;62872:26:0;;;;;;;;37593:223;;;;;;;;;;-1:-1:-1;37593:223:0;;;;;:::i;:::-;;:::i;62619:21::-;;;;;;;;;;;;;:::i;37324:207::-;;;;;;;;;;-1:-1:-1;37324:207:0;;;;;:::i;:::-;;:::i;61641:103::-;;;;;;;;;;;;;:::i;66229:116::-;;;;;;;;;;-1:-1:-1;66229:116:0;;;;;:::i;:::-;;:::i;60993:87::-;;;;;;;;;;-1:-1:-1;61066:6:0;;-1:-1:-1;;;;;61066:6:0;60993:87;;38052:104;;;;;;;;;;;;;:::i;62936:34::-;;;;;;;;;;-1:-1:-1;62936:34:0;;;;;;;;;;;63556:1276;;;;;;:::i;:::-;;:::i;39638:155::-;;;;;;;;;;-1:-1:-1;39638:155:0;;;;;:::i;:::-;;:::i;65958:65::-;;;;;;;;;;;;;:::i;40757:322::-;;;;;;;;;;-1:-1:-1;40757:322:0;;;;;:::i;:::-;;:::i;63061:37::-;;;;;;;;;;-1:-1:-1;63061:37:0;;;;;:::i;:::-;;:::i;62830:::-;;;;;;;;;;;;;;;;62645;;;;;;;;;;;;;:::i;65439:497::-;;;;;;;;;;-1:-1:-1;65439:497:0;;;;;:::i;:::-;;:::i;66031:104::-;;;;;;;;;;-1:-1:-1;66031:104:0;;;;;:::i;:::-;;:::i;62758:30::-;;;;;;;;;;;;;;;;66455:122;;;;;;;;;;-1:-1:-1;66455:122:0;;;;;:::i;:::-;;:::i;39864:164::-;;;;;;;;;;-1:-1:-1;39864:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;39985:25:0;;;39961:4;39985:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;39864:164;66895:144;;;;;;;;;;-1:-1:-1;66895:144:0;;;;;:::i;:::-;;:::i;66585:120::-;;;;;;;;;;-1:-1:-1;66585:120:0;;;;;:::i;:::-;;:::i;61899:201::-;;;;;;;;;;-1:-1:-1;61899:201:0;;;;;:::i;:::-;;:::i;53822:224::-;53924:4;-1:-1:-1;;;;;;53948:50:0;;-1:-1:-1;;;53948:50:0;;:90;;;54002:36;54026:11;54002:23;:36::i;:::-;53941:97;53822:224;-1:-1:-1;;53822:224:0:o;66711:73::-;60879:13;:11;:13::i;:::-;66763:6:::1;:15:::0;;-1:-1:-1;;66763:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;66711:73::o;37883:100::-;37937:13;37970:5;37963:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37883:100;:::o;39395:171::-;39471:7;39491:23;39506:7;39491:14;:23::i;:::-;-1:-1:-1;39534:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;39534:24:0;;39395:171::o;62687:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;38913:416::-;38994:13;39010:23;39025:7;39010:14;:23::i;:::-;38994:39;;39058:5;-1:-1:-1;;;;;39052:11:0;:2;-1:-1:-1;;;;;39052:11:0;;39044:57;;;;-1:-1:-1;;;39044:57:0;;7499:2:1;39044:57:0;;;7481:21:1;7538:2;7518:18;;;7511:30;7577:34;7557:18;;;7550:62;-1:-1:-1;;;7628:18:1;;;7621:31;7669:19;;39044:57:0;;;;;;;;;35846:10;-1:-1:-1;;;;;39136:21:0;;;;:62;;-1:-1:-1;39161:37:0;39178:5;35846:10;39864:164;:::i;39161:37::-;39114:173;;;;-1:-1:-1;;;39114:173:0;;7901:2:1;39114:173:0;;;7883:21:1;7940:2;7920:18;;;7913:30;7979:34;7959:18;;;7952:62;8050:31;8030:18;;;8023:59;8099:19;;39114:173:0;7699:425:1;39114:173:0;39300:21;39309:2;39313:7;39300:8;:21::i;:::-;38983:346;38913:416;;:::o;40095:335::-;40290:41;35846:10;40323:7;40290:18;:41::i;:::-;40282:99;;;;-1:-1:-1;;;40282:99:0;;;;;;;:::i;:::-;40394:28;40404:4;40410:2;40414:7;40394:9;:28::i;54130:256::-;54227:7;54263:23;54280:5;54263:16;:23::i;:::-;54255:5;:31;54247:87;;;;-1:-1:-1;;;54247:87:0;;8745:2:1;54247:87:0;;;8727:21:1;8784:2;8764:18;;;8757:30;8823:34;8803:18;;;8796:62;-1:-1:-1;;;8874:18:1;;;8867:41;8925:19;;54247:87:0;8543:407:1;54247:87:0;-1:-1:-1;;;;;;54352:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;54130:256::o;64840:239::-;64899:4;;64912:143;64933:20;:27;64929:31;;64912:143;;;65007:5;-1:-1:-1;;;;;64980:32:0;:20;65001:1;64980:23;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;64980:23:0;:32;64976:72;;-1:-1:-1;65034:4:0;;64840:239;-1:-1:-1;;64840:239:0:o;64976:72::-;64962:3;;;;:::i;:::-;;;;64912:143;;;-1:-1:-1;65068:5:0;;64840:239;-1:-1:-1;;64840:239:0:o;66792:95::-;60879:13;:11;:13::i;:::-;66857:15:::1;:24:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;66857:24:0;;::::1;::::0;;;::::1;::::0;;66792:95::o;67046:153::-;60879:13;:11;:13::i;:::-;67101:7:::1;67122;61066:6:::0;;-1:-1:-1;;;;;61066:6:0;;60993:87;67122:7:::1;-1:-1:-1::0;;;;;67114:21:0::1;67143;67114:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67100:69;;;67184:2;67176:11;;;::::0;::::1;;67091:108;67046:153::o:0;40501:185::-;40639:39;40656:4;40662:2;40666:7;40639:39;;;;;;;;;;;;:16;:39::i;65085:348::-;65160:16;65188:23;65214:17;65224:6;65214:9;:17::i;:::-;65188:43;;65238:25;65280:15;65266:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65266:30:0;;65238:58;;65308:9;65303:103;65323:15;65319:1;:19;65303:103;;;65368:30;65388:6;65396:1;65368:19;:30::i;:::-;65354:8;65363:1;65354:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;65340:3;;;;:::i;:::-;;;;65303:103;;;-1:-1:-1;65419:8:0;65085:348;-1:-1:-1;;;65085:348:0:o;66143:80::-;60879:13;:11;:13::i;:::-;66202:4:::1;:15:::0;66143:80::o;54652:233::-;54727:7;54763:30;54550:10;:17;;54462:113;54763:30;54755:5;:38;54747:95;;;;-1:-1:-1;;;54747:95:0;;9771:2:1;54747:95:0;;;9753:21:1;9810:2;9790:18;;;9783:30;9849:34;9829:18;;;9822:62;-1:-1:-1;;;9900:18:1;;;9893:42;9952:19;;54747:95:0;9569:408:1;54747:95:0;54860:10;54871:5;54860:17;;;;;;;;:::i;:::-;;;;;;;;;54853:24;;54652:233;;;:::o;66351:98::-;60879:13;:11;:13::i;:::-;66422:7:::1;:21;66432:11:::0;66422:7;:21:::1;:::i;:::-;;66351:98:::0;:::o;37593:223::-;37665:7;42480:16;;;:7;:16;;;;;;-1:-1:-1;;;;;42480:16:0;;37729:56;;;;-1:-1:-1;;;37729:56:0;;12388:2:1;37729:56:0;;;12370:21:1;12427:2;12407:18;;;12400:30;-1:-1:-1;;;12446:18:1;;;12439:54;12510:18;;37729:56:0;12186:348:1;62619:21:0;;;;;;;:::i;37324:207::-;37396:7;-1:-1:-1;;;;;37424:19:0;;37416:73;;;;-1:-1:-1;;;37416:73:0;;12741:2:1;37416:73:0;;;12723:21:1;12780:2;12760:18;;;12753:30;12819:34;12799:18;;;12792:62;-1:-1:-1;;;12870:18:1;;;12863:39;12919:19;;37416:73:0;12539:405:1;37416:73:0;-1:-1:-1;;;;;;37507:16:0;;;;;:9;:16;;;;;;;37324:207::o;61641:103::-;60879:13;:11;:13::i;:::-;61706:30:::1;61733:1;61706:18;:30::i;:::-;61641:103::o:0;66229:116::-;60879:13;:11;:13::i;:::-;66306::::1;:33:::0;66229:116::o;38052:104::-;38108:13;38141:7;38134:14;;;;;:::i;63556:1276::-;63622:6;;;;63621:7;63613:42;;;;-1:-1:-1;;;63613:42:0;;13151:2:1;63613:42:0;;;13133:21:1;13190:2;13170:18;;;13163:30;-1:-1:-1;;;13209:18:1;;;13202:52;13271:18;;63613:42:0;12949:346:1;63613:42:0;63662:14;63679:13;54550:10;:17;;54462:113;63679:13;63662:30;;63721:1;63707:11;:15;63699:55;;;;-1:-1:-1;;;63699:55:0;;13502:2:1;63699:55:0;;;13484:21:1;13541:2;13521:18;;;13514:30;13580:29;13560:18;;;13553:57;13627:18;;63699:55:0;13300:351:1;63699:55:0;63784:13;;63769:11;:28;;63761:77;;;;-1:-1:-1;;;63761:77:0;;13858:2:1;63761:77:0;;;13840:21:1;13897:2;13877:18;;;13870:30;13936:34;13916:18;;;13909:62;-1:-1:-1;;;13987:18:1;;;13980:34;14031:19;;63761:77:0;13656:400:1;63761:77:0;63877:9;;63853:20;63862:11;63853:6;:20;:::i;:::-;:33;;63845:68;;;;-1:-1:-1;;;63845:68:0;;14393:2:1;63845:68:0;;;14375:21:1;14432:2;14412:18;;;14405:30;-1:-1:-1;;;14451:18:1;;;14444:52;14513:18;;63845:68:0;14191:346:1;63845:68:0;61066:6;;-1:-1:-1;;;;;61066:6:0;63926:10;:21;63922:649;;63963:15;;;;;;;:23;;63982:4;63963:23;63960:298;;64011:25;64025:10;64011:13;:25::i;:::-;64003:61;;;;-1:-1:-1;;;64003:61:0;;14744:2:1;64003:61:0;;;14726:21:1;14783:2;14763:18;;;14756:30;14822:25;14802:18;;;14795:53;14865:18;;64003:61:0;14542:347:1;64003:61:0;64127:10;64079:24;64106:32;;;:20;:32;;;;;;64195:18;;64161:30;64180:11;64106:32;64161:30;:::i;:::-;:52;;64153:93;;;;-1:-1:-1;;;64153:93:0;;15096:2:1;64153:93:0;;;15078:21:1;15135:2;15115:18;;;15108:30;15174;15154:18;;;15147:58;15222:18;;64153:93:0;14894:352:1;64153:93:0;63988:270;63960:298;64271:15;;;;;;;:24;;64290:5;64271:24;64268:223;;64360:10;64312:24;64339:32;;;:20;:32;;;;;;64428:18;;64394:30;64413:11;64339:32;64394:30;:::i;:::-;:52;;64386:93;;;;-1:-1:-1;;;64386:93:0;;15096:2:1;64386:93:0;;;15078:21:1;15135:2;15115:18;;;15108:30;15174;15154:18;;;15147:58;15222:18;;64386:93:0;14894:352:1;64386:93:0;64297:194;64268:223;64529:11;64522:4;;:18;;;;:::i;:::-;64509:9;:31;;64501:62;;;;-1:-1:-1;;;64501:62:0;;15626:2:1;64501:62:0;;;15608:21:1;15665:2;15645:18;;;15638:30;-1:-1:-1;;;15684:18:1;;;15677:48;15742:18;;64501:62:0;15424:342:1;64501:62:0;64596:1;64579:136;64604:11;64599:1;:16;64579:136;;64652:10;64631:32;;;;:20;:32;;;;;:34;;;;;;:::i;:::-;;;;-1:-1:-1;64674:33:0;;-1:-1:-1;64684:10:0;64696;64705:1;64696:6;:10;:::i;:::-;64674:9;:33::i;:::-;64617:3;;;;:::i;:::-;;;;64579:136;;;-1:-1:-1;64754:11:0;;64728:12;;64754:11;;;-1:-1:-1;;;;;64754:11:0;64795:3;64779:13;:9;64791:1;64779:13;:::i;:::-;:19;;;;:::i;:::-;64746:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64727:76;;;64818:7;64810:16;;;;;39638:155;39733:52;35846:10;39766:8;39776;39733:18;:52::i;65958:65::-;60879:13;:11;:13::i;:::-;66002:8:::1;:15:::0;;-1:-1:-1;;66002:15:0::1;;;::::0;;65958:65::o;40757:322::-;40931:41;35846:10;40964:7;40931:18;:41::i;:::-;40923:99;;;;-1:-1:-1;;;40923:99:0;;;;;;;:::i;:::-;41033:38;41047:4;41053:2;41057:7;41066:4;41033:13;:38::i;:::-;40757:322;;;;:::o;63061:37::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63061:37:0;;-1:-1:-1;63061:37:0;:::o;62645:::-;;;;;;;:::i;65439:497::-;42882:4;42480:16;;;:7;:16;;;;;;65537:13;;-1:-1:-1;;;;;42480:16:0;65562:97;;;;-1:-1:-1;;;65562:97:0;;16327:2:1;65562:97:0;;;16309:21:1;16366:2;16346:18;;;16339:30;16405:34;16385:18;;;16378:62;-1:-1:-1;;;16456:18:1;;;16449:45;16511:19;;65562:97:0;16125:411:1;65562:97:0;65675:8;;;;;;;:17;;65687:5;65675:17;65672:62;;65712:14;65705:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65439:497;;;:::o;65672:62::-;65742:28;65773:10;:8;:10::i;:::-;65742:41;;65828:1;65803:14;65797:28;:32;:133;;;;;;;;;;;;;;;;;65865:14;65881:18;:7;:16;:18::i;:::-;65901:13;65848:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;65797:133;65790:140;65439:497;-1:-1:-1;;;65439:497:0:o;66031:104::-;60879:13;:11;:13::i;:::-;66102:18:::1;:27:::0;66031:104::o;66455:122::-;60879:13;:11;:13::i;:::-;66538::::1;:33;66554:17:::0;66538:13;:33:::1;:::i;66895:144::-:0;60879:13;:11;:13::i;:::-;66970:27:::1;66977:20;;66970:27;:::i;:::-;67004:29;:20;67027:6:::0;;67004:29:::1;:::i;66585:120::-:0;60879:13;:11;:13::i;:::-;66667:14:::1;:32;66684:15:::0;66667:14;:32:::1;:::i;61899:201::-:0;60879:13;:11;:13::i;:::-;-1:-1:-1;;;;;61988:22:0;::::1;61980:73;;;::::0;-1:-1:-1;;;61980:73:0;;18004:2:1;61980:73:0::1;::::0;::::1;17986:21:1::0;18043:2;18023:18;;;18016:30;18082:34;18062:18;;;18055:62;-1:-1:-1;;;18133:18:1;;;18126:36;18179:19;;61980:73:0::1;17802:402:1::0;61980:73:0::1;62064:28;62083:8;62064:18;:28::i;36955:305::-:0;37057:4;-1:-1:-1;;;;;;37094:40:0;;-1:-1:-1;;;37094:40:0;;:105;;-1:-1:-1;;;;;;;37151:48:0;;-1:-1:-1;;;37151:48:0;37094:105;:158;;;-1:-1:-1;;;;;;;;;;8108:40:0;;;37216:36;7999:157;61158:132;61066:6;;-1:-1:-1;;;;;61066:6:0;35846:10;61222:23;61214:68;;;;-1:-1:-1;;;61214:68:0;;18411:2:1;61214:68:0;;;18393:21:1;;;18430:18;;;18423:30;18489:34;18469:18;;;18462:62;18541:18;;61214:68:0;18209:356:1;49214:135:0;42882:4;42480:16;;;:7;:16;;;;;;-1:-1:-1;;;;;42480:16:0;49288:53;;;;-1:-1:-1;;;49288:53:0;;12388:2:1;49288:53:0;;;12370:21:1;12427:2;12407:18;;;12400:30;-1:-1:-1;;;12446:18:1;;;12439:54;12510:18;;49288:53:0;12186:348:1;48493:174:0;48568:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;48568:29:0;-1:-1:-1;;;;;48568:29:0;;;;;;;;:24;;48622:23;48568:24;48622:14;:23::i;:::-;-1:-1:-1;;;;;48613:46:0;;;;;;;;;;;48493:174;;:::o;43112:264::-;43205:4;43222:13;43238:23;43253:7;43238:14;:23::i;:::-;43222:39;;43291:5;-1:-1:-1;;;;;43280:16:0;:7;-1:-1:-1;;;;;43280:16:0;;:52;;;-1:-1:-1;;;;;;39985:25:0;;;39961:4;39985:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;43300:32;43280:87;;;;43360:7;-1:-1:-1;;;;;43336:31:0;:20;43348:7;43336:11;:20::i;:::-;-1:-1:-1;;;;;43336:31:0;;43280:87;43272:96;43112:264;-1:-1:-1;;;;43112:264:0:o;47111:1263::-;47270:4;-1:-1:-1;;;;;47243:31:0;:23;47258:7;47243:14;:23::i;:::-;-1:-1:-1;;;;;47243:31:0;;47235:81;;;;-1:-1:-1;;;47235:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;47335:16:0;;47327:65;;;;-1:-1:-1;;;47327:65:0;;19178:2:1;47327:65:0;;;19160:21:1;19217:2;19197:18;;;19190:30;19256:34;19236:18;;;19229:62;-1:-1:-1;;;19307:18:1;;;19300:34;19351:19;;47327:65:0;18976:400:1;47327:65:0;47405:42;47426:4;47432:2;47436:7;47445:1;47405:20;:42::i;:::-;47577:4;-1:-1:-1;;;;;47550:31:0;:23;47565:7;47550:14;:23::i;:::-;-1:-1:-1;;;;;47550:31:0;;47542:81;;;;-1:-1:-1;;;47542:81:0;;;;;;;:::i;:::-;47695:24;;;;:15;:24;;;;;;;;47688:31;;-1:-1:-1;;;;;;47688:31:0;;;;;;-1:-1:-1;;;;;48171:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;48171:20:0;;;48206:13;;;;;;;;;:18;;47688:31;48206:18;;;48246:16;;;:7;:16;;;;;;:21;;;;;;;;;;48285:27;;47711:7;;48285:27;;;38983:346;38913:416;;:::o;62260:191::-;62353:6;;;-1:-1:-1;;;;;62370:17:0;;;-1:-1:-1;;;;;;62370:17:0;;;;;;;62403:40;;62353:6;;;62370:17;62353:6;;62403:40;;62334:16;;62403:40;62323:128;62260:191;:::o;43718:110::-;43794:26;43804:2;43808:7;43794:26;;;;;;;;;;;;:9;:26::i;48810:315::-;48965:8;-1:-1:-1;;;;;48956:17:0;:5;-1:-1:-1;;;;;48956:17:0;;48948:55;;;;-1:-1:-1;;;48948:55:0;;19583:2:1;48948:55:0;;;19565:21:1;19622:2;19602:18;;;19595:30;19661:27;19641:18;;;19634:55;19706:18;;48948:55:0;19381:349:1;48948:55:0;-1:-1:-1;;;;;49014:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;49014:46:0;;;;;;;;;;49076:41;;540::1;;;49076::0;;513:18:1;49076:41:0;;;;;;;48810:315;;;:::o;41960:313::-;42116:28;42126:4;42132:2;42136:7;42116:9;:28::i;:::-;42163:47;42186:4;42192:2;42196:7;42205:4;42163:22;:47::i;:::-;42155:110;;;;-1:-1:-1;;;42155:110:0;;;;;;;:::i;63435:102::-;63495:13;63524:7;63517:14;;;;;:::i;21470:716::-;21526:13;21577:14;21594:17;21605:5;21594:10;:17::i;:::-;21614:1;21594:21;21577:38;;21630:20;21664:6;21653:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21653:18:0;-1:-1:-1;21630:41:0;-1:-1:-1;21795:28:0;;;21811:2;21795:28;21852:288;-1:-1:-1;;21884:5:0;-1:-1:-1;;;22021:2:0;22010:14;;22005:30;21884:5;21992:44;22082:2;22073:11;;;-1:-1:-1;22103:21:0;21852:288;22103:21;-1:-1:-1;22161:6:0;21470:716;-1:-1:-1;;;21470:716:0:o;54959:915::-;55136:61;55163:4;55169:2;55173:12;55187:9;55136:26;:61::i;:::-;55226:1;55214:9;:13;55210:222;;;55357:63;;-1:-1:-1;;;55357:63:0;;20356:2:1;55357:63:0;;;20338:21:1;20395:2;20375:18;;;20368:30;20434:34;20414:18;;;20407:62;-1:-1:-1;;;20485:18:1;;;20478:51;20546:19;;55357:63:0;20154:417:1;55210:222:0;55462:12;-1:-1:-1;;;;;55491:18:0;;55487:187;;55526:40;55558:7;56701:10;:17;;56674:24;;;;:15;:24;;;;;:44;;;56729:24;;;;;;;;;;;;56597:164;55526:40;55487:187;;;55596:2;-1:-1:-1;;;;;55588:10:0;:4;-1:-1:-1;;;;;55588:10:0;;55584:90;;55615:47;55648:4;55654:7;55615:32;:47::i;:::-;-1:-1:-1;;;;;55688:16:0;;55684:183;;55721:45;55758:7;55721:36;:45::i;:::-;55684:183;;;55794:4;-1:-1:-1;;;;;55788:10:0;:2;-1:-1:-1;;;;;55788:10:0;;55784:83;;55815:40;55843:2;55847:7;55815:27;:40::i;:::-;55125:749;54959:915;;;;:::o;44055:319::-;44184:18;44190:2;44194:7;44184:5;:18::i;:::-;44235:53;44266:1;44270:2;44274:7;44283:4;44235:22;:53::i;:::-;44213:153;;;;-1:-1:-1;;;44213:153:0;;;;;;;:::i;49913:853::-;50067:4;-1:-1:-1;;;;;50088:13:0;;24893:19;:23;50084:675;;50124:71;;-1:-1:-1;;;50124:71:0;;-1:-1:-1;;;;;50124:36:0;;;;;:71;;35846:10;;50175:4;;50181:7;;50190:4;;50124:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50124:71:0;;;;;;;;-1:-1:-1;;50124:71:0;;;;;;;;;;;;:::i;:::-;;;50120:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50365:6;:13;50382:1;50365:18;50361:328;;50408:60;;-1:-1:-1;;;50408:60:0;;;;;;;:::i;50361:328::-;50639:6;50633:13;50624:6;50620:2;50616:15;50609:38;50120:584;-1:-1:-1;;;;;;50246:51:0;-1:-1:-1;;;50246:51:0;;-1:-1:-1;50239:58:0;;50084:675;-1:-1:-1;50743:4:0;49913:853;;;;;;:::o;18335:922::-;18388:7;;-1:-1:-1;;;18466:15:0;;18462:102;;-1:-1:-1;;;18502:15:0;;;-1:-1:-1;18546:2:0;18536:12;18462:102;18591:6;18582:5;:15;18578:102;;18627:6;18618:15;;;-1:-1:-1;18662:2:0;18652:12;18578:102;18707:6;18698:5;:15;18694:102;;18743:6;18734:15;;;-1:-1:-1;18778:2:0;18768:12;18694:102;18823:5;18814;:14;18810:99;;18858:5;18849:14;;;-1:-1:-1;18892:1:0;18882:11;18810:99;18936:5;18927;:14;18923:99;;18971:5;18962:14;;;-1:-1:-1;19005:1:0;18995:11;18923:99;19049:5;19040;:14;19036:99;;19084:5;19075:14;;;-1:-1:-1;19118:1:0;19108:11;19036:99;19162:5;19153;:14;19149:66;;19198:1;19188:11;19243:6;18335:922;-1:-1:-1;;18335:922:0:o;51498:410::-;51688:1;51676:9;:13;51672:229;;;-1:-1:-1;;;;;51710:18:0;;;51706:87;;-1:-1:-1;;;;;51749:15:0;;;;;;:9;:15;;;;;:28;;51768:9;;51749:15;:28;;51768:9;;51749:28;:::i;:::-;;;;-1:-1:-1;;51706:87:0;-1:-1:-1;;;;;51811:16:0;;;51807:83;;-1:-1:-1;;;;;51848:13:0;;;;;;:9;:13;;;;;:26;;51865:9;;51848:13;:26;;51865:9;;51848:26;:::i;:::-;;;;-1:-1:-1;;51498:410:0;;;;:::o;57388:988::-;57654:22;57704:1;57679:22;57696:4;57679:16;:22::i;:::-;:26;;;;:::i;:::-;57716:18;57737:26;;;:17;:26;;;;;;57654:51;;-1:-1:-1;57870:28:0;;;57866:328;;-1:-1:-1;;;;;57937:18:0;;57915:19;57937:18;;;:12;:18;;;;;;;;:34;;;;;;;;;57988:30;;;;;;:44;;;58105:30;;:17;:30;;;;;:43;;;57866:328;-1:-1:-1;58290:26:0;;;;:17;:26;;;;;;;;58283:33;;;-1:-1:-1;;;;;58334:18:0;;;;;:12;:18;;;;;:34;;;;;;;58327:41;57388:988::o;58671:1079::-;58949:10;:17;58924:22;;58949:21;;58969:1;;58949:21;:::i;:::-;58981:18;59002:24;;;:15;:24;;;;;;59375:10;:26;;58924:46;;-1:-1:-1;59002:24:0;;58924:46;;59375:26;;;;;;:::i;:::-;;;;;;;;;59353:48;;59439:11;59414:10;59425;59414:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;59519:28;;;:15;:28;;;;;;;:41;;;59691:24;;;;;59684:31;59726:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;58742:1008;;;58671:1079;:::o;56175:221::-;56260:14;56277:20;56294:2;56277:16;:20::i;:::-;-1:-1:-1;;;;;56308:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;56353:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;56175:221:0:o;44710:942::-;-1:-1:-1;;;;;44790:16:0;;44782:61;;;;-1:-1:-1;;;44782:61:0;;21791:2:1;44782:61:0;;;21773:21:1;;;21810:18;;;21803:30;21869:34;21849:18;;;21842:62;21921:18;;44782:61:0;21589:356:1;44782:61:0;42882:4;42480:16;;;:7;:16;;;;;;-1:-1:-1;;;;;42480:16:0;42906:31;44854:58;;;;-1:-1:-1;;;44854:58:0;;22152:2:1;44854:58:0;;;22134:21:1;22191:2;22171:18;;;22164:30;22230;22210:18;;;22203:58;22278:18;;44854:58:0;21950:352:1;44854:58:0;44925:48;44954:1;44958:2;44962:7;44971:1;44925:20;:48::i;:::-;42882:4;42480:16;;;:7;:16;;;;;;-1:-1:-1;;;;;42480:16:0;42906:31;45063:58;;;;-1:-1:-1;;;45063:58:0;;22152:2:1;45063:58:0;;;22134:21:1;22191:2;22171:18;;;22164:30;22230;22210:18;;;22203:58;22278:18;;45063:58:0;21950:352:1;45063:58:0;-1:-1:-1;;;;;45470:13:0;;;;;;:9;:13;;;;;;;;:18;;45487:1;45470:18;;;45512:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;45512:21:0;;;;;45551:33;45520:7;;45470:13;;45551:33;;45470:13;;45551:33;66422:21:::1;66351:98:::0;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:160::-;657:20;;713:13;;706:21;696:32;;686:60;;742:1;739;732:12;686:60;592:160;;;:::o;757:180::-;813:6;866:2;854:9;845:7;841:23;837:32;834:52;;;882:1;879;872:12;834:52;905:26;921:9;905:26;:::i;942:250::-;1027:1;1037:113;1051:6;1048:1;1045:13;1037:113;;;1127:11;;;1121:18;1108:11;;;1101:39;1073:2;1066:10;1037:113;;;-1:-1:-1;;1184:1:1;1166:16;;1159:27;942:250::o;1197:271::-;1239:3;1277:5;1271:12;1304:6;1299:3;1292:19;1320:76;1389:6;1382:4;1377:3;1373:14;1366:4;1359:5;1355:16;1320:76;:::i;:::-;1450:2;1429:15;-1:-1:-1;;1425:29:1;1416:39;;;;1457:4;1412:50;;1197:271;-1:-1:-1;;1197:271:1:o;1473:220::-;1622:2;1611:9;1604:21;1585:4;1642:45;1683:2;1672:9;1668:18;1660:6;1642:45;:::i;1698:180::-;1757:6;1810:2;1798:9;1789:7;1785:23;1781:32;1778:52;;;1826:1;1823;1816:12;1778:52;-1:-1:-1;1849:23:1;;1698:180;-1:-1:-1;1698:180:1:o;2091:173::-;2159:20;;-1:-1:-1;;;;;2208:31:1;;2198:42;;2188:70;;2254:1;2251;2244:12;2269:254;2337:6;2345;2398:2;2386:9;2377:7;2373:23;2369:32;2366:52;;;2414:1;2411;2404:12;2366:52;2437:29;2456:9;2437:29;:::i;:::-;2427:39;2513:2;2498:18;;;;2485:32;;-1:-1:-1;;;2269:254:1:o;2710:186::-;2769:6;2822:2;2810:9;2801:7;2797:23;2793:32;2790:52;;;2838:1;2835;2828:12;2790:52;2861:29;2880:9;2861:29;:::i;2901:328::-;2978:6;2986;2994;3047:2;3035:9;3026:7;3022:23;3018:32;3015:52;;;3063:1;3060;3053:12;3015:52;3086:29;3105:9;3086:29;:::i;:::-;3076:39;;3134:38;3168:2;3157:9;3153:18;3134:38;:::i;:::-;3124:48;;3219:2;3208:9;3204:18;3191:32;3181:42;;2901:328;;;;;:::o;3234:632::-;3405:2;3457:21;;;3527:13;;3430:18;;;3549:22;;;3376:4;;3405:2;3628:15;;;;3602:2;3587:18;;;3376:4;3671:169;3685:6;3682:1;3679:13;3671:169;;;3746:13;;3734:26;;3815:15;;;;3780:12;;;;3707:1;3700:9;3671:169;;;-1:-1:-1;3857:3:1;;3234:632;-1:-1:-1;;;;;;3234:632:1:o;3871:127::-;3932:10;3927:3;3923:20;3920:1;3913:31;3963:4;3960:1;3953:15;3987:4;3984:1;3977:15;4003:632;4068:5;4098:18;4139:2;4131:6;4128:14;4125:40;;;4145:18;;:::i;:::-;4220:2;4214:9;4188:2;4274:15;;-1:-1:-1;;4270:24:1;;;4296:2;4266:33;4262:42;4250:55;;;4320:18;;;4340:22;;;4317:46;4314:72;;;4366:18;;:::i;:::-;4406:10;4402:2;4395:22;4435:6;4426:15;;4465:6;4457;4450:22;4505:3;4496:6;4491:3;4487:16;4484:25;4481:45;;;4522:1;4519;4512:12;4481:45;4572:6;4567:3;4560:4;4552:6;4548:17;4535:44;4627:1;4620:4;4611:6;4603;4599:19;4595:30;4588:41;;;;4003:632;;;;;:::o;4640:451::-;4709:6;4762:2;4750:9;4741:7;4737:23;4733:32;4730:52;;;4778:1;4775;4768:12;4730:52;4818:9;4805:23;4851:18;4843:6;4840:30;4837:50;;;4883:1;4880;4873:12;4837:50;4906:22;;4959:4;4951:13;;4947:27;-1:-1:-1;4937:55:1;;4988:1;4985;4978:12;4937:55;5011:74;5077:7;5072:2;5059:16;5054:2;5050;5046:11;5011:74;:::i;5096:254::-;5161:6;5169;5222:2;5210:9;5201:7;5197:23;5193:32;5190:52;;;5238:1;5235;5228:12;5190:52;5261:29;5280:9;5261:29;:::i;:::-;5251:39;;5309:35;5340:2;5329:9;5325:18;5309:35;:::i;:::-;5299:45;;5096:254;;;;;:::o;5355:667::-;5450:6;5458;5466;5474;5527:3;5515:9;5506:7;5502:23;5498:33;5495:53;;;5544:1;5541;5534:12;5495:53;5567:29;5586:9;5567:29;:::i;:::-;5557:39;;5615:38;5649:2;5638:9;5634:18;5615:38;:::i;:::-;5605:48;;5700:2;5689:9;5685:18;5672:32;5662:42;;5755:2;5744:9;5740:18;5727:32;5782:18;5774:6;5771:30;5768:50;;;5814:1;5811;5804:12;5768:50;5837:22;;5890:4;5882:13;;5878:27;-1:-1:-1;5868:55:1;;5919:1;5916;5909:12;5868:55;5942:74;6008:7;6003:2;5990:16;5985:2;5981;5977:11;5942:74;:::i;:::-;5932:84;;;5355:667;;;;;;;:::o;6027:260::-;6095:6;6103;6156:2;6144:9;6135:7;6131:23;6127:32;6124:52;;;6172:1;6169;6162:12;6124:52;6195:29;6214:9;6195:29;:::i;:::-;6185:39;;6243:38;6277:2;6266:9;6262:18;6243:38;:::i;6292:615::-;6378:6;6386;6439:2;6427:9;6418:7;6414:23;6410:32;6407:52;;;6455:1;6452;6445:12;6407:52;6495:9;6482:23;6524:18;6565:2;6557:6;6554:14;6551:34;;;6581:1;6578;6571:12;6551:34;6619:6;6608:9;6604:22;6594:32;;6664:7;6657:4;6653:2;6649:13;6645:27;6635:55;;6686:1;6683;6676:12;6635:55;6726:2;6713:16;6752:2;6744:6;6741:14;6738:34;;;6768:1;6765;6758:12;6738:34;6821:7;6816:2;6806:6;6803:1;6799:14;6795:2;6791:23;6787:32;6784:45;6781:65;;;6842:1;6839;6832:12;6781:65;6873:2;6865:11;;;;;6895:6;;-1:-1:-1;6292:615:1;;-1:-1:-1;;;;6292:615:1:o;6912:380::-;6991:1;6987:12;;;;7034;;;7055:61;;7109:4;7101:6;7097:17;7087:27;;7055:61;7162:2;7154:6;7151:14;7131:18;7128:38;7125:161;;7208:10;7203:3;7199:20;7196:1;7189:31;7243:4;7240:1;7233:15;7271:4;7268:1;7261:15;7125:161;;6912:380;;;:::o;8129:409::-;8331:2;8313:21;;;8370:2;8350:18;;;8343:30;8409:34;8404:2;8389:18;;8382:62;-1:-1:-1;;;8475:2:1;8460:18;;8453:43;8528:3;8513:19;;8129:409::o;8955:127::-;9016:10;9011:3;9007:20;9004:1;8997:31;9047:4;9044:1;9037:15;9071:4;9068:1;9061:15;9087:127;9148:10;9143:3;9139:20;9136:1;9129:31;9179:4;9176:1;9169:15;9203:4;9200:1;9193:15;9219:135;9258:3;9279:17;;;9276:43;;9299:18;;:::i;:::-;-1:-1:-1;9346:1:1;9335:13;;9219:135::o;10108:545::-;10210:2;10205:3;10202:11;10199:448;;;10246:1;10271:5;10267:2;10260:17;10316:4;10312:2;10302:19;10386:2;10374:10;10370:19;10367:1;10363:27;10357:4;10353:38;10422:4;10410:10;10407:20;10404:47;;;-1:-1:-1;10445:4:1;10404:47;10500:2;10495:3;10491:12;10488:1;10484:20;10478:4;10474:31;10464:41;;10555:82;10573:2;10566:5;10563:13;10555:82;;;10618:17;;;10599:1;10588:13;10555:82;;;10559:3;;;10108:545;;;:::o;10829:1352::-;10955:3;10949:10;10982:18;10974:6;10971:30;10968:56;;;11004:18;;:::i;:::-;11033:97;11123:6;11083:38;11115:4;11109:11;11083:38;:::i;:::-;11077:4;11033:97;:::i;:::-;11185:4;;11249:2;11238:14;;11266:1;11261:663;;;;11968:1;11985:6;11982:89;;;-1:-1:-1;12037:19:1;;;12031:26;11982:89;-1:-1:-1;;10786:1:1;10782:11;;;10778:24;10774:29;10764:40;10810:1;10806:11;;;10761:57;12084:81;;11231:944;;11261:663;10055:1;10048:14;;;10092:4;10079:18;;-1:-1:-1;;11297:20:1;;;11415:236;11429:7;11426:1;11423:14;11415:236;;;11518:19;;;11512:26;11497:42;;11610:27;;;;11578:1;11566:14;;;;11445:19;;11415:236;;;11419:3;11679:6;11670:7;11667:19;11664:201;;;11740:19;;;11734:26;-1:-1:-1;;11823:1:1;11819:14;;;11835:3;11815:24;11811:37;11807:42;11792:58;11777:74;;11664:201;-1:-1:-1;;;;;11911:1:1;11895:14;;;11891:22;11878:36;;-1:-1:-1;10829:1352:1:o;14061:125::-;14126:9;;;14147:10;;;14144:36;;;14160:18;;:::i;15251:168::-;15324:9;;;15355;;15372:15;;;15366:22;;15352:37;15342:71;;15393:18;;:::i;15903:217::-;15943:1;15969;15959:132;;16013:10;16008:3;16004:20;16001:1;15994:31;16048:4;16045:1;16038:15;16076:4;16073:1;16066:15;15959:132;-1:-1:-1;16105:9:1;;15903:217::o;16541:1256::-;16765:3;16803:6;16797:13;16829:4;16842:64;16899:6;16894:3;16889:2;16881:6;16877:15;16842:64;:::i;:::-;16969:13;;16928:16;;;;16991:68;16969:13;16928:16;17026:15;;;16991:68;:::i;:::-;17148:13;;17081:20;;;17121:1;;17186:36;17148:13;17186:36;:::i;:::-;17241:1;17258:18;;;17285:141;;;;17440:1;17435:337;;;;17251:521;;17285:141;-1:-1:-1;;17320:24:1;;17306:39;;17397:16;;17390:24;17376:39;;17365:51;;;-1:-1:-1;17285:141:1;;17435:337;17466:6;17463:1;17456:17;17514:2;17511:1;17501:16;17539:1;17553:169;17567:8;17564:1;17561:15;17553:169;;;17649:14;;17634:13;;;17627:37;17692:16;;;;17584:10;;17553:169;;;17557:3;;17753:8;17746:5;17742:20;17735:27;;17251:521;-1:-1:-1;17788:3:1;;16541:1256;-1:-1:-1;;;;;;;;;;16541:1256:1:o;18570:401::-;18772:2;18754:21;;;18811:2;18791:18;;;18784:30;18850:34;18845:2;18830:18;;18823:62;-1:-1:-1;;;18916:2:1;18901:18;;18894:35;18961:3;18946:19;;18570:401::o;19735:414::-;19937:2;19919:21;;;19976:2;19956:18;;;19949:30;20015:34;20010:2;19995:18;;19988:62;-1:-1:-1;;;20081:2:1;20066:18;;20059:48;20139:3;20124:19;;19735:414::o;20576:489::-;-1:-1:-1;;;;;20845:15:1;;;20827:34;;20897:15;;20892:2;20877:18;;20870:43;20944:2;20929:18;;20922:34;;;20992:3;20987:2;20972:18;;20965:31;;;20770:4;;21013:46;;21039:19;;21031:6;21013:46;:::i;:::-;21005:54;20576:489;-1:-1:-1;;;;;;20576:489:1:o;21070:249::-;21139:6;21192:2;21180:9;21171:7;21167:23;21163:32;21160:52;;;21208:1;21205;21198:12;21160:52;21240:9;21234:16;21259:30;21283:5;21259:30;:::i;21324:128::-;21391:9;;;21412:11;;;21409:37;;;21426:18;;:::i;21457:127::-;21518:10;21513:3;21509:20;21506:1;21499:31;21549:4;21546:1;21539:15;21573:4;21570:1;21563:15

ipfs://9e4cd233ecc02e42bff055d0b32dcd2d0fbfa3c547dc638463b761fbe37694e6