Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• interface IERC721Receiver
•    - function onERC721Received(
• library ECDSA
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(
•    - function recover(bytes32 hash, uint8 ...
•    - function _throwError(RecoverError err ...
•    - function _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Math
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function mulDiv(uint256 x, uint256 y, ...
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
•    - function unsignedRoundsUp(Rounding ro ...
• library SignedMath
•    - function max(int256 a, int256 b)
•    - function min(int256 a, int256 b)
•    - function average(int256 a, int256 b)
•    - function abs(int256 n)
• library Strings
•    - function toString(uint256 value)
•    - function toStringSigned(int256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
•    - function equal(string memory a, strin ...
• library MessageHashUtils
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toDataWithIntendedValidatorH ...
•    - function toTypedDataHash(bytes32 doma ...
•  contract NFTClaimingPortal is Owna ... *
•    - function claim(uint256[] calldata tok ...
•    - function deposit(uint256[] calldata t ...
•    - function emergencyWithdrawByTokenId(u ...
•    - function emergencyWithdrawAll()
•    - function updateSignerAddress(address ...
•    - function decodeSignature(uint256[] ca ...
•    - function onERC721Received(
•    - function _removeTokenIdFromAvailable( ...
•    - function getAvailableTokenIds()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-09-29
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.18;

/**
 * @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 v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.18;


/**
 * @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 address zero.
     *
     * 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/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.18;

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

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.19;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.18;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.18;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.18;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the 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 towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (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 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

            uint256 twos = denominator & (0 - denominator);
            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 (unsignedRoundsUp(rounding) && 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
     * towards zero.
     *
     * 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * 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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * 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 256, 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.18;

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.18;



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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @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), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @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) {
        uint256 localValue = value;
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// File: @openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.19;


/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

// File: HYPC Claiming/hypcClaiming.sol


pragma solidity ^0.8.18;






contract NFTClaimingPortal is Ownable(msg.sender), IERC721Receiver {
    using MessageHashUtils for bytes32;

    // Address of the ERC721 NFT contract
    IERC721 public nftContract;

    // Mapping to track claimed status
    mapping(address => bool) public hasClaimed;

    // Mapping to track the token IDs claimed by each address
    mapping(address => uint256[]) public claims;

    // Array to store available token IDs for claiming
    uint256[] public availableTokenIds;

    // The address that is allowed to sign the claim requests
    address public signerAddress;

    event NFTsClaimed(address indexed claimant, uint256[] tokenIds);
    event NFTDeposited(uint256 indexed tokenId);
    event EmergencyWithdraw(address indexed owner, uint256[] tokenIds);
    event EmergencyWithdrawAll(address indexed owner);

    /**
     * @dev Constructor that sets the NFT contract and signer address.
     * @param _nftContract The address of the ERC721 contract.
     * @param _signerAddress The address of the off-chain signer.
     */
    constructor(address _nftContract, address _signerAddress) {
        require(_nftContract != address(0), "Invalid NFT contract address");
        require(_signerAddress != address(0), "Invalid signer address");
        nftContract = IERC721(_nftContract);
        signerAddress = _signerAddress;
    }

    /**
     * @notice Claims specified NFTs using a valid signature.
     * @param tokenIds The array of token IDs to be claimed.
     * @param signature The signature verifying the claim.
     */
    function claim(uint256[] calldata tokenIds, bytes calldata signature) external {
        require(!hasClaimed[msg.sender], "Already claimed");

        bytes32 hash = keccak256(abi.encodePacked(msg.sender, tokenIds));

        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(hash);
        address recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);

        require(recoveredSigner == signerAddress, "Invalid signature");

        hasClaimed[msg.sender] = true;

        claims[msg.sender] = tokenIds;

        for (uint256 i = 0; i < tokenIds.length; i++) {
            _removeTokenIdFromAvailable(tokenIds[i]);
            nftContract.safeTransferFrom(address(this), msg.sender, tokenIds[i]);
        }

        emit NFTsClaimed(msg.sender, tokenIds);
    }

    /**
     * @notice Deposits multiple NFTs into the contract in one transaction.
     * @dev Only callable by the owner of the contract.
     * @param tokenIds The array of NFT token IDs to be deposited.
     */
    function deposit(uint256[] calldata tokenIds) external onlyOwner {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            nftContract.safeTransferFrom(msg.sender, address(this), tokenIds[i]);
            availableTokenIds.push(tokenIds[i]);
            emit NFTDeposited(tokenIds[i]);
        }
    }

    /**
     * @notice Emergency withdrawal of specific NFTs by the owner.
     * @param tokenIds Array of token IDs to be withdrawn.
     */
    function emergencyWithdrawByTokenId(uint256[] calldata tokenIds) external onlyOwner {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            nftContract.safeTransferFrom(address(this), msg.sender, tokenIds[i]);
            _removeTokenIdFromAvailable(tokenIds[i]);
        }
        emit EmergencyWithdraw(msg.sender, tokenIds);
    }

    /**
     * @notice Emergency withdrawal of all remaining NFTs by the owner.
     * Withdraws all NFTs that are still available in the contract.
     */
    function emergencyWithdrawAll() external onlyOwner {
        uint256 length = availableTokenIds.length;
        for (uint256 i = 0; i < length; i++) {
            uint256 tokenId = availableTokenIds[i];
            nftContract.safeTransferFrom(address(this), msg.sender, tokenId);
        }
        delete availableTokenIds;
        emit EmergencyWithdrawAll(msg.sender);
    }

    /**
     * @notice Updates the signer address.
     * @param _signerAddress The new signer address.
     */
    function updateSignerAddress(address _signerAddress) external onlyOwner {
        require(_signerAddress != address(0), "Invalid signer address");
        signerAddress = _signerAddress;
    }

    /**
     * @notice Decodes the signature to recover the signer address.
     * @param tokenIds The array of token IDs that were signed.
     * @param signature The signature provided to verify.
     * @return The address of the recovered signer.
     */
    function decodeSignature(uint256[] calldata tokenIds, bytes calldata signature) external view returns (address) {
        bytes32 hash = keccak256(abi.encodePacked(msg.sender, tokenIds));
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(hash);
        address recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);
        return recoveredSigner;
    }

    /**
     * @notice Handles the receipt of an ERC721 token.
     * The ERC721 smart contract calls this function on the recipient after a `safeTransfer`.
     * It must return its selector to confirm the token transfer.
     * @param operator The address which called `safeTransferFrom`.
     * @param from The address which previously owned the token.
     * @param tokenId The ID of the token being transferred.
     * @param data Additional data with no specified format.
     * @return bytes4 The selector to confirm the token transfer.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    /**
     * @notice Removes a token ID from the availableTokenIds array.
     * @param tokenId The token ID to be removed.
     */
    function _removeTokenIdFromAvailable(uint256 tokenId) internal {
        uint256 length = availableTokenIds.length;
        for (uint256 i = 0; i < length; i++) {
            if (availableTokenIds[i] == tokenId) {
                availableTokenIds[i] = availableTokenIds[length - 1];
                availableTokenIds.pop();
                break;
            }
        }
    }

    /**
     * @notice Returns the list of token IDs that are still available for claiming.
     * @return tokenIds Array of remaining token IDs.
     */
    function getAvailableTokenIds() external view returns (uint256[] memory) {
        return availableTokenIds;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"address","name":"_signerAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"EmergencyWithdrawAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NFTDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimant","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"NFTsClaimed","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"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"availableTokenIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"claims","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"decodeSignature","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"emergencyWithdrawByTokenId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAvailableTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftContract","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signerAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signerAddress","type":"address"}],"name":"updateSignerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000d32cb5f76989a27782e44c5297aaba728ad6166900000000000000000000000065846443566d2ecd28259198ae76a42e9ff3e3ec

-----Decoded View---------------
Arg [0] : _nftContract (address): 0xd32CB5f76989A27782e44c5297AAba728Ad61669
Arg [1] : _signerAddress (address): 0x65846443566D2ecD28259198ae76A42E9FF3E3Ec

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000d32cb5f76989a27782e44c5297aaba728ad61669
Arg [1] : 00000000000000000000000065846443566d2ecd28259198ae76a42e9ff3e3ec

43125:6633:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48695:246;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43582:34;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45757:319;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43688:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18327:103;;;:::i;:::-;;43360:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17652:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47260:195;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43474:43;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49639:116;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46230:353;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44713:816;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43285:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46751:385;;;:::i;:::-;;47727:398;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18585:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48695:246;48866:6;48892:41;;;48885:48;;48695:246;;;;;;;:::o;43582:34::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45757:319::-;17538:13;:11;:13::i;:::-;45838:9:::1;45833:236;45857:8;;:15;;45853:1;:19;45833:236;;;45894:11;;;;;;;;;;;:28;;;45923:10;45943:4;45950:8;;45959:1;45950:11;;;;;;;:::i;:::-;;;;;;;;45894:68;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;45977:17;46000:8;;46009:1;46000:11;;;;;;;:::i;:::-;;;;;;;;45977:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46045:8;;46054:1;46045:11;;;;;;;:::i;:::-;;;;;;;;46032:25;;;;;;;;;;45874:3;;;;;:::i;:::-;;;;45833:236;;;;45757:319:::0;;:::o;43688:28::-;;;;;;;;;;;;;:::o;18327:103::-;17538:13;:11;:13::i;:::-;18392:30:::1;18419:1;18392:18;:30::i;:::-;18327:103::o:0;43360:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;17652:87::-;17698:7;17725:6;;;;;;;;;;;17718:13;;17652:87;:::o;47260:195::-;17538:13;:11;:13::i;:::-;47377:1:::1;47351:28;;:14;:28;;::::0;47343:63:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;47433:14;47417:13;;:30;;;;;;;;;;;;;;;;;;47260:195:::0;:::o;43474:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49639:116::-;49694:16;49730:17;49723:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49639:116;:::o;46230:353::-;17538:13;:11;:13::i;:::-;46330:9:::1;46325:196;46349:8;;:15;;46345:1;:19;46325:196;;;46386:11;;;;;;;;;;;:28;;;46423:4;46430:10;46442:8;;46451:1;46442:11;;;;;;;:::i;:::-;;;;;;;;46386:68;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;46469:40;46497:8;;46506:1;46497:11;;;;;;;:::i;:::-;;;;;;;;46469:27;:40::i;:::-;46366:3;;;;;:::i;:::-;;;;46325:196;;;;46554:10;46536:39;;;46566:8;;46536:39;;;;;;;:::i;:::-;;;;;;;;46230:353:::0;;:::o;44713:816::-;44812:10;:22;44823:10;44812:22;;;;;;;;;;;;;;;;;;;;;;;;;44811:23;44803:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;44867:12;44909:10;44921:8;;44892:38;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;44882:49;;;;;;44867:64;;44944:28;44975:45;45015:4;44975:39;:45::i;:::-;44944:76;;45031:23;45057:46;45071:20;45093:9;;45057:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:13;:46::i;:::-;45031:72;;45143:13;;;;;;;;;;;45124:32;;:15;:32;;;45116:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;45216:4;45191:10;:22;45202:10;45191:22;;;;;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;45254:8;;45233:6;:18;45240:10;45233:18;;;;;;;;;;;;;;;:29;;;;;;;:::i;:::-;;45280:9;45275:196;45299:8;;:15;;45295:1;:19;45275:196;;;45336:40;45364:8;;45373:1;45364:11;;;;;;;:::i;:::-;;;;;;;;45336:27;:40::i;:::-;45391:11;;;;;;;;;;;:28;;;45428:4;45435:10;45447:8;;45456:1;45447:11;;;;;;;:::i;:::-;;;;;;;;45391:68;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45316:3;;;;;:::i;:::-;;;;45275:196;;;;45500:10;45488:33;;;45512:8;;45488:33;;;;;;;:::i;:::-;;;;;;;;44792:737;;;44713:816;;;;:::o;43285:26::-;;;;;;;;;;;;;:::o;46751:385::-;17538:13;:11;:13::i;:::-;46813:14:::1;46830:17;:24;;;;46813:41;;46870:9;46865:181;46889:6;46885:1;:10;46865:181;;;46917:15;46935:17;46953:1;46935:20;;;;;;;;:::i;:::-;;;;;;;;;;46917:38;;46970:11;;;;;;;;;;;:28;;;47007:4;47014:10;47026:7;46970:64;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;46902:144;46897:3;;;;;:::i;:::-;;;;46865:181;;;;47063:17;;47056:24;;;;:::i;:::-;47117:10;47096:32;;;;;;;;;;;;46802:334;46751:385::o:0;47727:398::-;47830:7;47850:12;47892:10;47904:8;;47875:38;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;47865:49;;;;;;47850:64;;47925:28;47956:45;47996:4;47956:39;:45::i;:::-;47925:76;;48012:23;48038:46;48052:20;48074:9;;48038:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:13;:46::i;:::-;48012:72;;48102:15;48095:22;;;;;47727:398;;;;;;:::o;18585:220::-;17538:13;:11;:13::i;:::-;18690:1:::1;18670:22;;:8;:22;;::::0;18666:93:::1;;18744:1;18716:31;;;;;;;;;;;:::i;:::-;;;;;;;;18666:93;18769:28;18788:8;18769:18;:28::i;:::-;18585:220:::0;:::o;17817:166::-;17888:12;:10;:12::i;:::-;17877:23;;:7;:5;:7::i;:::-;:23;;;17873:103;;17951:12;:10;:12::i;:::-;17924:40;;;;;;;;;;;:::i;:::-;;;;;;;;17873:103;17817:166::o;18965:191::-;19039:16;19058:6;;;;;;;;;;;19039:25;;19084:8;19075:6;;:17;;;;;;;;;;;;;;;;;;19139:8;19108:40;;19129:8;19108:40;;;;;;;;;;;;19028:128;18965:191;:::o;49087:386::-;49161:14;49178:17;:24;;;;49161:41;;49218:9;49213:253;49237:6;49233:1;:10;49213:253;;;49293:7;49269:17;49287:1;49269:20;;;;;;;;:::i;:::-;;;;;;;;;;:31;49265:190;;49344:17;49371:1;49362:6;:10;;;;:::i;:::-;49344:29;;;;;;;;:::i;:::-;;;;;;;;;;49321:17;49339:1;49321:20;;;;;;;;:::i;:::-;;;;;;;;;:52;;;;49392:17;:23;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;49434:5;;49265:190;49245:3;;;;;:::i;:::-;;;;49213:253;;;;49150:323;49087:386;:::o;40448:467::-;40524:14;40632:34;40626:4;40619:48;40735:11;40729:4;40722:25;40828:4;40822;40812:21;40802:31;;40448:467;;;:::o;10849:259::-;10927:7;10948:17;10967:18;10987:16;11007:27;11018:4;11024:9;11007:10;:27::i;:::-;10947:87;;;;;;11045:28;11057:5;11064:8;11045:11;:28::i;:::-;11091:9;11084:16;;;;;10849:259;;;;:::o;15661:98::-;15714:7;15741:10;15734:17;;15661:98;:::o;9243:783::-;9324:7;9333:12;9347:7;9391:2;9371:9;:16;:22;9367:652;;9410:9;9434;9458:7;9715:4;9704:9;9700:20;9694:27;9689:32;;9765:4;9754:9;9750:20;9744:27;9739:32;;9823:4;9812:9;9808:20;9802:27;9799:1;9794:36;9789:41;;9866:25;9877:4;9883:1;9886;9889;9866:10;:25::i;:::-;9859:32;;;;;;;;;;;9367:652;9940:1;9944:35;9989:9;:16;9981:25;;9924:83;;;;;;9243:783;;;;;;:::o;14417:542::-;14513:20;14504:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;14500:452;14550:7;14500:452;14611:29;14602:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;14598:354;;14664:23;;;;;;;;;;;;;;14598:354;14718:35;14709:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;14705:247;;14813:8;14805:17;;14777:46;;;;;;;;;;;:::i;:::-;;;;;;;;14705:247;14854:30;14845:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;14841:111;;14931:8;14908:32;;;;;;;;;;;:::i;:::-;;;;;;;;14841:111;14417:542;;;:::o;12320:1556::-;12451:7;12460:12;12474:7;13394:66;13389:1;13381:10;;:79;13377:166;;;13493:1;13497:30;13529:1;13477:54;;;;;;;;13377:166;13640:14;13657:24;13667:4;13673:1;13676;13679;13657:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13640:41;;13714:1;13696:20;;:6;:20;;;13692:115;;13749:1;13753:29;13792:1;13784:10;;13733:62;;;;;;;;;13692:115;13827:6;13835:20;13865:1;13857:10;;13819:49;;;;;;;12320:1556;;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:117::-;1306:1;1303;1296:12;1320:117;1429:1;1426;1419:12;1443:117;1552:1;1549;1542:12;1579:552;1636:8;1646:6;1696:3;1689:4;1681:6;1677:17;1673:27;1663:122;;1704:79;;:::i;:::-;1663:122;1817:6;1804:20;1794:30;;1847:18;1839:6;1836:30;1833:117;;;1869:79;;:::i;:::-;1833:117;1983:4;1975:6;1971:17;1959:29;;2037:3;2029:4;2021:6;2017:17;2007:8;2003:32;2000:41;1997:128;;;2044:79;;:::i;:::-;1997:128;1579:552;;;;;:::o;2137:963::-;2234:6;2242;2250;2258;2266;2315:3;2303:9;2294:7;2290:23;2286:33;2283:120;;;2322:79;;:::i;:::-;2283:120;2442:1;2467:53;2512:7;2503:6;2492:9;2488:22;2467:53;:::i;:::-;2457:63;;2413:117;2569:2;2595:53;2640:7;2631:6;2620:9;2616:22;2595:53;:::i;:::-;2585:63;;2540:118;2697:2;2723:53;2768:7;2759:6;2748:9;2744:22;2723:53;:::i;:::-;2713:63;;2668:118;2853:2;2842:9;2838:18;2825:32;2884:18;2876:6;2873:30;2870:117;;;2906:79;;:::i;:::-;2870:117;3019:64;3075:7;3066:6;3055:9;3051:22;3019:64;:::i;:::-;3001:82;;;;2796:297;2137:963;;;;;;;;:::o;3106:149::-;3142:7;3182:66;3175:5;3171:78;3160:89;;3106:149;;;:::o;3261:115::-;3346:23;3363:5;3346:23;:::i;:::-;3341:3;3334:36;3261:115;;:::o;3382:218::-;3473:4;3511:2;3500:9;3496:18;3488:26;;3524:69;3590:1;3579:9;3575:17;3566:6;3524:69;:::i;:::-;3382:218;;;;:::o;3606:329::-;3665:6;3714:2;3702:9;3693:7;3689:23;3685:32;3682:119;;;3720:79;;:::i;:::-;3682:119;3840:1;3865:53;3910:7;3901:6;3890:9;3886:22;3865:53;:::i;:::-;3855:63;;3811:117;3606:329;;;;:::o;3941:118::-;4028:24;4046:5;4028:24;:::i;:::-;4023:3;4016:37;3941:118;;:::o;4065:222::-;4158:4;4196:2;4185:9;4181:18;4173:26;;4209:71;4277:1;4266:9;4262:17;4253:6;4209:71;:::i;:::-;4065:222;;;;:::o;4310:568::-;4383:8;4393:6;4443:3;4436:4;4428:6;4424:17;4420:27;4410:122;;4451:79;;:::i;:::-;4410:122;4564:6;4551:20;4541:30;;4594:18;4586:6;4583:30;4580:117;;;4616:79;;:::i;:::-;4580:117;4730:4;4722:6;4718:17;4706:29;;4784:3;4776:4;4768:6;4764:17;4754:8;4750:32;4747:41;4744:128;;;4791:79;;:::i;:::-;4744:128;4310:568;;;;;:::o;4884:559::-;4970:6;4978;5027:2;5015:9;5006:7;5002:23;4998:32;4995:119;;;5033:79;;:::i;:::-;4995:119;5181:1;5170:9;5166:17;5153:31;5211:18;5203:6;5200:30;5197:117;;;5233:79;;:::i;:::-;5197:117;5346:80;5418:7;5409:6;5398:9;5394:22;5346:80;:::i;:::-;5328:98;;;;5124:312;4884:559;;;;;:::o;5449:118::-;5536:24;5554:5;5536:24;:::i;:::-;5531:3;5524:37;5449:118;;:::o;5573:222::-;5666:4;5704:2;5693:9;5689:18;5681:26;;5717:71;5785:1;5774:9;5770:17;5761:6;5717:71;:::i;:::-;5573:222;;;;:::o;5801:329::-;5860:6;5909:2;5897:9;5888:7;5884:23;5880:32;5877:119;;;5915:79;;:::i;:::-;5877:119;6035:1;6060:53;6105:7;6096:6;6085:9;6081:22;6060:53;:::i;:::-;6050:63;;6006:117;5801:329;;;;:::o;6136:90::-;6170:7;6213:5;6206:13;6199:21;6188:32;;6136:90;;;:::o;6232:109::-;6313:21;6328:5;6313:21;:::i;:::-;6308:3;6301:34;6232:109;;:::o;6347:210::-;6434:4;6472:2;6461:9;6457:18;6449:26;;6485:65;6547:1;6536:9;6532:17;6523:6;6485:65;:::i;:::-;6347:210;;;;:::o;6563:474::-;6631:6;6639;6688:2;6676:9;6667:7;6663:23;6659:32;6656:119;;;6694:79;;:::i;:::-;6656:119;6814:1;6839:53;6884:7;6875:6;6864:9;6860:22;6839:53;:::i;:::-;6829:63;;6785:117;6941:2;6967:53;7012:7;7003:6;6992:9;6988:22;6967:53;:::i;:::-;6957:63;;6912:118;6563:474;;;;;:::o;7043:114::-;7110:6;7144:5;7138:12;7128:22;;7043:114;;;:::o;7163:184::-;7262:11;7296:6;7291:3;7284:19;7336:4;7331:3;7327:14;7312:29;;7163:184;;;;:::o;7353:132::-;7420:4;7443:3;7435:11;;7473:4;7468:3;7464:14;7456:22;;7353:132;;;:::o;7491:108::-;7568:24;7586:5;7568:24;:::i;:::-;7563:3;7556:37;7491:108;;:::o;7605:179::-;7674:10;7695:46;7737:3;7729:6;7695:46;:::i;:::-;7773:4;7768:3;7764:14;7750:28;;7605:179;;;;:::o;7790:113::-;7860:4;7892;7887:3;7883:14;7875:22;;7790:113;;;:::o;7939:732::-;8058:3;8087:54;8135:5;8087:54;:::i;:::-;8157:86;8236:6;8231:3;8157:86;:::i;:::-;8150:93;;8267:56;8317:5;8267:56;:::i;:::-;8346:7;8377:1;8362:284;8387:6;8384:1;8381:13;8362:284;;;8463:6;8457:13;8490:63;8549:3;8534:13;8490:63;:::i;:::-;8483:70;;8576:60;8629:6;8576:60;:::i;:::-;8566:70;;8422:224;8409:1;8406;8402:9;8397:14;;8362:284;;;8366:14;8662:3;8655:10;;8063:608;;;7939:732;;;;:::o;8677:373::-;8820:4;8858:2;8847:9;8843:18;8835:26;;8907:9;8901:4;8897:20;8893:1;8882:9;8878:17;8871:47;8935:108;9038:4;9029:6;8935:108;:::i;:::-;8927:116;;8677:373;;;;:::o;9056:902::-;9162:6;9170;9178;9186;9235:2;9223:9;9214:7;9210:23;9206:32;9203:119;;;9241:79;;:::i;:::-;9203:119;9389:1;9378:9;9374:17;9361:31;9419:18;9411:6;9408:30;9405:117;;;9441:79;;:::i;:::-;9405:117;9554:80;9626:7;9617:6;9606:9;9602:22;9554:80;:::i;:::-;9536:98;;;;9332:312;9711:2;9700:9;9696:18;9683:32;9742:18;9734:6;9731:30;9728:117;;;9764:79;;:::i;:::-;9728:117;9877:64;9933:7;9924:6;9913:9;9909:22;9877:64;:::i;:::-;9859:82;;;;9654:297;9056:902;;;;;;;:::o;9964:60::-;9992:3;10013:5;10006:12;;9964:60;;;:::o;10030:142::-;10080:9;10113:53;10131:34;10140:24;10158:5;10140:24;:::i;:::-;10131:34;:::i;:::-;10113:53;:::i;:::-;10100:66;;10030:142;;;:::o;10178:126::-;10228:9;10261:37;10292:5;10261:37;:::i;:::-;10248:50;;10178:126;;;:::o;10310:141::-;10375:9;10408:37;10439:5;10408:37;:::i;:::-;10395:50;;10310:141;;;:::o;10457:161::-;10559:52;10605:5;10559:52;:::i;:::-;10554:3;10547:65;10457:161;;:::o;10624:252::-;10732:4;10770:2;10759:9;10755:18;10747:26;;10783:86;10866:1;10855:9;10851:17;10842:6;10783:86;:::i;:::-;10624:252;;;;:::o;10882:180::-;10930:77;10927:1;10920:88;11027:4;11024:1;11017:15;11051:4;11048:1;11041:15;11068:442;11217:4;11255:2;11244:9;11240:18;11232:26;;11268:71;11336:1;11325:9;11321:17;11312:6;11268:71;:::i;:::-;11349:72;11417:2;11406:9;11402:18;11393:6;11349:72;:::i;:::-;11431;11499:2;11488:9;11484:18;11475:6;11431:72;:::i;:::-;11068:442;;;;;;:::o;11516:180::-;11564:77;11561:1;11554:88;11661:4;11658:1;11651:15;11685:4;11682:1;11675:15;11702:233;11741:3;11764:24;11782:5;11764:24;:::i;:::-;11755:33;;11810:66;11803:5;11800:77;11797:103;;11880:18;;:::i;:::-;11797:103;11927:1;11920:5;11916:13;11909:20;;11702:233;;;:::o;11941:169::-;12025:11;12059:6;12054:3;12047:19;12099:4;12094:3;12090:14;12075:29;;11941:169;;;;:::o;12116:172::-;12256:24;12252:1;12244:6;12240:14;12233:48;12116:172;:::o;12294:366::-;12436:3;12457:67;12521:2;12516:3;12457:67;:::i;:::-;12450:74;;12533:93;12622:3;12533:93;:::i;:::-;12651:2;12646:3;12642:12;12635:19;;12294:366;;;:::o;12666:419::-;12832:4;12870:2;12859:9;12855:18;12847:26;;12919:9;12913:4;12909:20;12905:1;12894:9;12890:17;12883:47;12947:131;13073:4;12947:131;:::i;:::-;12939:139;;12666:419;;;:::o;13091:117::-;13200:1;13197;13190:12;13214:98;13298:6;13293:3;13288;13275:30;13214:98;;;:::o;13348:537::-;13476:3;13497:86;13576:6;13571:3;13497:86;:::i;:::-;13490:93;;13607:66;13599:6;13596:78;13593:165;;;13677:79;;:::i;:::-;13593:165;13789:4;13781:6;13777:17;13767:27;;13804:43;13840:6;13835:3;13828:5;13804:43;:::i;:::-;13872:6;13867:3;13863:16;13856:23;;13348:537;;;;;:::o;13891:393::-;14044:4;14082:2;14071:9;14067:18;14059:26;;14131:9;14125:4;14121:20;14117:1;14106:9;14102:17;14095:47;14159:118;14272:4;14263:6;14255;14159:118;:::i;:::-;14151:126;;13891:393;;;;;:::o;14290:165::-;14430:17;14426:1;14418:6;14414:14;14407:41;14290:165;:::o;14461:366::-;14603:3;14624:67;14688:2;14683:3;14624:67;:::i;:::-;14617:74;;14700:93;14789:3;14700:93;:::i;:::-;14818:2;14813:3;14809:12;14802:19;;14461:366;;;:::o;14833:419::-;14999:4;15037:2;15026:9;15022:18;15014:26;;15086:9;15080:4;15076:20;15072:1;15061:9;15057:17;15050:47;15114:131;15240:4;15114:131;:::i;:::-;15106:139;;14833:419;;;:::o;15258:94::-;15291:8;15339:5;15335:2;15331:14;15310:35;;15258:94;;;:::o;15358:::-;15397:7;15426:20;15440:5;15426:20;:::i;:::-;15415:31;;15358:94;;;:::o;15458:100::-;15497:7;15526:26;15546:5;15526:26;:::i;:::-;15515:37;;15458:100;;;:::o;15564:157::-;15669:45;15689:24;15707:5;15689:24;:::i;:::-;15669:45;:::i;:::-;15664:3;15657:58;15564:157;;:::o;15727:163::-;15844:11;15881:3;15866:18;;15727:163;;;;:::o;15926:573::-;16072:3;16093:104;16190:6;16185:3;16093:104;:::i;:::-;16086:111;;16221:66;16213:6;16210:78;16207:165;;;16291:79;;:::i;:::-;16207:165;16403:4;16395:6;16391:17;16381:27;;16418:43;16454:6;16449:3;16442:5;16418:43;:::i;:::-;16486:6;16481:3;16477:16;16470:23;;15926:573;;;;;:::o;16505:496::-;16705:3;16720:75;16791:3;16782:6;16720:75;:::i;:::-;16820:2;16815:3;16811:12;16804:19;;16840:135;16971:3;16962:6;16954;16840:135;:::i;:::-;16833:142;;16992:3;16985:10;;16505:496;;;;;;:::o;17007:167::-;17147:19;17143:1;17135:6;17131:14;17124:43;17007:167;:::o;17180:366::-;17322:3;17343:67;17407:2;17402:3;17343:67;:::i;:::-;17336:74;;17419:93;17508:3;17419:93;:::i;:::-;17537:2;17532:3;17528:12;17521:19;;17180:366;;;:::o;17552:419::-;17718:4;17756:2;17745:9;17741:18;17733:26;;17805:9;17799:4;17795:20;17791:1;17780:9;17776:17;17769:47;17833:131;17959:4;17833:131;:::i;:::-;17825:139;;17552:419;;;:::o;17977:194::-;18017:4;18037:20;18055:1;18037:20;:::i;:::-;18032:25;;18071:20;18089:1;18071:20;:::i;:::-;18066:25;;18115:1;18112;18108:9;18100:17;;18139:1;18133:4;18130:11;18127:37;;;18144:18;;:::i;:::-;18127:37;17977:194;;;;:::o;18177:180::-;18225:77;18222:1;18215:88;18322:4;18319:1;18312:15;18346:4;18343:1;18336:15;18363:180;18411:77;18408:1;18401:88;18508:4;18505:1;18498:15;18532:4;18529:1;18522:15;18549:77;18586:7;18615:5;18604:16;;18549:77;;;:::o;18632:118::-;18719:24;18737:5;18719:24;:::i;:::-;18714:3;18707:37;18632:118;;:::o;18756:222::-;18849:4;18887:2;18876:9;18872:18;18864:26;;18900:71;18968:1;18957:9;18953:17;18944:6;18900:71;:::i;:::-;18756:222;;;;:::o;18984:86::-;19019:7;19059:4;19052:5;19048:16;19037:27;;18984:86;;;:::o;19076:112::-;19159:22;19175:5;19159:22;:::i;:::-;19154:3;19147:35;19076:112;;:::o;19194:545::-;19367:4;19405:3;19394:9;19390:19;19382:27;;19419:71;19487:1;19476:9;19472:17;19463:6;19419:71;:::i;:::-;19500:68;19564:2;19553:9;19549:18;19540:6;19500:68;:::i;:::-;19578:72;19646:2;19635:9;19631:18;19622:6;19578:72;:::i;:::-;19660;19728:2;19717:9;19713:18;19704:6;19660:72;:::i;:::-;19194:545;;;;;;;:::o

ipfs://87a9d09f23fe19ead3c22cc49742a935fdb4cc3d81bcafbcb9964c71bea72556