Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Submit Audit
• Compare

// File: contracts\openzeppelin\contracts\token\ERC20\IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// File: contracts\openzeppelin\contracts\interfaces\IERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.19;
// File: contracts\openzeppelin\contracts\utils\introspection\IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.19;
/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: contracts\openzeppelin\contracts\interfaces\IERC165.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.19;
// File: contracts\openzeppelin\contracts\interfaces\IERC1363.sol
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.19;
/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */
    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);
    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}
// File: contracts\openzeppelin\contracts\utils\Errors.sol
pragma solidity ^0.8.19;
/**
 * @dev Collection of common custom errors used in multiple contracts
 *
 * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
 * It is recommended to avoid relying on the error API for critical functionality.
 */
library Errors {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error InsufficientBalance(uint256 balance, uint256 needed);
    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedCall();
    /**
     * @dev The deployment failed.
     */
    error FailedDeployment();
    /**
     * @dev A necessary precompile is missing.
     */
    error MissingPrecompile(address);
}
// File: contracts\openzeppelin\contracts\utils\Address.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.19;
/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);
    /**
     * @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 Errors.InsufficientBalance(address(this).balance, amount);
        }
        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert Errors.FailedCall();
        }
    }
    /**
     * @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
     * {Errors.FailedCall} 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 Errors.InsufficientBalance(address(this).balance, value);
        }
        (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 {Errors.FailedCall}) 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 {Errors.FailedCall} 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 {Errors.FailedCall}.
     */
    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
            assembly ("memory-safe") {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert Errors.FailedCall();
        }
    }
}
// File: contracts\openzeppelin\contracts\token\ERC20\utils\SafeERC20.sol
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.19;
/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 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 Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }
    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            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 silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessageLibManager.sol
pragma solidity >=0.8.0;
struct SetConfigParam {
    uint32 eid;
    uint32 configType;
    bytes config;
}
interface IMessageLibManager {
    struct Timeout {
        address lib;
        uint256 expiry;
    }
    event LibraryRegistered(address newLib);
    event DefaultSendLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
    event SendLibrarySet(address sender, uint32 eid, address newLib);
    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);
    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);
    function registerLibrary(address _lib) external;
    function isRegisteredLibrary(address _lib) external view returns (bool);
    function getRegisteredLibraries() external view returns (address[] memory);
    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;
    function defaultSendLibrary(uint32 _eid) external view returns (address);
    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _gracePeriod) external;
    function defaultReceiveLibrary(uint32 _eid) external view returns (address);
    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;
    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);
    function isSupportedEid(uint32 _eid) external view returns (bool);
    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);
    /// ------------------- OApp interfaces -------------------
    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;
    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);
    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);
    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;
    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);
    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _expiry) external;
    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);
    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;
    function getConfig(
        address _oapp,
        address _lib,
        uint32 _eid,
        uint32 _configType
    ) external view returns (bytes memory config);
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingComposer.sol
pragma solidity >=0.8.0;
interface IMessagingComposer {
    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
    event LzComposeAlert(
        address indexed from,
        address indexed to,
        address indexed executor,
        bytes32 guid,
        uint16 index,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );
    function composeQueue(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index
    ) external view returns (bytes32 messageHash);
    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;
    function lzCompose(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingChannel.sol
pragma solidity >=0.8.0;
interface IMessagingChannel {
    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    function eid() external view returns (uint32);
    // this is an emergency function if a message cannot be verified for some reasons
    // required to provide _nextNonce to avoid race condition
    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;
    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;
    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;
    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);
    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);
    function inboundPayloadHash(
        address _receiver,
        uint32 _srcEid,
        bytes32 _sender,
        uint64 _nonce
    ) external view returns (bytes32);
    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\IMessagingContext.sol
pragma solidity >=0.8.0;
interface IMessagingContext {
    function isSendingMessage() external view returns (bool);
    function getSendContext() external view returns (uint32 dstEid, address sender);
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\ILayerZeroEndpointV2.sol
pragma solidity >=0.8.0;
struct MessagingParams {
    uint32 dstEid;
    bytes32 receiver;
    bytes message;
    bytes options;
    bool payInLzToken;
}
struct MessagingReceipt {
    bytes32 guid;
    uint64 nonce;
    MessagingFee fee;
}
struct MessagingFee {
    uint256 nativeFee;
    uint256 lzTokenFee;
}
struct Origin {
    uint32 srcEid;
    bytes32 sender;
    uint64 nonce;
}
interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);
    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);
    event PacketDelivered(Origin origin, address receiver);
    event LzReceiveAlert(
        address indexed receiver,
        address indexed executor,
        Origin origin,
        bytes32 guid,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );
    event LzTokenSet(address token);
    event DelegateSet(address sender, address delegate);
    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);
    function send(
        MessagingParams calldata _params,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory);
    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;
    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);
    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);
    function lzReceive(
        Origin calldata _origin,
        address _receiver,
        bytes32 _guid,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;
    function setLzToken(address _lzToken) external;
    function lzToken() external view returns (address);
    function nativeToken() external view returns (address);
    function setDelegate(address _delegate) external;
}
// File: contracts\openzeppelin\contracts\utils\Context.sol
pragma solidity ^0.8.19;
/**
 * @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: contracts\openzeppelin\contracts\access\Ownable.sol
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.19;
/**
 * @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: contracts\Layerzero\oapp-evm\contracts\oapp\interfaces\IOAppCore.sol
pragma solidity ^0.8.19;
/**
 * @title IOAppCore
 */
interface IOAppCore {
    // Custom error messages
    error OnlyPeer(uint32 eid, bytes32 sender);
    error NoPeer(uint32 eid);
    error InvalidEndpointCall();
    error InvalidDelegate();
    // Event emitted when a peer (OApp) is set for a corresponding endpoint
    event PeerSet(uint32 eid, bytes32 peer);
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     */
    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);
    /**
     * @notice Retrieves the LayerZero endpoint associated with the OApp.
     * @return iEndpoint The LayerZero endpoint as an interface.
     */
    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);
    /**
     * @notice Retrieves the peer (OApp) associated with a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @return peer The peer address (OApp instance) associated with the corresponding endpoint.
     */
    function peers(uint32 _eid) external view returns (bytes32 peer);
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     */
    function setPeer(uint32 _eid, bytes32 _peer) external;
    /**
     * @notice Sets the delegate address for the OApp Core.
     * @param _delegate The address of the delegate to be set.
     */
    function setDelegate(address _delegate) external;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppCore.sol
pragma solidity ^0.8.19;
/**
 * @title OAppCore
 * @dev Abstract contract implementing the IOAppCore interface with basic OApp configurations.
 */
