Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ... interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() library Address    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCallWithValue(addres ...    - function functionStaticCall(address t ...    - function functionDelegateCall(address ...    - function verifyCallResultFromTarget(    - function verifyCallResult(bool succes ...    - function _revert(bytes memory returnd ... library SafeERC20    - function safeTransfer(IERC20 token, a ...    - function safeTransferFrom(IERC20 toke ...    - function safeIncreaseAllowance(IERC20 ...    - function safeDecreaseAllowance(IERC20 ...    - function forceApprove(IERC20 token, a ...    - function _callOptionalReturn(IERC20 t ...    - function _callOptionalReturnBool(IERC ... interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function _msgSender()    - function _msgData()    - function _contextSuffixLength() interface IERC20Errors interface IERC721Errors interface IERC1155Errors    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address from, a ...    - function _transfer(address from, addr ...    - function _update(address from, addres ...    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(address owner, addr ...    - function _approve(address owner, addr ...    - function _spendAllowance(address owne ...    - function burn(uint256 value)    - function burnFrom(address account, ui ...    - function paused()    - function _requireNotPaused()    - function _requirePaused()    - function _pause()    - function _unpause()    - function _update(address from, addres ...    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC3156FlashBorrower    - function onFlashLoan( interface IERC3156FlashLender    - function maxFlashLoan(address token)    - function flashFee(address token, uint ...    - function flashLoan(    - function maxFlashLoan(address token)    - function flashFee(address token, uint ...    - function _flashFee(address token, uin ...    - function _flashFeeReceiver()    - function flashLoan(  contract PocketFiToken is ERC20, E ... *    - function decimals()    - function pause()    - function unpause()    - function _update(address from, addres ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-10-01
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

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/token/ERC20/extensions/IERC20Metadata.sol


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

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// 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/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

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


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

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

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


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

pragma solidity ^0.8.20;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

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


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

pragma solidity ^0.8.20;


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

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

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

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

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

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

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


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

pragma solidity ^0.8.20;



/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract pause mechanism of the contract unreachable, and thus unusable.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_update}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _update(address from, address to, uint256 value) internal virtual override whenNotPaused {
        super._update(from, to, value);
    }
}

// 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/interfaces/IERC3156FlashBorrower.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC3156FlashBorrower.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC3156 FlashBorrower, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 */
interface IERC3156FlashBorrower {
    /**
     * @dev Receive a flash loan.
     * @param initiator The initiator of the loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param fee The additional amount of tokens to repay.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
     */
    function onFlashLoan(
        address initiator,
        address token,
        uint256 amount,
        uint256 fee,
        bytes calldata data
    ) external returns (bytes32);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC3156FlashLender.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface of the ERC3156 FlashLender, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 */
interface IERC3156FlashLender {
    /**
     * @dev The amount of currency available to be lended.
     * @param token The loan currency.
     * @return The amount of `token` that can be borrowed.
     */
    function maxFlashLoan(address token) external view returns (uint256);

    /**
     * @dev The fee to be charged for a given loan.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @return The amount of `token` to be charged for the loan, on top of the returned principal.
     */
    function flashFee(address token, uint256 amount) external view returns (uint256);

    /**
     * @dev Initiate a flash loan.
     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.
     * @param token The loan currency.
     * @param amount The amount of tokens lent.
     * @param data Arbitrary data structure, intended to contain user-defined parameters.
     */
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 amount,
        bytes calldata data
    ) external returns (bool);
}

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


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

pragma solidity ^0.8.20;




/**
 * @dev Implementation of the ERC3156 Flash loans extension, as defined in
 * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].
 *
 * Adds the {flashLoan} method, which provides flash loan support at the token
 * level. By default there is no fee, but this can be changed by overriding {flashFee}.
 *
 * NOTE: When this extension is used along with the {ERC20Capped} or {ERC20Votes} extensions,
 * {maxFlashLoan} will not correctly reflect the maximum that can be flash minted. We recommend
 * overriding {maxFlashLoan} so that it correctly reflects the supply cap.
 */
abstract contract ERC20FlashMint is ERC20, IERC3156FlashLender {
    bytes32 private constant RETURN_VALUE = keccak256("ERC3156FlashBorrower.onFlashLoan");

    /**
     * @dev The loan token is not valid.
     */
    error ERC3156UnsupportedToken(address token);

    /**
     * @dev The requested loan exceeds the max loan value for `token`.
     */
    error ERC3156ExceededMaxLoan(uint256 maxLoan);

    /**
     * @dev The receiver of a flashloan is not a valid {onFlashLoan} implementer.
     */
    error ERC3156InvalidReceiver(address receiver);

    /**
     * @dev Returns the maximum amount of tokens available for loan.
     * @param token The address of the token that is requested.
     * @return The amount of token that can be loaned.
     *
     * NOTE: This function does not consider any form of supply cap, so in case
     * it's used in a token with a cap like {ERC20Capped}, make sure to override this
     * function to integrate the cap instead of `type(uint256).max`.
     */
    function maxFlashLoan(address token) public view virtual returns (uint256) {
        return token == address(this) ? type(uint256).max - totalSupply() : 0;
    }

    /**
     * @dev Returns the fee applied when doing flash loans. This function calls
     * the {_flashFee} function which returns the fee applied when doing flash
     * loans.
     * @param token The token to be flash loaned.
     * @param value The amount of tokens to be loaned.
     * @return The fees applied to the corresponding flash loan.
     */
    function flashFee(address token, uint256 value) public view virtual returns (uint256) {
        if (token != address(this)) {
            revert ERC3156UnsupportedToken(token);
        }
        return _flashFee(token, value);
    }

    /**
     * @dev Returns the fee applied when doing flash loans. By default this
     * implementation has 0 fees. This function can be overloaded to make
     * the flash loan mechanism deflationary.
     * @param token The token to be flash loaned.
     * @param value The amount of tokens to be loaned.
     * @return The fees applied to the corresponding flash loan.
     */
    function _flashFee(address token, uint256 value) internal view virtual returns (uint256) {
        // silence warning about unused variable without the addition of bytecode.
        token;
        value;
        return 0;
    }

    /**
     * @dev Returns the receiver address of the flash fee. By default this
     * implementation returns the address(0) which means the fee amount will be burnt.
     * This function can be overloaded to change the fee receiver.
     * @return The address for which the flash fee will be sent to.
     */
    function _flashFeeReceiver() internal view virtual returns (address) {
        return address(0);
    }

    /**
     * @dev Performs a flash loan. New tokens are minted and sent to the
     * `receiver`, who is required to implement the {IERC3156FlashBorrower}
     * interface. By the end of the flash loan, the receiver is expected to own
     * value + fee tokens and have them approved back to the token contract itself so
     * they can be burned.
     * @param receiver The receiver of the flash loan. Should implement the
     * {IERC3156FlashBorrower-onFlashLoan} interface.
     * @param token The token to be flash loaned. Only `address(this)` is
     * supported.
     * @param value The amount of tokens to be loaned.
     * @param data An arbitrary datafield that is passed to the receiver.
     * @return `true` if the flash loan was successful.
     */
    // This function can reenter, but it doesn't pose a risk because it always preserves the property that the amount
    // minted at the beginning is always recovered and burned at the end, or else the entire function will revert.
    // slither-disable-next-line reentrancy-no-eth
    function flashLoan(
        IERC3156FlashBorrower receiver,
        address token,
        uint256 value,
        bytes calldata data
    ) public virtual returns (bool) {
        uint256 maxLoan = maxFlashLoan(token);
        if (value > maxLoan) {
            revert ERC3156ExceededMaxLoan(maxLoan);
        }
        uint256 fee = flashFee(token, value);
        _mint(address(receiver), value);
        if (receiver.onFlashLoan(_msgSender(), token, value, fee, data) != RETURN_VALUE) {
            revert ERC3156InvalidReceiver(address(receiver));
        }
        address flashFeeReceiver = _flashFeeReceiver();
        _spendAllowance(address(receiver), address(this), value + fee);
        if (fee == 0 || flashFeeReceiver == address(0)) {
            _burn(address(receiver), value + fee);
        } else {
            _burn(address(receiver), value);
            _transfer(address(receiver), flashFeeReceiver, fee);
        }
        return true;
    }
}

// File: PocketFiToken.sol


pragma solidity >=0.6.12 <0.9.0;







/// @custom:security-contact [email protected]

contract PocketFiToken is ERC20, ERC20Burnable, ERC20Pausable, Ownable, ERC20FlashMint {

    constructor() ERC20("PocketFi Token", "PFI") Ownable(msg.sender){
        _mint(msg.sender, 1000000000 * 10 ** decimals());
    }

    // MARK: Common methods
    
    function decimals() public view virtual override returns (uint8) {
        return 10;
    }

    // MARK: Owner methods

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    // MARK: Pausable.

    function _update(address from, address to, uint256 value) internal override(ERC20, ERC20Pausable) {
        super._update(from, to, value);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"maxLoan","type":"uint256"}],"name":"ERC3156ExceededMaxLoan","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC3156InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"ERC3156UnsupportedToken","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","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":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"flashFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC3156FlashBorrower","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flashLoan","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"maxFlashLoan","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

55633:719:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29460:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31753:190;;;;;;:::i;:::-;;:::i;:::-;;;1110:14:1;;1103:22;1085:41;;1073:2;1058:18;31753:190:0;945:187:1;30562:99:0;30641:12;;30562:99;;;1283:25:1;;;1271:2;1256:18;30562:99:0;1137:177:1;32521:249:0;;;;;;:::i;:::-;;:::i;55903:93::-;;;55986:2;1974:36:1;;1962:2;1947:18;55903:93:0;1832:184:1;56103:65:0;;;:::i;:::-;;39385:89;;;;;;:::i;:::-;;:::i;41871:86::-;41942:7;;;;41871:86;;54506:986;;;;;;:::i;:::-;;:::i;51595:163::-;;;;;;:::i;:::-;;:::i;30724:118::-;;;;;;:::i;:::-;-1:-1:-1;;;;;30816:18:0;30789:7;30816:18;;;;;;;;;;;;30724:118;46495:103;;;:::i;39803:161::-;;;;;;:::i;:::-;;:::i;56034:61::-;;;:::i;45820:87::-;45893:6;;;;;-1:-1:-1;;;;;45893:6:0;45820:87;;-1:-1:-1;;;;;3686:32:1;;;3668:51;;3656:2;3641:18;45820:87:0;3522:203:1;29670:95:0;;;:::i;31047:182::-;;;;;;:::i;:::-;;:::i;52133:237::-;;;;;;:::i;:::-;;:::i;31292:142::-;;;;;;:::i;:::-;-1:-1:-1;;;;;31399:18:0;;;31372:7;31399:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;31292:142;46753:220;;;;;;:::i;:::-;;:::i;29460:91::-;29505:13;29538:5;29531:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29460:91;:::o;31753:190::-;31826:4;20545:10;31882:31;20545:10;31898:7;31907:5;31882:8;:31::i;:::-;31931:4;31924:11;;;31753:190;;;;;:::o;32521:249::-;32608:4;20545:10;32666:37;32682:4;20545:10;32697:5;32666:15;:37::i;:::-;32714:26;32724:4;32730:2;32734:5;32714:9;:26::i;:::-;-1:-1:-1;32758:4:0;;32521:249;-1:-1:-1;;;;32521:249:0:o;56103:65::-;45706:13;:11;:13::i;:::-;56150:10:::1;:8;:10::i;:::-;56103:65::o:0;39385:89::-;39440:26;20545:10;39460:5;39440;:26::i;:::-;39385:89;:::o;54506:986::-;54675:4;54692:15;54710:19;54723:5;54710:12;:19::i;:::-;54692:37;;54752:7;54744:5;:15;54740:86;;;54783:31;;-1:-1:-1;;;54783:31:0;;;;;1283:25:1;;;1256:18;;54783:31:0;;;;;;;;54740:86;54836:11;54850:22;54859:5;54866;54850:8;:22::i;:::-;54836:36;;54883:31;54897:8;54908:5;54883;:31::i;:::-;54929:59;;-1:-1:-1;;;54929:59:0;;50673:45;;-1:-1:-1;;;;;54929:20:0;;;;;:59;;20545:10;;54964:5;;54971;;54978:3;;54983:4;;;;54929:59;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:75;54925:156;;55028:41;;-1:-1:-1;;;55028:41:0;;-1:-1:-1;;;;;3686:32:1;;55028:41:0;;;3668:51:1;3641:18;;55028:41:0;3522:203:1;54925:156:0;55091:24;55148:62;55172:8;55191:4;55198:11;55206:3;55198:5;:11;:::i;:::-;55148:15;:62::i;:::-;55225:8;;;:42;;-1:-1:-1;;;;;;55237:30:0;;;55225:42;55221:242;;;55284:37;55298:8;55309:11;55317:3;55309:5;:11;:::i;:::-;55284:5;:37::i;:::-;55221:242;;;55354:31;55368:8;55379:5;55354;:31::i;:::-;55400:51;55418:8;55429:16;55447:3;55400:9;:51::i;:::-;-1:-1:-1;55480:4:0;;54506:986;-1:-1:-1;;;;;;;;54506:986:0:o;51595:163::-;51661:7;-1:-1:-1;;;;;51688:22:0;;51705:4;51688:22;:62;;51749:1;51688:62;;;30641:12;;51713:33;;-1:-1:-1;;51713:33:0;:::i;46495:103::-;45706:13;:11;:13::i;:::-;46560:30:::1;46587:1;46560:18;:30::i;39803:161::-:0;39879:45;39895:7;20545:10;39918:5;39879:15;:45::i;:::-;39935:21;39941:7;39950:5;39935;:21::i;:::-;39803:161;;:::o;56034:61::-;45706:13;:11;:13::i;:::-;56079:8:::1;:6;:8::i;29670:95::-:0;29717:13;29750:7;29743:14;;;;;:::i;31047:182::-;31116:4;20545:10;31172:27;20545:10;31189:2;31193:5;31172:9;:27::i;52133:237::-;52210:7;-1:-1:-1;;;;;52234:22:0;;52251:4;52234:22;52230:92;;52280:30;;-1:-1:-1;;;52280:30:0;;-1:-1:-1;;;;;3686:32:1;;52280:30:0;;;3668:51:1;3641:18;;52280:30:0;3522:203:1;52230:92:0;52848:7;52339:23;52332:30;52133:237;-1:-1:-1;;;52133:237:0:o;46753:220::-;45706:13;:11;:13::i;:::-;-1:-1:-1;;;;;46838:22:0;::::1;46834:93;;46884:31;::::0;-1:-1:-1;;;46884:31:0;;46912:1:::1;46884:31;::::0;::::1;3668:51:1::0;3641:18;;46884:31:0::1;3522:203:1::0;46834:93:0::1;46937:28;46956:8;46937:18;:28::i;36580:130::-:0;36665:37;36674:5;36681:7;36690:5;36697:4;36665:8;:37::i;:::-;36580:130;;;:::o;38296:487::-;-1:-1:-1;;;;;31399:18:0;;;38396:24;31399:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;38463:37:0;;38459:317;;38540:5;38521:16;:24;38517:132;;;38573:60;;-1:-1:-1;;;38573:60:0;;-1:-1:-1;;;;;6047:32:1;;38573:60:0;;;6029:51:1;6096:18;;;6089:34;;;6139:18;;;6132:34;;;6002:18;;38573:60:0;5827:345:1;38517:132:0;38692:57;38701:5;38708:7;38736:5;38717:16;:24;38743:5;38692:8;:57::i;:::-;38385:398;38296:487;;;:::o;33155:308::-;-1:-1:-1;;;;;33239:18:0;;33235:88;;33281:30;;-1:-1:-1;;;33281:30:0;;33308:1;33281:30;;;3668:51:1;3641:18;;33281:30:0;3522:203:1;33235:88:0;-1:-1:-1;;;;;33337:16:0;;33333:88;;33377:32;;-1:-1:-1;;;33377:32:0;;33406:1;33377:32;;;3668:51:1;3641:18;;33377:32:0;3522:203:1;33333:88:0;33431:24;33439:4;33445:2;33449:5;33431:7;:24::i;45985:166::-;45893:6;;-1:-1:-1;;;;;45893:6:0;;;;;20545:10;46045:23;46041:103;;46092:40;;-1:-1:-1;;;46092:40:0;;20545:10;46092:40;;;3668:51:1;3641:18;;46092:40:0;3522:203:1;42772:120:0;41735:16;:14;:16::i;:::-;42831:7:::1;:15:::0;;-1:-1:-1;;42831:15:0::1;::::0;;42862:22:::1;20545:10:::0;42871:12:::1;42862:22;::::0;-1:-1:-1;;;;;3686:32:1;;;3668:51;;3656:2;3641:18;42862:22:0::1;;;;;;;42772:120::o:0;35816:211::-;-1:-1:-1;;;;;35887:21:0;;35883:91;;35932:30;;-1:-1:-1;;;35932:30:0;;35959:1;35932:30;;;3668:51:1;3641:18;;35932:30:0;3522:203:1;35883:91:0;35984:35;35992:7;36009:1;36013:5;35984:7;:35::i;35275:213::-;-1:-1:-1;;;;;35346:21:0;;35342:93;;35391:32;;-1:-1:-1;;;35391:32:0;;35420:1;35391:32;;;3668:51:1;3641:18;;35391:32:0;3522:203:1;35342:93:0;35445:35;35461:1;35465:7;35474:5;35445:7;:35::i;47133:191::-;47226:6;;;-1:-1:-1;;;;;47243:17:0;;;47226:6;47243:17;;;-1:-1:-1;;;;;;47243:17:0;;;;;;47276:40;;47226:6;;;;;;;;47276:40;;47207:16;;47276:40;47196:128;47133:191;:::o;42513:118::-;41476:19;:17;:19::i;:::-;42573:7:::1;:14:::0;;-1:-1:-1;;42573:14:0::1;42583:4;42573:14;::::0;;42603:20:::1;42610:12;20545:10:::0;;20465:98;37561:443;-1:-1:-1;;;;;37674:19:0;;37670:91;;37717:32;;-1:-1:-1;;;37717:32:0;;37746:1;37717:32;;;3668:51:1;3641:18;;37717:32:0;3522:203:1;37670:91:0;-1:-1:-1;;;;;37775:21:0;;37771:92;;37820:31;;-1:-1:-1;;;37820:31:0;;37848:1;37820:31;;;3668:51:1;3641:18;;37820:31:0;3522:203:1;37771:92:0;-1:-1:-1;;;;;37873:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;37919:78;;;;37970:7;-1:-1:-1;;;;;37954:31:0;37963:5;-1:-1:-1;;;;;37954:31:0;;37979:5;37954:31;;;;1283:25:1;;1271:2;1256:18;;1137:177;37954:31:0;;;;;;;;37561:443;;;;:::o;56202:147::-;56311:30;56325:4;56331:2;56335:5;56311:13;:30::i;42239:130::-;41942:7;;;;42298:64;;42335:15;;-1:-1:-1;;;42335:15:0;;;;;;;;;;;42030:132;41942:7;;;;42092:63;;;42128:15;;-1:-1:-1;;;42128:15:0;;;;;;;;;;;43996:147;41476:19;:17;:19::i;:::-;44105:30:::1;44119:4;44125:2;44129:5;-1:-1:-1::0;;;;;33877:18:0;;33873:552;;34031:5;34015:12;;:21;;;;;;;:::i;:::-;;;;-1:-1:-1;33873:552:0;;-1:-1:-1;33873:552:0;;-1:-1:-1;;;;;34091:15:0;;34069:19;34091:15;;;;;;;;;;;34125:19;;;34121:117;;;34172:50;;-1:-1:-1;;;34172:50:0;;-1:-1:-1;;;;;6047:32:1;;34172:50:0;;;6029:51:1;6096:18;;;6089:34;;;6139:18;;;6132:34;;;6002:18;;34172:50:0;5827:345:1;34121:117:0;-1:-1:-1;;;;;34361:15:0;;:9;:15;;;;;;;;;;34379:19;;;;34361:37;;33873:552;-1:-1:-1;;;;;34441:16:0;;34437:435;;34607:12;:21;;;;;;;34437:435;;;-1:-1:-1;;;;;34823:13:0;;:9;:13;;;;;;;;;;:22;;;;;;34437:435;34904:2;-1:-1:-1;;;;;34889:25:0;34898:4;-1:-1:-1;;;;;34889:25:0;;34908:5;34889:25;;;;1283::1;;1271:2;1256:18;;1137:177;34889:25:0;;;;;;;;33787:1135;;;:::o;14:418:1:-;163:2;152:9;145:21;126:4;195:6;189:13;238:6;233:2;222:9;218:18;211:34;297:6;292:2;284:6;280:15;275:2;264:9;260:18;254:50;353:1;348:2;339:6;328:9;324:22;320:31;313:42;423:2;416;412:7;407:2;399:6;395:15;391:29;380:9;376:45;372:54;364:62;;;14:418;;;;:::o;437:131::-;-1:-1:-1;;;;;512:31:1;;502:42;;492:70;;558:1;555;548:12;573:367;641:6;649;702:2;690:9;681:7;677:23;673:32;670:52;;;718:1;715;708:12;670:52;757:9;744:23;776:31;801:5;776:31;:::i;:::-;826:5;904:2;889:18;;;;876:32;;-1:-1:-1;;;573:367:1:o;1319:508::-;1396:6;1404;1412;1465:2;1453:9;1444:7;1440:23;1436:32;1433:52;;;1481:1;1478;1471:12;1433:52;1520:9;1507:23;1539:31;1564:5;1539:31;:::i;:::-;1589:5;-1:-1:-1;1646:2:1;1631:18;;1618:32;1659:33;1618:32;1659:33;:::i;:::-;1319:508;;1711:7;;-1:-1:-1;;;1791:2:1;1776:18;;;;1763:32;;1319:508::o;2021:226::-;2080:6;2133:2;2121:9;2112:7;2108:23;2104:32;2101:52;;;2149:1;2146;2139:12;2101:52;-1:-1:-1;2194:23:1;;2021:226;-1:-1:-1;2021:226:1:o;2252:1013::-;2379:6;2387;2395;2403;2411;2464:3;2452:9;2443:7;2439:23;2435:33;2432:53;;;2481:1;2478;2471:12;2432:53;2520:9;2507:23;2539:31;2564:5;2539:31;:::i;:::-;2589:5;-1:-1:-1;2646:2:1;2631:18;;2618:32;2659:33;2618:32;2659:33;:::i;:::-;2711:7;-1:-1:-1;2791:2:1;2776:18;;2763:32;;-1:-1:-1;2872:2:1;2857:18;;2844:32;2899:18;2888:30;;2885:50;;;2931:1;2928;2921:12;2885:50;2954:22;;3007:4;2999:13;;2995:27;-1:-1:-1;2985:55:1;;3036:1;3033;3026:12;2985:55;3076:2;3063:16;3102:18;3094:6;3091:30;3088:50;;;3134:1;3131;3124:12;3088:50;3179:7;3174:2;3165:6;3161:2;3157:15;3153:24;3150:37;3147:57;;;3200:1;3197;3190:12;3147:57;2252:1013;;;;-1:-1:-1;2252:1013:1;;-1:-1:-1;;;3231:2:1;3223:11;;3253:6;2252:1013::o;3270:247::-;3329:6;3382:2;3370:9;3361:7;3357:23;3353:32;3350:52;;;3398:1;3395;3388:12;3350:52;3437:9;3424:23;3456:31;3481:5;3456:31;:::i;3730:388::-;3798:6;3806;3859:2;3847:9;3838:7;3834:23;3830:32;3827:52;;;3875:1;3872;3865:12;3827:52;3914:9;3901:23;3933:31;3958:5;3933:31;:::i;:::-;3983:5;-1:-1:-1;4040:2:1;4025:18;;4012:32;4053:33;4012:32;4053:33;:::i;:::-;4105:7;4095:17;;;3730:388;;;;;:::o;4123:380::-;4202:1;4198:12;;;;4245;;;4266:61;;4320:4;4312:6;4308:17;4298:27;;4266:61;4373:2;4365:6;4362:14;4342:18;4339:38;4336:161;;4419:10;4414:3;4410:20;4407:1;4400:31;4454:4;4451:1;4444:15;4482:4;4479:1;4472:15;4336:161;;4123:380;;;:::o;4508:730::-;-1:-1:-1;;;;;4777:32:1;;;4759:51;;4846:32;;4841:2;4826:18;;4819:60;4910:2;4895:18;;4888:34;;;4953:2;4938:18;;4931:34;;;4797:3;4996;4981:19;;4974:32;;;5022:19;;5015:35;;;5043:6;5093;5087:3;5072:19;;5059:49;5158:1;5128:22;;;5152:3;5124:32;;;5117:43;;;;5221:2;5200:15;;;-1:-1:-1;;5196:29:1;5181:45;5177:55;;4508:730;-1:-1:-1;;;;;4508:730:1:o;5243:184::-;5313:6;5366:2;5354:9;5345:7;5341:23;5337:32;5334:52;;;5382:1;5379;5372:12;5334:52;-1:-1:-1;5405:16:1;;5243:184;-1:-1:-1;5243:184:1:o;5432:127::-;5493:10;5488:3;5484:20;5481:1;5474:31;5524:4;5521:1;5514:15;5548:4;5545:1;5538:15;5564:125;5629:9;;;5650:10;;;5647:36;;;5663:18;;:::i;5694:128::-;5761:9;;;5782:11;;;5779:37;;;5796:18;;:::i

ipfs://6007dd617755a74605cb38072050111ef176a159680581a298dd594ec3db0e49