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 2024-08-02
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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


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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) 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 FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;




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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

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


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

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

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


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

pragma solidity ^0.8.20;

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


/**
 * @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/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// File: kangamoonclaim.sol


pragma solidity ^0.8.24;






contract KangaClaiming is Ownable, ReentrancyGuard {
    using SafeERC20  for IERC20;

    IERC20 private token;
    bytes32 public root;

    enum Stage { STAGE_1, STAGE_2, STAGE_3, STAGE_4}

    mapping(address => bool) public userInitialized;
    mapping(address => uint256) public userBalance;
    mapping(address => uint256) public tokensClaimed;

    mapping(Stage => bool) public stageStarted;
    mapping(address => mapping(Stage => bool)) public IsClaimed;


    event Claimed(address indexed tokenAddress, address indexed user, uint256 amount, uint256 indexed timestamp);

    constructor(address _token, bytes32 _root) Ownable(msg.sender) {
        token = IERC20(_token);
        root = _root;

    }

    function allowStageRelease(Stage _stage) external onlyOwner {
        require(!stageStarted[_stage], "Stage Already Started..");
        stageStarted[_stage] = true;
    }

    function isValid(bytes32[] memory proof, bytes32 leaf) public view returns (bool) {
       return MerkleProof.verify(proof, root, leaf);
    }

    function setRoot(bytes32 _root) external onlyOwner {
        root = _root;
    }


    function Claim(uint256 _amount, bytes32[] memory proof) external nonReentrant {
        require(msg.sender != address(0), "CONTRACT: Caller is zero address");
        require(address(token) != address(0), "CONTRACT: Token is not set.");
        require(isValid(proof, keccak256(bytes.concat(keccak256(abi.encode(msg.sender, _amount))))), "Caller not whitelisted");

        if(!userInitialized[msg.sender]) {
           userInitialized[msg.sender]  = true;
           userBalance[msg.sender] = _amount;
        } 
        
        uint256 claimAmount = 0;
        if(stageStarted[Stage.STAGE_1] && !IsClaimed[msg.sender][Stage.STAGE_1]) {
            claimAmount = claimAmount + (_amount * 25) / 100;
            IsClaimed[msg.sender][Stage.STAGE_1] = true;
        }
        if(stageStarted[Stage.STAGE_2] && !IsClaimed[msg.sender][Stage.STAGE_2]) {
            claimAmount = claimAmount + (_amount * 25) / 100;
            IsClaimed[msg.sender][Stage.STAGE_2] = true;
        }
        if(stageStarted[Stage.STAGE_3] && !IsClaimed[msg.sender][Stage.STAGE_3]) {
            claimAmount = claimAmount + (_amount * 25) / 100;
            IsClaimed[msg.sender][Stage.STAGE_3] = true;
        }
        if(stageStarted[Stage.STAGE_4] && !IsClaimed[msg.sender][Stage.STAGE_4]) {
            claimAmount = claimAmount + (_amount * 25) / 100;
            IsClaimed[msg.sender][Stage.STAGE_4] = true;
        }

        require(claimAmount <=  userBalance[msg.sender], "Invalid Claim..");
        require(claimAmount >  0, "Invalid Claim..");
        userBalance[msg.sender] = userBalance[msg.sender] - claimAmount;

        
        tokensClaimed[msg.sender] = tokensClaimed[msg.sender] + claimAmount;
        token.safeTransferFrom(owner(), msg.sender, claimAmount);

        emit Claimed(address(token), msg.sender, claimAmount, block.timestamp);
    }


}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"bytes32","name":"_root","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Claimed","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":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"Claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"enum KangaClaiming.Stage","name":"","type":"uint8"}],"name":"IsClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum KangaClaiming.Stage","name":"_stage","type":"uint8"}],"name":"allowStageRelease","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"bytes32","name":"leaf","type":"bytes32"}],"name":"isValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum KangaClaiming.Stage","name":"","type":"uint8"}],"name":"stageStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000b1c9d42fa4ba691efe21656a7e6953d999b990c4c1398a1e73c8b9db758cdbc0042004d4afe14a6f6e3e7cc94f9ea0553f2625fc

-----Decoded View---------------
Arg [0] : _token (address): 0xB1c9D42FA4bA691eFe21656A7e6953d999B990c4
Arg [1] : _root (bytes32): 0xc1398a1e73c8b9db758cdbc0042004d4afe14a6f6e3e7cc94f9ea0553f2625fc

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b1c9d42fa4ba691efe21656a7e6953d999b990c4
Arg [1] : c1398a1e73c8b9db758cdbc0042004d4afe14a6f6e3e7cc94f9ea0553f2625fc

36608:3060:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36867:46;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37350:174;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36920:48;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25667:103;;;:::i;:::-;;24992:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36977:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37026:59;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37532:144;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36813:47;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37684:82;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36729:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25925:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37776:1885;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36867:46;;;;;;;;;;;;;;;;;:::o;37350:174::-;24878:13;:11;:13::i;:::-;37430:12:::1;:20;37443:6;37430:20;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;37429:21;37421:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;37512:4;37489:12;:20;37502:6;37489:20;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;37350:174:::0;:::o;36920:48::-;;;;;;;;;;;;;;;;;:::o;25667:103::-;24878:13;:11;:13::i;:::-;25732:30:::1;25759:1;25732:18;:30::i;:::-;25667:103::o:0;24992:87::-;25038:7;25065:6;;;;;;;;;;;25058:13;;24992:87;:::o;36977:42::-;;;;;;;;;;;;;;;;;;;;;;:::o;37026:59::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;37532:144::-;37608:4;37631:37;37650:5;37657:4;;37663;37631:18;:37::i;:::-;37624:44;;37532:144;;;;:::o;36813:47::-;;;;;;;;;;;;;;;;;;;;;;:::o;37684:82::-;24878:13;:11;:13::i;:::-;37753:5:::1;37746:4;:12;;;;37684:82:::0;:::o;36729:19::-;;;;:::o;25925:220::-;24878:13;:11;:13::i;:::-;26030:1:::1;26010:22;;:8;:22;;::::0;26006:93:::1;;26084:1;26056:31;;;;;;;;;;;:::i;:::-;;;;;;;;26006:93;26109:28;26128:8;26109:18;:28::i;:::-;25925:220:::0;:::o;37776:1885::-;21391:21;:19;:21::i;:::-;37895:1:::1;37873:24;;:10;:24;;::::0;37865:69:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;37979:1;37953:28;;37961:5;;;;;;;;;;;37953:28;;::::0;37945:68:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;38032:83;38040:5;38091:10;38103:7;38080:31;;;;;;;;;:::i;:::-;;;;;;;;;;;;;38070:42;;;;;;38057:56;;;;;;;;:::i;:::-;;;;;;;;;;;;;38047:67;;;;;;38032:7;:83::i;:::-;38024:118;;;;;;;;;;;;:::i;:::-;;;;;;;;;38159:15;:27;38175:10;38159:27;;;;;;;;;;;;;;;;;;;;;;;;;38155:141;;38233:4;38202:15;:27;38218:10;38202:27;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;38277:7;38251:11;:23;38263:10;38251:23;;;;;;;;;;;;;;;:33;;;;38155:141;38317:19;38354:12;:27;38367:13:::0;38354:27:::1;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:68;;;;;38386:9;:21;38396:10;38386:21;;;;;;;;;;;;;;;:36;38408:13:::0;38386:36:::1;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;38385:37;38354:68;38351:206;;;38484:3;38478:2;38468:7;:12;;;;:::i;:::-;38467:20;;;;:::i;:::-;38453:11;:34;;;;:::i;:::-;38439:48;;38541:4;38502:9;:21;38512:10;38502:21;;;;;;;;;;;;;;;:36;38524:13:::0;38502:36:::1;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;38351:206;38570:12;:27;38583:13;38570:27;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:68;;;;;38602:9;:21;38612:10;38602:21;;;;;;;;;;;;;;;:36;38624:13;38602:36;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;38601:37;38570:68;38567:206;;;38700:3;38694:2;38684:7;:12;;;;:::i;:::-;38683:20;;;;:::i;:::-;38669:11;:34;;;;:::i;:::-;38655:48;;38757:4;38718:9;:21;38728:10;38718:21;;;;;;;;;;;;;;;:36;38740:13;38718:36;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;38567:206;38786:12;:27;38799:13;38786:27;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:68;;;;;38818:9;:21;38828:10;38818:21;;;;;;;;;;;;;;;:36;38840:13;38818:36;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;38817:37;38786:68;38783:206;;;38916:3;38910:2;38900:7;:12;;;;:::i;:::-;38899:20;;;;:::i;:::-;38885:11;:34;;;;:::i;:::-;38871:48;;38973:4;38934:9;:21;38944:10;38934:21;;;;;;;;;;;;;;;:36;38956:13;38934:36;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;38783:206;39002:12;:27;39015:13;39002:27:::0;::::1;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:68;;;;;39034:9;:21;39044:10;39034:21;;;;;;;;;;;;;;;:36;39056:13;39034:36:::0;::::1;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;39033:37;39002:68;38999:206;;;39132:3;39126:2;39116:7;:12;;;;:::i;:::-;39115:20;;;;:::i;:::-;39101:11;:34;;;;:::i;:::-;39087:48;;39189:4;39150:9;:21;39160:10;39150:21;;;;;;;;;;;;;;;:36;39172:13;39150:36:::0;::::1;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;38999:206;39241:11;:23;39253:10;39241:23;;;;;;;;;;;;;;;;39225:11;:39;;39217:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;39318:1;39303:11;:16;39295:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;39402:11;39376;:23;39388:10;39376:23;;;;;;;;;;;;;;;;:37;;;;:::i;:::-;39350:11;:23;39362:10;39350:23;;;;;;;;;;;;;;;:63;;;;39492:11;39464:13;:25;39478:10;39464:25;;;;;;;;;;;;;;;;:39;;;;:::i;:::-;39436:13;:25;39450:10;39436:25;;;;;;;;;;;;;;;:67;;;;39514:56;39537:7;:5;:7::i;:::-;39546:10;39558:11;39514:5;;;;;;;;;;;:22;;;;:56;;;;;;:::i;:::-;39637:15;39612:10;39588:65;;39604:5;;;;;;;;;;;39588:65;;;39624:11;39588:65;;;;;;:::i;:::-;;;;;;;;37854:1807;21435:20:::0;:18;:20::i;:::-;37776:1885;;:::o;25157:166::-;25228:12;:10;:12::i;:::-;25217:23;;:7;:5;:7::i;:::-;:23;;;25213:103;;25291:12;:10;:12::i;:::-;25264:40;;;;;;;;;;;:::i;:::-;;;;;;;;25213:103;25157:166::o;26305:191::-;26379:16;26398:6;;;;;;;;;;;26379:25;;26424:8;26415:6;;:17;;;;;;;;;;;;;;;;;;26479:8;26448:40;;26469:8;26448:40;;;;;;;;;;;;26368:128;26305:191;:::o;27839:156::-;27930:4;27983;27954:25;27967:5;27974:4;27954:12;:25::i;:::-;:33;27947:40;;27839:156;;;;;:::o;21471:315::-;20769:1;21600:7;;:18;21596:88;;21642:30;;;;;;;;;;;;;;21596:88;20769:1;21761:7;:17;;;;21471:315::o;14804:190::-;14905:81;14925:5;14947;:18;;;14968:4;14974:2;14978:5;14932:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14905:19;:81::i;:::-;14804:190;;;;:::o;21794:212::-;20726:1;21977:7;:21;;;;21794:212::o;23001:98::-;23054:7;23081:10;23074:17;;23001:98;:::o;28558:296::-;28641:7;28661:20;28684:4;28661:27;;28704:9;28699:118;28723:5;:12;28719:1;:16;28699:118;;;28772:33;28782:12;28796:5;28802:1;28796:8;;;;;;;;:::i;:::-;;;;;;;;28772:9;:33::i;:::-;28757:48;;28737:3;;;;;;;28699:118;;;;28834:12;28827:19;;;28558:296;;;;:::o;17208:638::-;17632:23;17658:33;17686:4;17666:5;17658:27;;;;:33;;;;:::i;:::-;17632:59;;17727:1;17706:10;:17;:22;;:57;;;;;17744:10;17733:30;;;;;;;;;;;;:::i;:::-;17732:31;17706:57;17702:137;;;17820:5;17787:40;;;;;;;;;;;:::i;:::-;;;;;;;;17702:137;17278:568;17208:638;;:::o;35988:149::-;36051:7;36082:1;36078;:5;:51;;36109:20;36124:1;36127;36109:14;:20::i;:::-;36078:51;;;36086:20;36101:1;36104;36086:14;:20::i;:::-;36078:51;36071:58;;35988:149;;;;:::o;9523:153::-;9598:12;9630:38;9652:6;9660:4;9666:1;9630:21;:38::i;:::-;9623:45;;9523:153;;;;:::o;36262:268::-;36330:13;36437:1;36431:4;36424:15;36466:1;36460:4;36453:15;36507:4;36501;36491:21;36482:30;;36262:268;;;;:::o;10011:398::-;10110:12;10163:5;10139:21;:29;10135:110;;;10227:4;10192:41;;;;;;;;;;;:::i;:::-;;;;;;;;10135:110;10256:12;10270:23;10297:6;:11;;10316:5;10323:4;10297:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10255:73;;;;10346:55;10373:6;10381:7;10390:10;10346:26;:55::i;:::-;10339:62;;;;10011:398;;;;;:::o;11487:597::-;11635:12;11665:7;11660:417;;11689:19;11697:10;11689:7;:19::i;:::-;11660:417;;;11938:1;11917:10;:17;:22;:49;;;;;11965:1;11943:6;:18;;;:23;11917:49;11913:121;;;12011:6;11994:24;;;;;;;;;;;:::i;:::-;;;;;;;;11913:121;12055:10;12048:17;;;;11660:417;11487:597;;;;;;:::o;12637:528::-;12790:1;12770:10;:17;:21;12766:392;;;13002:10;12996:17;13059:15;13046:10;13042:2;13038:19;13031:44;12766:392;13129:17;;;;;;;;;;;;;;7:75:1;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334: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:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:109::-;1694:1;1687:5;1684:12;1674:40;;1710:1;1707;1700:12;1674:40;1611:109;:::o;1726:159::-;1782:5;1820:6;1807:20;1798:29;;1836:43;1873:5;1836:43;:::i;:::-;1726:159;;;;:::o;1891:349::-;1960:6;2009:2;1997:9;1988:7;1984:23;1980:32;1977:119;;;2015:79;;:::i;:::-;1977:119;2135:1;2160:63;2215:7;2206:6;2195:9;2191:22;2160:63;:::i;:::-;2150:73;;2106:127;1891:349;;;;:::o;2246:118::-;2333:24;2351:5;2333:24;:::i;:::-;2328:3;2321:37;2246:118;;:::o;2370:222::-;2463:4;2501:2;2490:9;2486:18;2478:26;;2514:71;2582:1;2571:9;2567:17;2558:6;2514:71;:::i;:::-;2370:222;;;;:::o;2598:90::-;2632:7;2675:5;2668:13;2661:21;2650:32;;2598:90;;;:::o;2694:109::-;2775:21;2790:5;2775:21;:::i;:::-;2770:3;2763:34;2694:109;;:::o;2809:210::-;2896:4;2934:2;2923:9;2919:18;2911:26;;2947:65;3009:1;2998:9;2994:17;2985:6;2947:65;:::i;:::-;2809:210;;;;:::o;3025:494::-;3103:6;3111;3160:2;3148:9;3139:7;3135:23;3131:32;3128:119;;;3166:79;;:::i;:::-;3128:119;3286:1;3311:53;3356:7;3347:6;3336:9;3332:22;3311:53;:::i;:::-;3301:63;;3257:117;3413:2;3439:63;3494:7;3485:6;3474:9;3470:22;3439:63;:::i;:::-;3429:73;;3384:128;3025:494;;;;;:::o;3525:117::-;3634:1;3631;3624:12;3648:102;3689:6;3740:2;3736:7;3731:2;3724:5;3720:14;3716:28;3706:38;;3648:102;;;:::o;3756:180::-;3804:77;3801:1;3794:88;3901:4;3898:1;3891:15;3925:4;3922:1;3915:15;3942:281;4025:27;4047:4;4025:27;:::i;:::-;4017:6;4013:40;4155:6;4143:10;4140:22;4119:18;4107:10;4104:34;4101:62;4098:88;;;4166:18;;:::i;:::-;4098:88;4206:10;4202:2;4195:22;3985:238;3942:281;;:::o;4229:129::-;4263:6;4290:20;;:::i;:::-;4280:30;;4319:33;4347:4;4339:6;4319:33;:::i;:::-;4229:129;;;:::o;4364:311::-;4441:4;4531:18;4523:6;4520:30;4517:56;;;4553:18;;:::i;:::-;4517:56;4603:4;4595:6;4591:17;4583:25;;4663:4;4657;4653:15;4645:23;;4364:311;;;:::o;4681:117::-;4790:1;4787;4780:12;4804:77;4841:7;4870:5;4859:16;;4804:77;;;:::o;4887:122::-;4960:24;4978:5;4960:24;:::i;:::-;4953:5;4950:35;4940:63;;4999:1;4996;4989:12;4940:63;4887:122;:::o;5015:139::-;5061:5;5099:6;5086:20;5077:29;;5115:33;5142:5;5115:33;:::i;:::-;5015:139;;;;:::o;5177:710::-;5273:5;5298:81;5314:64;5371:6;5314:64;:::i;:::-;5298:81;:::i;:::-;5289:90;;5399:5;5428:6;5421:5;5414:21;5462:4;5455:5;5451:16;5444:23;;5515:4;5507:6;5503:17;5495:6;5491:30;5544:3;5536:6;5533:15;5530:122;;;5563:79;;:::i;:::-;5530:122;5678:6;5661:220;5695:6;5690:3;5687:15;5661:220;;;5770:3;5799:37;5832:3;5820:10;5799:37;:::i;:::-;5794:3;5787:50;5866:4;5861:3;5857:14;5850:21;;5737:144;5721:4;5716:3;5712:14;5705:21;;5661:220;;;5665:21;5279:608;;5177:710;;;;;:::o;5910:370::-;5981:5;6030:3;6023:4;6015:6;6011:17;6007:27;5997:122;;6038:79;;:::i;:::-;5997:122;6155:6;6142:20;6180:94;6270:3;6262:6;6255:4;6247:6;6243:17;6180:94;:::i;:::-;6171:103;;5987:293;5910:370;;;;:::o;6286:684::-;6379:6;6387;6436:2;6424:9;6415:7;6411:23;6407:32;6404:119;;;6442:79;;:::i;:::-;6404:119;6590:1;6579:9;6575:17;6562:31;6620:18;6612:6;6609:30;6606:117;;;6642:79;;:::i;:::-;6606:117;6747:78;6817:7;6808:6;6797:9;6793:22;6747:78;:::i;:::-;6737:88;;6533:302;6874:2;6900:53;6945:7;6936:6;6925:9;6921:22;6900:53;:::i;:::-;6890:63;;6845:118;6286:684;;;;;:::o;6976:329::-;7035:6;7084:2;7072:9;7063:7;7059:23;7055:32;7052:119;;;7090:79;;:::i;:::-;7052:119;7210:1;7235:53;7280:7;7271:6;7260:9;7256:22;7235:53;:::i;:::-;7225:63;;7181:117;6976:329;;;;:::o;7311:118::-;7398:24;7416:5;7398:24;:::i;:::-;7393:3;7386:37;7311:118;;:::o;7435:222::-;7528:4;7566:2;7555:9;7551:18;7543:26;;7579:71;7647:1;7636:9;7632:17;7623:6;7579:71;:::i;:::-;7435:222;;;;:::o;7663:122::-;7736:24;7754:5;7736:24;:::i;:::-;7729:5;7726:35;7716:63;;7775:1;7772;7765:12;7716:63;7663:122;:::o;7791:139::-;7837:5;7875:6;7862:20;7853:29;;7891:33;7918:5;7891:33;:::i;:::-;7791:139;;;;:::o;7936:684::-;8029:6;8037;8086:2;8074:9;8065:7;8061:23;8057:32;8054:119;;;8092:79;;:::i;:::-;8054:119;8212:1;8237:53;8282:7;8273:6;8262:9;8258:22;8237:53;:::i;:::-;8227:63;;8183:117;8367:2;8356:9;8352:18;8339:32;8398:18;8390:6;8387:30;8384:117;;;8420:79;;:::i;:::-;8384:117;8525:78;8595:7;8586:6;8575:9;8571:22;8525:78;:::i;:::-;8515:88;;8310:303;7936:684;;;;;:::o;8626:180::-;8674:77;8671:1;8664:88;8771:4;8768:1;8761:15;8795:4;8792:1;8785:15;8812:169;8896:11;8930:6;8925:3;8918:19;8970:4;8965:3;8961:14;8946:29;;8812:169;;;;:::o;8987:173::-;9127:25;9123:1;9115:6;9111:14;9104:49;8987:173;:::o;9166:366::-;9308:3;9329:67;9393:2;9388:3;9329:67;:::i;:::-;9322:74;;9405:93;9494:3;9405:93;:::i;:::-;9523:2;9518:3;9514:12;9507:19;;9166:366;;;:::o;9538:419::-;9704:4;9742:2;9731:9;9727:18;9719:26;;9791:9;9785:4;9781:20;9777:1;9766:9;9762:17;9755:47;9819:131;9945:4;9819:131;:::i;:::-;9811:139;;9538:419;;;:::o;9963:182::-;10103:34;10099:1;10091:6;10087:14;10080:58;9963:182;:::o;10151:366::-;10293:3;10314:67;10378:2;10373:3;10314:67;:::i;:::-;10307:74;;10390:93;10479:3;10390:93;:::i;:::-;10508:2;10503:3;10499:12;10492:19;;10151:366;;;:::o;10523:419::-;10689:4;10727:2;10716:9;10712:18;10704:26;;10776:9;10770:4;10766:20;10762:1;10751:9;10747:17;10740:47;10804:131;10930:4;10804:131;:::i;:::-;10796:139;;10523:419;;;:::o;10948:177::-;11088:29;11084:1;11076:6;11072:14;11065:53;10948:177;:::o;11131:366::-;11273:3;11294:67;11358:2;11353:3;11294:67;:::i;:::-;11287:74;;11370:93;11459:3;11370:93;:::i;:::-;11488:2;11483:3;11479:12;11472:19;;11131:366;;;:::o;11503:419::-;11669:4;11707:2;11696:9;11692:18;11684:26;;11756:9;11750:4;11746:20;11742:1;11731:9;11727:17;11720:47;11784:131;11910:4;11784:131;:::i;:::-;11776:139;;11503:419;;;:::o;11928:332::-;12049:4;12087:2;12076:9;12072:18;12064:26;;12100:71;12168:1;12157:9;12153:17;12144:6;12100:71;:::i;:::-;12181:72;12249:2;12238:9;12234:18;12225:6;12181:72;:::i;:::-;11928:332;;;;;:::o;12266:79::-;12305:7;12334:5;12323:16;;12266:79;;;:::o;12351:157::-;12456:45;12476:24;12494:5;12476:24;:::i;:::-;12456:45;:::i;:::-;12451:3;12444:58;12351:157;;:::o;12514:256::-;12626:3;12641:75;12712:3;12703:6;12641:75;:::i;:::-;12741:2;12736:3;12732:12;12725:19;;12761:3;12754:10;;12514:256;;;;:::o;12776:172::-;12916:24;12912:1;12904:6;12900:14;12893:48;12776:172;:::o;12954:366::-;13096:3;13117:67;13181:2;13176:3;13117:67;:::i;:::-;13110:74;;13193:93;13282:3;13193:93;:::i;:::-;13311:2;13306:3;13302:12;13295:19;;12954:366;;;:::o;13326:419::-;13492:4;13530:2;13519:9;13515:18;13507:26;;13579:9;13573:4;13569:20;13565:1;13554:9;13550:17;13543:47;13607:131;13733:4;13607:131;:::i;:::-;13599:139;;13326:419;;;:::o;13751:180::-;13799:77;13796:1;13789:88;13896:4;13893:1;13886:15;13920:4;13917:1;13910:15;13937:410;13977:7;14000:20;14018:1;14000:20;:::i;:::-;13995:25;;14034:20;14052:1;14034:20;:::i;:::-;14029:25;;14089:1;14086;14082:9;14111:30;14129:11;14111:30;:::i;:::-;14100:41;;14290:1;14281:7;14277:15;14274:1;14271:22;14251:1;14244:9;14224:83;14201:139;;14320:18;;:::i;:::-;14201:139;13985:362;13937:410;;;;:::o;14353:180::-;14401:77;14398:1;14391:88;14498:4;14495:1;14488:15;14522:4;14519:1;14512:15;14539:185;14579:1;14596:20;14614:1;14596:20;:::i;:::-;14591:25;;14630:20;14648:1;14630:20;:::i;:::-;14625:25;;14669:1;14659:35;;14674:18;;:::i;:::-;14659:35;14716:1;14713;14709:9;14704:14;;14539:185;;;;:::o;14730:191::-;14770:3;14789:20;14807:1;14789:20;:::i;:::-;14784:25;;14823:20;14841:1;14823:20;:::i;:::-;14818:25;;14866:1;14863;14859:9;14852:16;;14887:3;14884:1;14881:10;14878:36;;;14894:18;;:::i;:::-;14878:36;14730:191;;;;:::o;14927:165::-;15067:17;15063:1;15055:6;15051:14;15044:41;14927:165;:::o;15098:366::-;15240:3;15261:67;15325:2;15320:3;15261:67;:::i;:::-;15254:74;;15337:93;15426:3;15337:93;:::i;:::-;15455:2;15450:3;15446:12;15439:19;;15098:366;;;:::o;15470:419::-;15636:4;15674:2;15663:9;15659:18;15651:26;;15723:9;15717:4;15713:20;15709:1;15698:9;15694:17;15687:47;15751:131;15877:4;15751:131;:::i;:::-;15743:139;;15470:419;;;:::o;15895:194::-;15935:4;15955:20;15973:1;15955:20;:::i;:::-;15950:25;;15989:20;16007:1;15989:20;:::i;:::-;15984:25;;16033:1;16030;16026:9;16018:17;;16057:1;16051:4;16048:11;16045:37;;;16062:18;;:::i;:::-;16045:37;15895:194;;;;:::o;16095:442::-;16244:4;16282:2;16271:9;16267:18;16259:26;;16295:71;16363:1;16352:9;16348:17;16339:6;16295:71;:::i;:::-;16376:72;16444:2;16433:9;16429:18;16420:6;16376:72;:::i;:::-;16458;16526:2;16515:9;16511:18;16502:6;16458:72;:::i;:::-;16095:442;;;;;;:::o;16543:180::-;16591:77;16588:1;16581:88;16688:4;16685:1;16678:15;16712:4;16709:1;16702:15;16729:116;16799:21;16814:5;16799:21;:::i;:::-;16792:5;16789:32;16779:60;;16835:1;16832;16825:12;16779:60;16729:116;:::o;16851:137::-;16905:5;16936:6;16930:13;16921:22;;16952:30;16976:5;16952:30;:::i;:::-;16851:137;;;;:::o;16994:345::-;17061:6;17110:2;17098:9;17089:7;17085:23;17081:32;17078:119;;;17116:79;;:::i;:::-;17078:119;17236:1;17261:61;17314:7;17305:6;17294:9;17290:22;17261:61;:::i;:::-;17251:71;;17207:125;16994:345;;;;:::o;17345:98::-;17396:6;17430:5;17424:12;17414:22;;17345:98;;;:::o;17449:147::-;17550:11;17587:3;17572:18;;17449:147;;;;:::o;17602:139::-;17691:6;17686:3;17681;17675:23;17732:1;17723:6;17718:3;17714:16;17707:27;17602:139;;;:::o;17747:386::-;17851:3;17879:38;17911:5;17879:38;:::i;:::-;17933:88;18014:6;18009:3;17933:88;:::i;:::-;17926:95;;18030:65;18088:6;18083:3;18076:4;18069:5;18065:16;18030:65;:::i;:::-;18120:6;18115:3;18111:16;18104:23;;17855:278;17747:386;;;;:::o;18139:271::-;18269:3;18291:93;18380:3;18371:6;18291:93;:::i;:::-;18284:100;;18401:3;18394:10;;18139:271;;;;:::o

ipfs://22d661207415b4459ec5932000fa292f7417e62e4c2190dfd3cb053d7158920b