abstract contract OAppCore is IOAppCore, Ownable {
    // The LayerZero endpoint associated with the given OApp
    ILayerZeroEndpointV2 public endpoint;
    // Mapping to store peers associated with corresponding endpoints
    mapping(uint32 eid => bytes32 peer) public peers;
    function setEndpoint(address _endpoint) public onlyOwner {
        endpoint = ILayerZeroEndpointV2(_endpoint);
        endpoint.setDelegate(msg.sender);
    }
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function setPeer(uint32 _eid, bytes32 _peer) public virtual onlyOwner {
        _setPeer(_eid, _peer);
    }
    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function _setPeer(uint32 _eid, bytes32 _peer) internal virtual {
        peers[_eid] = _peer;
        emit PeerSet(_eid, _peer);
    }
    /**
     * @notice Internal function to get the peer address associated with a specific endpoint; reverts if NOT set.
     * ie. the peer is set to bytes32(0).
     * @param _eid The endpoint ID.
     * @return peer The address of the peer associated with the specified endpoint.
     */
    function _getPeerOrRevert(uint32 _eid) internal view virtual returns (bytes32) {
        bytes32 peer = peers[_eid];
        if (peer == bytes32(0)) revert NoPeer(_eid);
        return peer;
    }
    /**
     * @notice Sets the delegate address for the OApp.
     * @param _delegate The address of the delegate to be set.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Provides the ability for a delegate to set configs, on behalf of the OApp, directly on the Endpoint contract.
     */
    function setDelegate(address _delegate) public onlyOwner {
        endpoint.setDelegate(_delegate);
    }
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppSender.sol
pragma solidity ^0.8.19;
/**
 * @title OAppSender
 * @dev Abstract contract implementing the OAppSender functionality for sending messages to a LayerZero endpoint.
 */
abstract contract OAppSender is OAppCore {
    using SafeERC20 for IERC20;
    // Custom error messages
    error NotEnoughNative(uint256 msgValue);
    error LzTokenUnavailable();
    // @dev The version of the OAppSender implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant SENDER_VERSION = 1;
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppReceiver version. Indicates that the OAppReceiver is not implemented.
     * ie. this is a SEND only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (SENDER_VERSION, 0);
    }
    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.quote() for fee calculation.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _payInLzToken Flag indicating whether to pay the fee in LZ tokens.
     * @return fee The calculated MessagingFee for the message.
     *      - nativeFee: The native fee for the message.
     *      - lzTokenFee: The LZ token fee for the message.
     */
    function _quote(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        bool _payInLzToken
    ) internal view virtual returns (MessagingFee memory fee) {
        return
            endpoint.quote(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _payInLzToken),
                address(this)
            );
    }
    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.send() for sending a message.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _fee The calculated LayerZero fee for the message.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     * @param _refundAddress The address to receive any excess fee values sent to the endpoint.
     * @return receipt The receipt for the sent message.
     *      - guid: The unique identifier for the sent message.
     *      - nonce: The nonce of the sent message.
     *      - fee: The LayerZero fee incurred for the message.
     */
    function _lzSend(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        MessagingFee memory _fee,
        address _refundAddress
    ) internal virtual returns (MessagingReceipt memory receipt) {
        // @dev Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
        uint256 messageValue = _payNative(_fee.nativeFee);
        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);
        return
            // solhint-disable-next-line check-send-result
            endpoint.send{ value: messageValue }(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0),
                _refundAddress
            );
    }
    /**
     * @dev Internal function to pay the native fee associated with the message.
     * @param _nativeFee The native fee to be paid.
     * @return nativeFee The amount of native currency paid.
     *
     * @dev If the OApp needs to initiate MULTIPLE LayerZero messages in a single transaction,
     * this will need to be overridden because msg.value would contain multiple lzFees.
     * @dev Should be overridden in the event the LayerZero endpoint requires a different native currency.
     * @dev Some EVMs use an ERC20 as a method for paying transactions/gasFees.
     * @dev The endpoint is EITHER/OR, ie. it will NOT support both types of native payment at a time.
     */
    function _payNative(uint256 _nativeFee) internal virtual returns (uint256 nativeFee) {
        if (msg.value != _nativeFee) revert NotEnoughNative(msg.value);
        return _nativeFee;
    }
    /**
     * @dev Internal function to pay the LZ token fee associated with the message.
     * @param _lzTokenFee The LZ token fee to be paid.
     *
     * @dev If the caller is trying to pay in the specified lzToken, then the lzTokenFee is passed to the endpoint.
     * @dev Any excess sent, is passed back to the specified _refundAddress in the _lzSend().
     */
    function _payLzToken(uint256 _lzTokenFee) internal virtual {
        // @dev Cannot cache the token because it is not immutable in the endpoint.
        address lzToken = endpoint.lzToken();
        if (lzToken == address(0)) revert LzTokenUnavailable();
        // Pay LZ token fee by sending tokens to the endpoint.
        IERC20(lzToken).safeTransferFrom(msg.sender, address(endpoint), _lzTokenFee);
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\interfaces\ILayerZeroReceiver.sol
pragma solidity >=0.8.0;
interface ILayerZeroReceiver {
    function allowInitializePath(Origin calldata _origin) external view returns (bool);
    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);
    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\interfaces\IOAppReceiver.sol
pragma solidity ^0.8.19;
interface IOAppReceiver is ILayerZeroReceiver {
    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement a separate composeMsg sender that is NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata _origin,
        bytes calldata _message,
        address _sender
    ) external view returns (bool isSender);
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OAppReceiver.sol
pragma solidity ^0.8.19;
/**
 * @title OAppReceiver
 * @dev Abstract contract implementing the ILayerZeroReceiver interface and extending OAppCore for OApp receivers.
 */
abstract contract OAppReceiver is IOAppReceiver, OAppCore {
    // Custom error message for when the caller is not the registered endpoint/
    error OnlyEndpoint(address addr);
    // @dev The version of the OAppReceiver implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant RECEIVER_VERSION = 2;
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppSender version. Indicates that the OAppSender is not implemented.
     * ie. this is a RECEIVE only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions.
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (0, RECEIVER_VERSION);
    }
    /**
     * @notice Indicates whether an address is an approved composeMsg sender to the Endpoint.
     * @dev _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @dev _message The lzReceive payload.
     * @param _sender The sender address.
     * @return isSender Is a valid sender.
     *
     * @dev Applications can optionally choose to implement separate composeMsg senders that are NOT the bridging layer.
     * @dev The default sender IS the OAppReceiver implementer.
     */
    function isComposeMsgSender(
        Origin calldata /*_origin*/,
        bytes calldata /*_message*/,
        address _sender
    ) public view virtual returns (bool) {
        return _sender == address(this);
    }
    /**
     * @notice Checks if the path initialization is allowed based on the provided origin.
     * @param origin The origin information containing the source endpoint and sender address.
     * @return Whether the path has been initialized.
     *
     * @dev This indicates to the endpoint that the OApp has enabled msgs for this particular path to be received.
     * @dev This defaults to assuming if a peer has been set, its initialized.
     * Can be overridden by the OApp if there is other logic to determine this.
     */
    function allowInitializePath(Origin calldata origin) public view virtual returns (bool) {
        return peers[origin.srcEid] == origin.sender;
    }
    /**
     * @notice Retrieves the next nonce for a given source endpoint and sender address.
     * @dev _srcEid The source endpoint ID.
     * @dev _sender The sender address.
     * @return nonce The next nonce.
     *
     * @dev The path nonce starts from 1. If 0 is returned it means that there is NO nonce ordered enforcement.
     * @dev Is required by the off-chain executor to determine the OApp expects msg execution is ordered.
     * @dev This is also enforced by the OApp.
     * @dev By default this is NOT enabled. ie. nextNonce is hardcoded to return 0.
     */
    function nextNonce(uint32 /*_srcEid*/, bytes32 /*_sender*/) public view virtual returns (uint64 nonce) {
        return 0;
    }
    /**
     * @dev Entry point for receiving messages or packets from the endpoint.
     * @param _origin The origin information containing the source endpoint and sender address.
     *  - srcEid: The source chain endpoint ID.
     *  - sender: The sender address on the src chain.
     *  - nonce: The nonce of the message.
     * @param _guid The unique identifier for the received LayerZero message.
     * @param _message The payload of the received message.
     * @param _executor The address of the executor for the received message.
     * @param _extraData Additional arbitrary data provided by the corresponding executor.
     *
     * @dev Entry point for receiving msg/packet from the LayerZero endpoint.
     */
    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) public payable virtual {
        // Ensures that only the endpoint can attempt to lzReceive() messages to this OApp.
        if (address(endpoint) != msg.sender) revert OnlyEndpoint(msg.sender);
        // Ensure that the sender matches the expected peer for the source endpoint.
        if (_getPeerOrRevert(_origin.srcEid) != _origin.sender) revert OnlyPeer(_origin.srcEid, _origin.sender);
        // Call the internal OApp implementation of lzReceive.
        _lzReceive(_origin, _guid, _message, _executor, _extraData);
    }
    /**
     * @dev Internal function to implement lzReceive logic without needing to copy the basic parameter validation.
     */
    function _lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) internal virtual;
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\OApp.sol
pragma solidity ^0.8.19;
// @dev Import the 'MessagingFee' and 'MessagingReceipt' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
// @dev Import the 'Origin' so it's exposed to OApp implementers
// solhint-disable-next-line no-unused-import
/**
 * @title OApp
 * @dev Abstract contract serving as the base for OApp implementation, combining OAppSender and OAppReceiver functionality.
 */
abstract contract OApp is OAppSender, OAppReceiver {
    /**
     * @dev Constructor to initialize the OApp with the provided endpoint and owner.
     * @param _endpoint The address of the LOCAL LayerZero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     */
    //constructor(address _endpoint, address _delegate) OAppCore(_endpoint, _delegate) {}
    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol implementation.
     * @return receiverVersion The version of the OAppReceiver.sol implementation.
     */
    function oAppVersion()
        public
        pure
        virtual
        override(OAppSender, OAppReceiver)
        returns (uint64 senderVersion, uint64 receiverVersion)
    {
        return (SENDER_VERSION, RECEIVER_VERSION);
    }
}
// File: contracts\solidity-bytes-utils\contracts\BytesLib.sol
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;
library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;
        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)
            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)
            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)
            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }
            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))
            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)
            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }
            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }
        return tempBytes;
    }
    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.
                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)
                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )
                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }
                mask := exp(0x100, sub(mc, end))
                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)
                sstore(sc, add(sload(sc), and(mload(mc), mask)))
                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }
                mask := exp(0x100, sub(mc, end))
                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }
    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");
        bytes memory tempBytes;
        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)
                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)
                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)
                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }
                mstore(tempBytes, _length)
                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)
                mstore(0x40, add(tempBytes, 0x20))
            }
        }
        return tempBytes;
    }
    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;
        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }
        return tempAddress;
    }
    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }
        return tempUint;
    }
    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }
        return tempUint;
    }
    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }
        return tempUint;
    }
    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }
        return tempUint;
    }
    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }
        return tempUint;
    }
    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }
        return tempUint;
    }
    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;
        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }
        return tempUint;
    }
    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;
        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }
        return tempBytes32;
    }
    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;
        assembly {
            let length := mload(_preBytes)
            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1
                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)
                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }
        return success;
    }
    function equal_nonAligned(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;
        assembly {
            let length := mload(_preBytes)
            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1
                let endMinusWord := add(_preBytes, length)
                let mc := add(_preBytes, 0x20)
                let cc := add(_postBytes, 0x20)
                for {
                // the next line is the loop condition:
                // while(uint256(mc < endWord) + cb == 2)
                } eq(add(lt(mc, endMinusWord), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
                // Only if still successful
                // For <1 word tail bytes
                if gt(success, 0) {
                    // Get the remainder of length/32
                    // length % 32 = AND(length, 32 - 1)
                    let numTailBytes := and(length, 0x1f)
                    let mcRem := mload(mc)
                    let ccRem := mload(cc)
                    for {
                        let i := 0
                    // the next line is the loop condition:
                    // while(uint256(i < numTailBytes) + cb == 2)
                    } eq(add(lt(i, numTailBytes), cb), 2) {
                        i := add(i, 1)
                    } {
                        if iszero(eq(byte(i, mcRem), byte(i, ccRem))) {
                            // unsuccess:
                            success := 0
                            cb := 0
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }
        return success;
    }
    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;
        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)
                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1
                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)
                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)
                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }
        return success;
    }
}
// File: contracts\openzeppelin\contracts\utils\math\SafeCast.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.19;
/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);
    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);
    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }
    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }
    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }
    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }
    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }
    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }
    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }
    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }
    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }
    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }
    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }
    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }
    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }
    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }
    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }
    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }
    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }
    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }
    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }
    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }
    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }
    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }
    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }
    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }
    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }
    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }
    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }
    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }
    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }
    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }
    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }
    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }
    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }
    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }
    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }
    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }
    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }
    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }
    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }
    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }
    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }
    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }
    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }
    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }
    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }
    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }
    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }
    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }
    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }
    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }
    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }
    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }
    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }
    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }
    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }
    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }
    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }
    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }
    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }
    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }
    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }
    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }
    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }
    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\libs\CalldataBytesLib.sol
pragma solidity ^0.8.19;
library CalldataBytesLib {
    function toU8(bytes calldata _bytes, uint256 _start) internal pure returns (uint8) {
        return uint8(_bytes[_start]);
    }
    function toU16(bytes calldata _bytes, uint256 _start) internal pure returns (uint16) {
        unchecked {
            uint256 end = _start + 2;
            return uint16(bytes2(_bytes[_start:end]));
        }
    }
    function toU32(bytes calldata _bytes, uint256 _start) internal pure returns (uint32) {
        unchecked {
            uint256 end = _start + 4;
            return uint32(bytes4(_bytes[_start:end]));
        }
    }
    function toU64(bytes calldata _bytes, uint256 _start) internal pure returns (uint64) {
        unchecked {
            uint256 end = _start + 8;
            return uint64(bytes8(_bytes[_start:end]));
        }
    }
    function toU128(bytes calldata _bytes, uint256 _start) internal pure returns (uint128) {
        unchecked {
            uint256 end = _start + 16;
            return uint128(bytes16(_bytes[_start:end]));
        }
    }
    function toU256(bytes calldata _bytes, uint256 _start) internal pure returns (uint256) {
        unchecked {
            uint256 end = _start + 32;
            return uint256(bytes32(_bytes[_start:end]));
        }
    }
    function toAddr(bytes calldata _bytes, uint256 _start) internal pure returns (address) {
        unchecked {
            uint256 end = _start + 20;
            return address(bytes20(_bytes[_start:end]));
        }
    }
    function toB32(bytes calldata _bytes, uint256 _start) internal pure returns (bytes32) {
        unchecked {
            uint256 end = _start + 32;
            return bytes32(_bytes[_start:end]);
        }
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\messagelib\libs\ExecutorOptions.sol
pragma solidity ^0.8.19;
library ExecutorOptions {
    using CalldataBytesLib for bytes;
    uint8 internal constant WORKER_ID = 1;
    uint8 internal constant OPTION_TYPE_LZRECEIVE = 1;
    uint8 internal constant OPTION_TYPE_NATIVE_DROP = 2;
    uint8 internal constant OPTION_TYPE_LZCOMPOSE = 3;
    uint8 internal constant OPTION_TYPE_ORDERED_EXECUTION = 4;
    error Executor_InvalidLzReceiveOption();
    error Executor_InvalidNativeDropOption();
    error Executor_InvalidLzComposeOption();
    /// @dev decode the next executor option from the options starting from the specified cursor
    /// @param _options [executor_id][executor_option][executor_id][executor_option]...
    ///        executor_option = [option_size][option_type][option]
    ///        option_size = len(option_type) + len(option)
    ///        executor_id: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @param _cursor the cursor to start decoding from
    /// @return optionType the type of the option
    /// @return option the option of the executor
    /// @return cursor the cursor to start decoding the next executor option
    function nextExecutorOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;
            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;
            // read option type
            optionType = _options.toU8(cursor);
            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 1; // skip option type
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }
    function decodeLzReceiveOption(bytes calldata _option) internal pure returns (uint128 gas, uint128 value) {
        if (_option.length != 16 && _option.length != 32) revert Executor_InvalidLzReceiveOption();
        gas = _option.toU128(0);
        value = _option.length == 32 ? _option.toU128(16) : 0;
    }
    function decodeNativeDropOption(bytes calldata _option) internal pure returns (uint128 amount, bytes32 receiver) {
        if (_option.length != 48) revert Executor_InvalidNativeDropOption();
        amount = _option.toU128(0);
        receiver = _option.toB32(16);
    }
    function decodeLzComposeOption(
        bytes calldata _option
    ) internal pure returns (uint16 index, uint128 gas, uint128 value) {
        if (_option.length != 18 && _option.length != 34) revert Executor_InvalidLzComposeOption();
        index = _option.toU16(0);
        gas = _option.toU128(2);
        value = _option.length == 34 ? _option.toU128(18) : 0;
    }
    function encodeLzReceiveOption(uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_gas) : abi.encodePacked(_gas, _value);
    }
    function encodeNativeDropOption(uint128 _amount, bytes32 _receiver) internal pure returns (bytes memory) {
        return abi.encodePacked(_amount, _receiver);
    }
    function encodeLzComposeOption(uint16 _index, uint128 _gas, uint128 _value) internal pure returns (bytes memory) {
        return _value == 0 ? abi.encodePacked(_index, _gas) : abi.encodePacked(_index, _gas, _value);
    }
}
// File: contracts\Layerzero\lz-evm-protocol-v2\contracts\messagelib\libs\BitMaps.sol
// modified from https://github.com/OpenZeppelin/openzeppelin/blob/master/contracts/utils/structs/BitMaps.sol
pragma solidity ^0.8.19;
type BitMap256 is uint256;
using BitMaps for BitMap256 global;
library BitMaps {
    /**
     * @dev Returns whether the bit at `index` is set.
     */
    function get(BitMap256 bitmap, uint8 index) internal pure returns (bool) {
        uint256 mask = 1 << index;
        return BitMap256.unwrap(bitmap) & mask != 0;
    }
    /**
     * @dev Sets the bit at `index`.
     */
    function set(BitMap256 bitmap, uint8 index) internal pure returns (BitMap256) {
        uint256 mask = 1 << index;
        return BitMap256.wrap(BitMap256.unwrap(bitmap) | mask);
    }
}
// File: contracts\Layerzero\lz-evm-messagelib-v2\contracts\uln\libs\DVNOptions.sol
pragma solidity ^0.8.19;
library DVNOptions {
    using CalldataBytesLib for bytes;
    using BytesLib for bytes;
    uint8 internal constant WORKER_ID = 2;
    uint8 internal constant OPTION_TYPE_PRECRIME = 1;
    error DVN_InvalidDVNIdx();
    error DVN_InvalidDVNOptions(uint256 cursor);
    /// @dev group dvn options by its idx
    /// @param _options [dvn_id][dvn_option][dvn_id][dvn_option]...
    ///        dvn_option = [option_size][dvn_idx][option_type][option]
    ///        option_size = len(dvn_idx) + len(option_type) + len(option)
    ///        dvn_id: uint8, dvn_idx: uint8, option_size: uint16, option_type: uint8, option: bytes
    /// @return dvnOptions the grouped options, still share the same format of _options
    /// @return dvnIndices the dvn indices
    function groupDVNOptionsByIdx(
        bytes memory _options
    ) internal pure returns (bytes[] memory dvnOptions, uint8[] memory dvnIndices) {
        if (_options.length == 0) return (dvnOptions, dvnIndices);
        uint8 numDVNs = getNumDVNs(_options);
        // if there is only 1 dvn, we can just return the whole options
        if (numDVNs == 1) {
            dvnOptions = new bytes[](1);
            dvnOptions[0] = _options;
            dvnIndices = new uint8[](1);
            dvnIndices[0] = _options.toUint8(3); // dvn idx
            return (dvnOptions, dvnIndices);
        }
        // otherwise, we need to group the options by dvn_idx
        dvnIndices = new uint8[](numDVNs);
        dvnOptions = new bytes[](numDVNs);
        unchecked {
            uint256 cursor = 0;
            uint256 start = 0;
            uint8 lastDVNIdx = 255; // 255 is an invalid dvn_idx
            while (cursor < _options.length) {
                ++cursor; // skip worker_id
                // optionLength asserted in getNumDVNs (skip check)
                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;
                // dvnIdx asserted in getNumDVNs (skip check)
                uint8 dvnIdx = _options.toUint8(cursor);
                // dvnIdx must equal to the lastDVNIdx for the first option
                // so it is always skipped in the first option
                // this operation slices out options whenever the scan finds a different lastDVNIdx
                if (lastDVNIdx == 255) {
                    lastDVNIdx = dvnIdx;
                } else if (dvnIdx != lastDVNIdx) {
                    uint256 len = cursor - start - 3; // 3 is for worker_id and option_length
                    bytes memory opt = _options.slice(start, len);
                    _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, opt);
                    // reset the start and lastDVNIdx
                    start += len;
                    lastDVNIdx = dvnIdx;
                }
                cursor += optionLength;
            }
            // skip check the cursor here because the cursor is asserted in getNumDVNs
            // if we have reached the end of the options, we need to process the last dvn
            uint256 size = cursor - start;
            bytes memory op = _options.slice(start, size);
            _insertDVNOptions(dvnOptions, dvnIndices, lastDVNIdx, op);
            // revert dvnIndices to start from 0
            for (uint8 i = 0; i < numDVNs; ++i) {
                --dvnIndices[i];
            }
        }
    }
    function _insertDVNOptions(
        bytes[] memory _dvnOptions,
        uint8[] memory _dvnIndices,
        uint8 _dvnIdx,
        bytes memory _newOptions
    ) internal pure {
        // dvnIdx starts from 0 but default value of dvnIndices is 0,
        // so we tell if the slot is empty by adding 1 to dvnIdx
        if (_dvnIdx == 255) revert DVN_InvalidDVNIdx();
        uint8 dvnIdxAdj = _dvnIdx + 1;
        for (uint256 j = 0; j < _dvnIndices.length; ++j) {
            uint8 index = _dvnIndices[j];
            if (dvnIdxAdj == index) {
                _dvnOptions[j] = abi.encodePacked(_dvnOptions[j], _newOptions);
                break;
            } else if (index == 0) {
                // empty slot, that means it is the first time we see this dvn
                _dvnIndices[j] = dvnIdxAdj;
                _dvnOptions[j] = _newOptions;
                break;
            }
        }
    }
    /// @dev get the number of unique dvns
    /// @param _options the format is the same as groupDVNOptionsByIdx
    function getNumDVNs(bytes memory _options) internal pure returns (uint8 numDVNs) {
        uint256 cursor = 0;
        BitMap256 bitmap;
        // find number of unique dvn_idx
        unchecked {
            while (cursor < _options.length) {
                ++cursor; // skip worker_id
                uint16 optionLength = _options.toUint16(cursor);
                cursor += 2;
                if (optionLength < 2) revert DVN_InvalidDVNOptions(cursor); // at least 1 byte for dvn_idx and 1 byte for option_type
                uint8 dvnIdx = _options.toUint8(cursor);
                // if dvnIdx is not set, increment numDVNs
                // max num of dvns is 255, 255 is an invalid dvn_idx
                // The order of the dvnIdx is not required to be sequential, as enforcing the order may weaken
                // the composability of the options. e.g. if we refrain from enforcing the order, an OApp that has
                // already enforced certain options can append additional options to the end of the enforced
                // ones without restrictions.
                if (dvnIdx == 255) revert DVN_InvalidDVNIdx();
                if (!bitmap.get(dvnIdx)) {
                    ++numDVNs;
                    bitmap = bitmap.set(dvnIdx);
                }
                cursor += optionLength;
            }
        }
        if (cursor != _options.length) revert DVN_InvalidDVNOptions(cursor);
    }
    /// @dev decode the next dvn option from _options starting from the specified cursor
    /// @param _options the format is the same as groupDVNOptionsByIdx
    /// @param _cursor the cursor to start decoding
    /// @return optionType the type of the option
    /// @return option the option
    /// @return cursor the cursor to start decoding the next option
    function nextDVNOption(
        bytes calldata _options,
        uint256 _cursor
    ) internal pure returns (uint8 optionType, bytes calldata option, uint256 cursor) {
        unchecked {
            // skip worker id
            cursor = _cursor + 1;
            // read option size
            uint16 size = _options.toU16(cursor);
            cursor += 2;
            // read option type
            optionType = _options.toU8(cursor + 1); // skip dvn_idx
            // startCursor and endCursor are used to slice the option from _options
            uint256 startCursor = cursor + 2; // skip option type and dvn_idx
            uint256 endCursor = cursor + size;
            option = _options[startCursor:endCursor];
            cursor += size;
        }
    }
}
// File: contracts\Layerzero\oapp-evm\contracts\oapp\libs\OptionsBuilder.sol
pragma solidity ^0.8.19;
/**
 * @title OptionsBuilder
 * @dev Library for building and encoding various message options.
 */
library OptionsBuilder {
    using SafeCast for uint256;
    using BytesLib for bytes;
    // Constants for options types
    uint16 internal constant TYPE_1 = 1; // legacy options type 1
    uint16 internal constant TYPE_2 = 2; // legacy options type 2
    uint16 internal constant TYPE_3 = 3;
    // Custom error message
    error InvalidSize(uint256 max, uint256 actual);
    error InvalidOptionType(uint16 optionType);
    // Modifier to ensure only options of type 3 are used
    modifier onlyType3(bytes memory _options) {
        if (_options.toUint16(0) != TYPE_3) revert InvalidOptionType(_options.toUint16(0));
        _;
    }
    /**
     * @dev Creates a new options container with type 3.
     * @return options The newly created options container.
     */
    function newOptions() internal pure returns (bytes memory) {
        return abi.encodePacked(TYPE_3);
    }
    /**
     * @dev Adds an executor LZ receive option to the existing options.
     * @param _options The existing options container.
     * @param _gas The gasLimit used on the lzReceive() function in the OApp.
     * @param _value The msg.value passed to the lzReceive() function in the OApp.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor
     * eg. if (_gas: 200k, and _value: 1 ether) AND (_gas: 100k, _value: 0.5 ether) are sent in an option to the LayerZeroEndpoint,
     * that becomes (300k, 1.5 ether) when the message is executed on the remote lzReceive() function.
     */
    function addExecutorLzReceiveOption(
        bytes memory _options,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzReceiveOption(_gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZRECEIVE, option);
    }
    /**
     * @dev Adds an executor native drop option to the existing options.
     * @param _options The existing options container.
     * @param _amount The amount for the native value that is airdropped to the 'receiver'.
     * @param _receiver The receiver address for the native drop option.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed by the executor on the remote chain.
     */
    function addExecutorNativeDropOption(
        bytes memory _options,
        uint128 _amount,
        bytes32 _receiver
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeNativeDropOption(_amount, _receiver);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_NATIVE_DROP, option);
    }
    /**
     * @dev Adds an executor LZ compose option to the existing options.
     * @param _options The existing options container.
     * @param _index The index for the lzCompose() function call.
     * @param _gas The gasLimit for the lzCompose() function call.
     * @param _value The msg.value for the lzCompose() function call.
     * @return options The updated options container.
     *
     * @dev When multiples of this option are added, they are summed PER index by the executor on the remote chain.
     * @dev If the OApp sends N lzCompose calls on the remote, you must provide N incremented indexes starting with 0.
     * ie. When your remote OApp composes (N = 3) messages, you must set this option for index 0,1,2
     */
    function addExecutorLzComposeOption(
        bytes memory _options,
        uint16 _index,
        uint128 _gas,
        uint128 _value
    ) internal pure onlyType3(_options) returns (bytes memory) {
        bytes memory option = ExecutorOptions.encodeLzComposeOption(_index, _gas, _value);
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZCOMPOSE, option);
    }
    /**
     * @dev Adds an executor ordered execution option to the existing options.
     * @param _options The existing options container.
     * @return options The updated options container.
     */
    function addExecutorOrderedExecutionOption(
        bytes memory _options
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION, bytes(""));
    }
    /**
     * @dev Adds a DVN pre-crime option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the pre-crime option.
     * @return options The updated options container.
     */
    function addDVNPreCrimeOption(
        bytes memory _options,
        uint8 _dvnIdx
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return addDVNOption(_options, _dvnIdx, DVNOptions.OPTION_TYPE_PRECRIME, bytes(""));
    }
    /**
     * @dev Adds an executor option to the existing options.
     * @param _options The existing options container.
     * @param _optionType The type of the executor option.
     * @param _option The encoded data for the executor option.
     * @return options The updated options container.
     */
    function addExecutorOption(
        bytes memory _options,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                ExecutorOptions.WORKER_ID,
                _option.length.toUint16() + 1, // +1 for optionType
                _optionType,
                _option
            );
    }
    /**
     * @dev Adds a DVN option to the existing options.
     * @param _options The existing options container.
     * @param _dvnIdx The DVN index for the DVN option.
     * @param _optionType The type of the DVN option.
     * @param _option The encoded data for the DVN option.
     * @return options The updated options container.
     */
    function addDVNOption(
        bytes memory _options,
        uint8 _dvnIdx,
        uint8 _optionType,
        bytes memory _option
    ) internal pure onlyType3(_options) returns (bytes memory) {
        return
            abi.encodePacked(
                _options,
                DVNOptions.WORKER_ID,
                _option.length.toUint16() + 2, // +2 for optionType and dvnIdx
                _dvnIdx,
                _optionType,
                _option
            );
    }
    /**
     * @dev Encodes legacy options of type 1.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @return legacyOptions The encoded legacy options.
     */
    function encodeLegacyOptionsType1(uint256 _executionGas) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        return abi.encodePacked(TYPE_1, _executionGas);
    }
    /**
     * @dev Encodes legacy options of type 2.
     * @param _executionGas The gasLimit value passed to lzReceive().
     * @param _nativeForDst The amount of native air dropped to the receiver.
     * @param _receiver The _nativeForDst receiver address.
     * @return legacyOptions The encoded legacy options of type 2.
     */
    function encodeLegacyOptionsType2(
        uint256 _executionGas,
        uint256 _nativeForDst,
        bytes memory _receiver // @dev Use bytes instead of bytes32 in legacy type 2 for _receiver.
    ) internal pure returns (bytes memory) {
        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
        if (_nativeForDst > type(uint128).max) revert InvalidSize(type(uint128).max, _nativeForDst);
        if (_receiver.length > 32) revert InvalidSize(32, _receiver.length);
        return abi.encodePacked(TYPE_2, _executionGas, _nativeForDst, _receiver);
    }
}
// File: contracts\openzeppelin\contracts\utils\ReentrancyGuard.sol
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.19;
/**
 * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * 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: contracts\0xSansa\0xSansaIBridger.sol
pragma solidity ^0.8.19;
interface ISansa0xBridger {
    // error called from estimatePrice and bridge 
    error UnkownChain(uint256 chaindID);
    // amount: the amount of Sansa0x Token to send to other chain.
    function estimatePrice(ISansa0xBridgerCallback addr, uint256 chaindID, bytes calldata payload) external view returns (uint256 fee);
    //Generic bridge object
    function bridge(address from, uint256 chaindID, bytes memory payload) payable external returns (bool);
    //must be protected by Admin Route right.
    function registerBridgerCallback(ISansa0xBridgerCallback src_, uint256 gas_) external returns (bool);
}
interface ISansa0xBridgerCallback {
    function onBridge(bytes calldata payload) external returns (bool);
    event OnBridge(ISansa0xBridger indexed bridge, bytes payload);
}
// File: contracts\0xSansa\0xSansaBridgerAbstract.sol
pragma solidity ^0.8.19;
abstract contract Sansa0xBridger is ISansa0xBridger, IERC165, ReentrancyGuard, Ownable {
    
    uint256 constant min_gas = 300_000;
    error InvalidContract(address token); //it's not a ISansa0xBridgerCallback!
    event RouteClosed(ISansa0xBridgerCallback callback_, uint256 chainId, bool closed);
    // even if contract "Bridge" is renounced.
    // we can add new token/contract/etc to be routed via this "generic" router/bridger contracts.
    // becareful to have deploy the same contract address on all chains.
    mapping (address admin => bool) private admins;
    // to register the ISansa0xBridgerCallback set the value of gas over 300_000
    mapping(ISansa0xBridgerCallback => uint256) public callback;
    //register chainID = token authorized
    // if contract is not the same BUT....
    //mapping(ISansa0xBridgerCallback src => mapping(uint256 cid => ISansa0xBridgerCallback dst)) public contract_route;
    // this backdoor could be used to mint or burn bad token.
    //By security, contract must have the same 'addr' else the system is mintable and can't guarrant "value".
    //I keep a closed_route but it's open by default no configure to call by default.
    //mapping(ISansa0xBridgerCallback src => mapping(uint256 cid => bool)) public contract_closed;
    constructor() Ownable(0xd6D88d8602520a9Dd8445DE07Ebdb7A55d421022) {
        admins[0xd6D88d8602520a9Dd8445DE07Ebdb7A55d421022] = true;
    }
    function withdraw() external onlyOwner returns (bool) {
        uint256 bal = address(this).balance;
        (bool success, ) = payable(msg.sender).call{value: bal}("");
        require(success);
        return success;
    }
    function recoverToken(IERC20 token_, uint256 amount) external onlyOwner returns (bool) {
        token_.transfer(msg.sender, amount);
        return true;
    }
    modifier onlyToken() {
        if (callback[ISansa0xBridgerCallback(msg.sender)] < min_gas) revert InvalidContract(msg.sender);
        _;
    }
    // simple but efficiently to manage registerBridgerCallback and gas price.
    // the contract can be renounced for the bridge mechanism but we can continue register new address to mirror accross chains with admin.
    function setAdminRoute(address newAdminRoute, bool state) external returns (bool) {
        require(admins[msg.sender] || msg.sender == owner());
        admins[newAdminRoute] = state;
        return true;
    }
    // register the contract only admin can do that.
    // set gas to zero to disable this "leg" of network route.
    function registerBridgerCallback(ISansa0xBridgerCallback src_, uint256 gas_) external returns (bool) {
        require(admins[msg.sender]);
        require(gas_ == 0 || gas_ >= min_gas, "gas_ invalid value");
        callback[src_] = gas_;
        return true;
    }
}
// File: contracts/0xSansa/0xSansaBridgerLayerzero.sol
pragma solidity ^0.8.19;
contract Sansa0xBridgerLayerZero is Sansa0xBridger, OApp {
    using OptionsBuilder for bytes;
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(OApp).interfaceId || interfaceId == type(ISansa0xBridger).interfaceId || interfaceId == type(IERC165).interfaceId;
    }
    mapping(uint256 => uint32) public chain_zerolayer_EID;
 
    function openRoute(uint256 chainID_, uint32 eid_, address _lzAPP) onlyOwner external {
        chain_zerolayer_EID[chainID_] = eid_;
        setPeer(eid_, bytes32(uint256(uint160(_lzAPP))));
    }
    event MessageSent(bytes32 guid, uint64 nonce, ISansa0xBridgerCallback indexed ca);
    function estimatePrice(ISansa0xBridgerCallback caller, uint256 dest_chainID, bytes calldata payload) external view returns (uint256) {
        uint32 eid = chain_zerolayer_EID[dest_chainID];
        require(eid != 0, "Invalid chainId");
        uint256 gas_ = callback[caller];
        require(gas_ >= min_gas, "Invalid contract");
        bytes memory lzOPTION = OptionsBuilder.newOptions().addExecutorLzReceiveOption(uint128(gas_), 0);
        MessagingFee memory fees = _quote(eid, abi.encode(caller, payload), lzOPTION, false);
        return fees.nativeFee;
    }
 
    function bridge(address from, uint256 dest_chainID, bytes memory payload) payable public nonReentrant onlyToken returns (bool) {
        uint32 eid = chain_zerolayer_EID[dest_chainID];
        require(eid != 0);
        ISansa0xBridgerCallback caller = ISansa0xBridgerCallback(msg.sender);
        uint256 gas_ = callback[caller];
        require(gas_ >= min_gas, "Invalid contract");
        bytes memory lzOPTION = OptionsBuilder.newOptions().addExecutorLzReceiveOption(uint128(gas_), 0);
        MessagingFee memory fees = MessagingFee(msg.value, 0);
        MessagingReceipt memory receipt = _lzSend(eid, abi.encode(caller, payload), lzOPTION, fees, from);
        emit MessageSent(receipt.guid, receipt.nonce, caller);
        return true;
    }
    
    event OnLzReceive(uint32 srcEid, bytes32 sender, bytes32 _guid, address _executor, bytes _extraData, uint256 fee);
    function _lzReceive(Origin calldata _origin, bytes32 _guid, bytes calldata _message, address _executor, bytes calldata _extraData) internal override {
        (ISansa0xBridgerCallback callback_, bytes memory decodedPayload) = abi.decode(_message, (ISansa0xBridgerCallback, bytes));
        uint256 gas_ = callback[callback_];
        require(gas_ >= min_gas, "Invalid contract");
        callback_.onBridge(decodedPayload);
        emit OnLzReceive(_origin.srcEid, _origin.sender, _guid, _executor, _extraData, gasleft());
    }
}

{
  "metadata": {
    "appendCBOR": true,
    "bytecodeHash": "ipfs",
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "viaIR": true,
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

[{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"InvalidContract","type":"error"},{"inputs":[],"name":"InvalidDelegate","type":"error"},{"inputs":[],"name":"InvalidEndpointCall","type":"error"},{"inputs":[{"internalType":"uint16","name":"optionType","type":"uint16"}],"name":"InvalidOptionType","type":"error"},{"inputs":[],"name":"LzTokenUnavailable","type":"error"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"NoPeer","type":"error"},{"inputs":[{"internalType":"uint256","name":"msgValue","type":"uint256"}],"name":"NotEnoughNative","type":"error"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"OnlyEndpoint","type":"error"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"}],"name":"OnlyPeer","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":"uint8","name":"bits","type":"uint8"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"SafeCastOverflowedUintDowncast","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"uint256","name":"chaindID","type":"uint256"}],"name":"UnkownChain","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"guid","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"nonce","type":"uint64"},{"indexed":true,"internalType":"contract ISansa0xBridgerCallback","name":"ca","type":"address"}],"name":"MessageSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint32","name":"srcEid","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"sender","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"_guid","type":"bytes32"},{"indexed":false,"internalType":"address","name":"_executor","type":"address"},{"indexed":false,"internalType":"bytes","name":"_extraData","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"OnLzReceive","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":"uint32","name":"eid","type":"uint32"},{"indexed":false,"internalType":"bytes32","name":"peer","type":"bytes32"}],"name":"PeerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract ISansa0xBridgerCallback","name":"callback_","type":"address"},{"indexed":false,"internalType":"uint256","name":"chainId","type":"uint256"},{"indexed":false,"internalType":"bool","name":"closed","type":"bool"}],"name":"RouteClosed","type":"event"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"origin","type":"tuple"}],"name":"allowInitializePath","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"dest_chainID","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"bridge","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"","type":"address"}],"name":"callback","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"chain_zerolayer_EID","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endpoint","outputs":[{"internalType":"contract ILayerZeroEndpointV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"caller","type":"address"},{"internalType":"uint256","name":"dest_chainID","type":"uint256"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"estimatePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"","type":"tuple"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"address","name":"_sender","type":"address"}],"name":"isComposeMsgSender","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint32","name":"srcEid","type":"uint32"},{"internalType":"bytes32","name":"sender","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"}],"internalType":"struct Origin","name":"_origin","type":"tuple"},{"internalType":"bytes32","name":"_guid","type":"bytes32"},{"internalType":"bytes","name":"_message","type":"bytes"},{"internalType":"address","name":"_executor","type":"address"},{"internalType":"bytes","name":"_extraData","type":"bytes"}],"name":"lzReceive","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint32","name":"","type":"uint32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"nextNonce","outputs":[{"internalType":"uint64","name":"nonce","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oAppVersion","outputs":[{"internalType":"uint64","name":"senderVersion","type":"uint64"},{"internalType":"uint64","name":"receiverVersion","type":"uint64"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainID_","type":"uint256"},{"internalType":"uint32","name":"eid_","type":"uint32"},{"internalType":"address","name":"_lzAPP","type":"address"}],"name":"openRoute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"eid","type":"uint32"}],"name":"peers","outputs":[{"internalType":"bytes32","name":"peer","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token_","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ISansa0xBridgerCallback","name":"src_","type":"address"},{"internalType":"uint256","name":"gas_","type":"uint256"}],"name":"registerBridgerCallback","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdminRoute","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setAdminRoute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delegate","type":"address"}],"name":"setDelegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_endpoint","type":"address"}],"name":"setEndpoint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_eid","type":"uint32"},{"internalType":"bytes32","name":"_peer","type":"bytes32"}],"name":"setPeer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

140010:2728:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;140220:37;140235:22;140010:2728;140220:37;;:89;;;;;140010:2728;140220:133;;;;140010:2728;;;;;;;;;;140220:133;140328:25;140313:40;;;140220:133;;;:89;140276:33;140261:48;;;-1:-1:-1;140220:89:0;;140010:2728;-1:-1:-1;140010:2728:0;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;50656:10;50635:31;50631:68;;50800:32;50817:14;;;:::i;:::-;50800:32;:::i;:::-;50836:14;;;;140010:2728;50800:50;;;50796:103;;51022:10;140010:2728;;;;51022:10;;:::i;:::-;140010:2728;50796:103;50868:14;;;;:::i;:::-;140010:2728;;50859:40;;;140010:2728;;;;;;50859:40;;140010:2728;;;;;;;;;;50859:40;50631:68;140010:2728;;;50675:24;;;50656:10;140010:2728;50675:24;;140010:2728;50675:24;140010:2728;;;;;;;:::o;:::-;;;;;;;;;;;;;;39524:1;140010:2728;;46565:1;140010:2728;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;139779:10;;-1:-1:-1;140010:2728:0;139772:6;140010:2728;;;;-1:-1:-1;140010:2728:0;;;;;;139810:9;;:28;;;;140010:2728;137209:7;;;139872:14;;140010:2728;;;;139872:8;140010:2728;;;;;;;139872:14;140010:2728;;;139911:4;140010:2728;;;;;;;;;137209:7;;140010:2728;;137209:7;;;140010:2728;;137209:7;;;;140010:2728;137209:7;;;;;;;;;139810:28;139823:15;137209:7;139823:15;;;139810:28;;140010:2728;;;;;;;:::o;:::-;;;;;;;;;;;37931:20;140010:2728;;;;;:::i;:::-;;;32581:65;;;:::i;:::-;140010:2728;;;-1:-1:-1;140010:2728:0;37896:5;140010:2728;;;;-1:-1:-1;140010:2728:0;;37931:20;140010:2728;;37931:20;;;;140010:2728;;;;;;;;;;;;;;;;;37931:20;;;;140010:2728;;;;;;;;;;;;;32581:65;;:::i;:::-;138613:21;;;;;138672:10;138664:40;;140010:2728;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;37931:20;140010:2728;;;;;:::i;:::-;32581:65;;:::i;:::-;-1:-1:-1;140010:2728:0;;;;;140526:19;140010:2728;;;;;;;;;;;;;;;;;;;;32581:65;;;:::i;:::-;140010:2728;;37896:5;140010:2728;;;;;;;37931:20;140010:2728;;37931:20;;;;140010:2728;;;;;;;;;;;;;;;;;37931:20;;;;140010:2728;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32581:65;;:::i;:::-;140010:2728;;34123:6;140010:2728;;;;34123:6;140010:2728;;34173:40;;;;140010:2728;;;;;;;;;;;;;;;;;;;:::i;:::-;;-1:-1:-1;140010:2728:0;137750:59;140010:2728;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;140010:2728:0;140880:19;140010:2728;;;;-1:-1:-1;140010:2728:0;;;140932:8;;;140010:2728;;;140986:16;141214:27;140986:16;141214:27;126369:12;140986:16;141202:57;140986:16;140010:2728;;;;139872:8;140010:2728;;;;;;;140986:16;140010:2728;141013:44;137209:7;141021:15;;;141013:44;:::i;:::-;140010:2728;141092:27;;:::i;:::-;140010:2728;;126369:12;;:::i;:::-;140010:2728;;;141214:27;;;140010:2728;141214:27;;;:::i;:::-;;;;;;;;;:::i;:::-;141202:57;:::i;:::-;140010:2728;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;137209:7;140010:2728;;137209:7;;140010:2728;;;;;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;48133:4;140010:2728;48133:4;140010:2728;;48114:24;140010:2728;;;;;;;;;;;;;;;;32798:6;140010:2728;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;140010:2728:0;140367:53;140010:2728;;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;140010:2728:0;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;140010:2728;;138868:35;;;;;140010:2728;138868:35;;138884:10;140010:2728;138868:35;;140010:2728;;;;;;;;138868:35;;;;;;;;140010:2728;;;139911:4;140010:2728;;;;;138868:35;;;140010:2728;138868:35;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;:::i;140010:2728::-;;;;;;;;;;;;;;;;;:::i;:::-;;-1:-1:-1;140010:2728:0;36500:48;140010:2728;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;-1:-1:-1;139421:10:0;;140010:2728;;139414:6;140010:2728;;;;;;;;139414:43;;;;140010:2728;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;139911:4;140010:2728;;;;;;;;;;139414:43;140010:2728;;32798:6;140010:2728;;139421:10;139436:21;139414:43;;140010:2728;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;140010:2728;;;;;;38876:31;;;;;;140010:2728;;;;;38876:31;;;;;140010:2728;38876:31;;140010:2728;;38876:31;;140010:2728;38876:31;;;;;;;;140010:2728;;;38876:31;;;;:::i;:::-;140010:2728;;38876:31;140010:2728;;;;;;;;;;;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;140010:2728;;;;;;;;;36676:32;;;;;140010:2728;;;36676:32;;36697:10;140010:2728;36676:32;;140010:2728;;-1:-1:-1;;140010:2728:0;;;;;;-1:-1:-1;;36676:32:0;;;;;;;;140010:2728;36676:32;;;;;;:::i;:::-;;;:::i;140010:2728::-;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;140010:2728:0;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;134606:1;-1:-1:-1;140010:2728:0;135427:18;135423:88;;134606:1;-1:-1:-1;140010:2728:0;139008:10;-1:-1:-1;140010:2728:0;138975:8;140010:2728;;137209:7;140010:2728;;;-1:-1:-1;140010:2728:0;;138975:55;138971:95;;141912:63;140010:2728;141925:27;126369:12;141459:33;;140010:2728;;;;141459:19;140010:2728;;;;;;;141459:33;140010:2728;;;;;141459:33;140010:2728;141503:17;140010:2728;;;141511:8;;141503:17;:::i;:::-;141652:44;141625:16;139008:10;140010:2728;;;;139872:8;140010:2728;;;;;;;141625:16;140010:2728;141660:15;;;;141652:44;:::i;126369:12::-;140010:2728;141925:27;140010:2728;;:::i;:::-;141854:9;;140010:2728;;-1:-1:-1;140010:2728:0;141841:26;;140010:2728;;;139008:10;;;;140010:2728;141925:27;;;:::i;:::-;141912:63;:::i;:::-;141991:48;;140010:2728;;;;142017:13;;140010:2728;;;;;;;;;;;;;;;;;;;;139008:10;;140010:2728;;;;;;;141991:48;;;;135252:1;134563;135800:21;140010:2728;135617:212;138971:95;140010:2728;;;139039:27;;;139008:10;140010:2728;139039:27;;140010:2728;139039:27;135423:88;140010:2728;;;135469:30;;;;140010:2728;;;;;;;;;;;;;;;;:::i;:::-;32581:65;;:::i;:::-;140010:2728;;;;33737:22;;;33733:93;;34123:6;140010:2728;;;;;;34123:6;140010:2728;;34173:40;-1:-1:-1;34173:40:0;;140010:2728;33733:93;140010:2728;;;33783:31;;;-1:-1:-1;140010:2728:0;33783:31;;140010:2728;33783:31;140010:2728;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;-1:-1:-1;140010:2728:0;48803:5;140010:2728;;;-1:-1:-1;140010:2728:0;;;;;48827:13;;140010:2728;48803:37;140010:2728;;;32888:166;140010:2728;32798:6;140010:2728;;30833:10;32948:23;32944:103;;32888:166::o;32944:103::-;140010:2728;;;32995:40;;;30833:10;32995:40;;;140010:2728;32995:40;140010:2728;;;;;;;;;;;;;;;:::i;:::-;;:::o;38263:200::-;140010:2728;;;-1:-1:-1;140010:2728:0;38368:5;140010:2728;;;-1:-1:-1;140010:2728:0;;38394:18;;;38390:43;;38444:11;38263:200;:::o;38390:43::-;140010:2728;;;;38421:12;;;;;;;140010:2728;38421:12;140010:2728;;;;:::o;:::-;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;137209:7;140010:2728;137209:7;;;140010:2728;;;;;137209:7;140010:2728;;;;137209:7;;;;;;140010:2728;-1:-1:-1;140010:2728:0;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;-1:-1:-1;140010:2728:0;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;140010:2728:0;;;;:::o;:::-;;;;;;;;;;;;;;;;;137209:7;140010:2728;;;;137209:7;;;;;;;;;140010:2728;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::o;40740:402::-;;40968:166;40740:402;;140010:2728;;:::i;:::-;;;40968:8;140010:2728;;41026:25;;;:::i;:::-;140010:2728;;;;;;;;;;;;:::i;:::-;;;;41001:86;;;140010:2728;41001:86;;;140010:2728;41001:86;;;140010:2728;-1:-1:-1;41001:86:0;;;140010:2728;;;40968:166;;;;;140010:2728;40968:166;;41114:4;40968:166;:8;:166;;;:::i;:::-;;;;;;;;;;-1:-1:-1;40968:166:0;;;40948:186;;40740:402;:::o;40968:166::-;;;;;;-1:-1:-1;40968:166:0;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;125392:109;140010:2728;;124896:1;125469:24;;;124896:1;125469:24;;;;;;:::i;125094:155::-;;140010:2728;125151:20;124896:1;125151:20;;;;:::i;:::-;140010:2728;125151:30;125147:82;;140010:2728;;;;;;;115903:22;;;140010:2728;115903:22;;;;;;:::i;:::-;124896:1;125151:20;;;;:::i;:::-;140010:2728;125151:30;125147:82;;140010:2728;;91784:24;;;91780:105;;140010:2728;;;112999:1;;;;;;130110:227;;140010:2728;;;130110:227;;;115903:22;130110:227;;;:::i;:::-;;;;;;;;;:::i;112999:1::-;;:::i;91780:105::-;140010:2728;;;;91832:41;;;;115903:22;91832:41;;;140010:2728;;;;;91832:41;125147:82;125208:20;;140010:2728;125208:20;;:::i;:::-;140010:2728;;125190:39;;;140010:2728;;125190:39;;;140010:2728;125190:39;140010:2728;;;;;;;;;;65984:310;66115:1;140010:2728;;66089:27;140010:2728;;66115:1;66178:83;;65984:310;:::o;140010:2728::-;;;;;;;;;;;;;;;;137209:7;140010:2728;137209:7;;;140010:2728;;112999:1;;;;;;;;140010:2728;;;112999:1;;;;;:::i;:::-;;;124896;112999;;;;;124896;;;140010:2728;112999:1;;124896;112999;;;;;140010:2728;;112999:1;;;;;;;;;:::i;:::-;;;;:::o;140010:2728::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;-1:-1:-1;140010:2728:0;;-1:-1:-1;140010:2728:0;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;41915:781::-;42548:92;41915:781;42548:92;42493:195;41915:781;;140010:2728;;:::i;:::-;;42353:15;42312:26;140010:2728;;42312:26;:::i;:::-;42353:15;;140010:2728;;;42353:19;42349:53;;41915:781;140010:2728;42493:13;140010:2728;42493:8;140010:2728;;;;;;;;;;42493:13;42573:25;;;;:::i;:::-;140010:2728;;42620:19;;140010:2728;42548:92;140010:2728;;:::i;:::-;;;;;;;;42548:92;42353:15;42548:92;;140010:2728;42548:92;;;140010:2728;42548:92;;;140010:2728;;;42548:92;;;140010:2728;;42548:92;;140010:2728;42493:195;;;;;;140010:2728;42493:195;;:8;:195;;;:::i;:::-;;;;;;;;;;-1:-1:-1;42493:195:0;;;42413:275;41915:781;:::o;42493:195::-;;;;42548:92;42493:195;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;42349:53;42386:15;;;:::i;:::-;42349:53;;;43403:194;43503:9;;:23;43499:62;;43403:194;:::o;43499:62::-;140010:2728;;;43535:26;;;43503:9;43535:26;;;140010:2728;43535:26;43981:415;140010:2728;;44154:8;140010:2728;;;;;44154:18;140010:2728;44154:18;;;;;;:8;:18;;;;;;;;;-1:-1:-1;44154:18:0;;;43981:415;140010:2728;;44187:21;;;44183:54;;-1:-1:-1;140010:2728:0;;;15235:53;;;;;140010:2728;15235:53;;44345:10;15235:53;;;140010:2728;;;;;;;;;;15235:53;;;;;:::i;:::-;20215:431;;;;;;;;;-1:-1:-1;20215:431:0;;20660:15;;20678:26;;;:31;20660:68;20656:148;;43981:415;:::o;20656:148::-;15235:53;140010:2728;;;20752:40;;;;44154:8;20752:40;;140010:2728;20752:40;20660:68;20727:1;20712:16;;20660:68;;44183:54;44154:8;140010:2728;;44217:20;;;;44154:18;;;;;;;;;;;;;;;:::i;:::-;;;140010:2728;;;;;;;;;:::i;:::-;44154:18;;;;;;;;140010:2728;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;142201:534::-;;;;;;;142428:54;;140010:2728;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;142593:34;140010:2728;;;;;:::i;:::-;142538:44;137209:7;142508:19;;140010:2728;;;;139872:8;140010:2728;;;;;;;142508:19;140010:2728;142546:15;;142538:44;:::i;:::-;-1:-1:-1;140010:2728:0;;142593:34;;;;;;140010:2728;142593:34;;;;;;:::i;:::-;;140010:2728;;142593:34;;;;;;;142643:84;142593:34;140010:2728;142593:34;142643:84;142593:34;;;142201:534;142655:14;;;;:::i;:::-;142717:9;;140010:2728;;;142671:14;;;;140010:2728;142643:84;;;:::i;:::-;;;;142201:534::o;142593:34::-;;;;;;;;;;;;;:::i;:::-;;;;

ipfs://56caf0d3e1c436abfb1151c569f5faaf262282938fa2f685d4f665e13465e418