Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import {AbstractVerifier, IVerifierHooks} from '../AbstractVerifier.sol';
import {GatewayRequest, GatewayVM, ProofSequence} from '../GatewayVM.sol';
import {ILineaRollup} from './ILineaRollup.sol';

contract LineaVerifier is AbstractVerifier {
    ILineaRollup immutable _rollup;

    constructor(
        string[] memory urls,
        uint256 window,
        IVerifierHooks hooks,
        ILineaRollup rollup
    ) AbstractVerifier(urls, window, hooks) {
        _rollup = rollup;
    }

    function getLatestContext() external view returns (bytes memory) {
        return abi.encode(_rollup.currentL2BlockNumber());
    }

    struct GatewayProof {
        uint256 l2BlockNumber;
        bytes[] proofs;
        bytes order;
    }

    function getStorageValues(
        bytes memory context,
        GatewayRequest memory req,
        bytes memory proof
    ) external view returns (bytes[] memory, uint8 exitCode) {
        uint256 l2BlockNumber1 = abi.decode(context, (uint256));
        GatewayProof memory p = abi.decode(proof, (GatewayProof));
        _checkWindow(l2BlockNumber1, p.l2BlockNumber);
        bytes32 stateRoot = _rollup.stateRootHashes(p.l2BlockNumber);
        if (stateRoot == bytes32(0)) revert('Linea: not finalized');
        return
            GatewayVM.evalRequest(
                req,
                ProofSequence(0, stateRoot, p.proofs, p.order, _hooks)
            );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {IGatewayVerifier, CommitTooOld, CommitTooNew} from './IGatewayVerifier.sol';
import {IVerifierHooks} from './IVerifierHooks.sol';
import {Ownable} from '@openzeppelin/contracts/access/Ownable.sol';

abstract contract AbstractVerifier is IGatewayVerifier, Ownable {
    event GatewayURLsChanged();

    string[] _urls;
    uint256 immutable _window;
    IVerifierHooks immutable _hooks;

    constructor(
        string[] memory urls,
        uint256 window,
        IVerifierHooks hooks
    ) Ownable(msg.sender) {
        _urls = urls;
        _window = window;
        _hooks = hooks;
    }

    function setGatewayURLs(string[] memory urls) external onlyOwner {
        _urls = urls;
        emit GatewayURLsChanged();
    }

    function gatewayURLs() external view returns (string[] memory) {
        return _urls;
    }

    function getWindow() external view returns (uint256) {
        return _window;
    }

    function getHooks() external view returns (IVerifierHooks) {
        return _hooks;
    }

    function _checkWindow(uint256 latest, uint256 got) internal view {
        if (got + _window < latest) revert CommitTooOld(latest, got, _window);
        if (got > latest) revert CommitTooNew(latest, got);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {GatewayRequest, GatewayOP, EvalFlag} from './GatewayRequest.sol';
import {IVerifierHooks, InvalidProof, NOT_A_CONTRACT} from './IVerifierHooks.sol';
import {Bytes} from '../lib/optimism/packages/contracts-bedrock/src/libraries/Bytes.sol'; // Bytes.slice

import 'forge-std/console.sol'; // DEBUG

struct ProofSequence {
    uint256 index;
    bytes32 stateRoot;
    bytes[] proofs;
    bytes order;
    IVerifierHooks hooks;
}

library GatewayVM {
    error InvalidRequest();
    error InvalidStackIndex();
    error StackOverflow();

    // current limit is 256 because of stackBits
    uint256 constant MAX_STACK = 256;

    function dump(Machine memory vm, string memory label) internal view {
        console.log('DEBUG(%s)', label);
        console.log('[pos=%s/%s]', vm.pos, vm.buf.length);
        if (vm.buf.length < 256) console.logBytes(vm.buf); // prevent spam
        console.log('[target=%s slot=%s]', vm.target, vm.slot);
        console.log('[proof=%s/%s]', vm.proofs.index, vm.proofs.order.length);
        console.log('[stackSize=%s]', vm.stackSize);
        for (uint256 i; i < vm.stackSize; i++) {
            bytes memory v = vm.stackAsBytes(i);
            console.log('%s [size=%s raw=%s]', i, v.length, vm.isStackRaw(i));
            console.logBytes(v);
        }
        uint256 mem;
        assembly {
            mem := mload(64)
        }
        console.log('[memory=%s gas=%s]', mem, gasleft());
    }

    function smallKeccak(bytes32 x) internal pure returns (bytes32 ret) {
        assembly {
            mstore(0, x)
            ret := keccak256(0, 32)
        }
    }

    function isZeros(bytes memory v) internal pure returns (bool ret) {
        assembly {
            let p := add(v, 32) // start of v
            let e := add(p, mload(v)) // end of v
            let x
            ret := 1 // assume zero
            for {

            } lt(p, e) { // while (p < e)

            } {
                x := mload(p) // remember last
                p := add(p, 32) // step by word
                if x {
                    ret := 0 // x is nonzero => return false
                    break
                }
            }
            // we checked beyond bound and failed
            if and(gt(p, e), iszero(ret)) {
                ret := iszero(shr(shl(3, sub(p, e)), x)) // shift off extra and recheck
            }
        }
    }

    struct Machine {
        bytes buf;
        uint256 pos;
        uint256[] stack;
        uint256 stackSize;
        uint256 stackBits;
        address target;
        bytes32 storageRoot;
        uint256 slot;
        ProofSequence proofs;
    }

    using GatewayVM for Machine;

    function pushBoolean(Machine memory vm, bool x) internal pure {
        vm.pushUint256(x ? 1 : 0);
    }
    function pushUint256(Machine memory vm, uint256 x) internal pure {
        vm.push(x, true);
    }
    function pushBytes(Machine memory vm, bytes memory v) internal pure {
        uint256 x;
        assembly {
            x := v // bytes => ptr
        }
        vm.push(x, false);
    }
    function push(Machine memory vm, uint256 x, bool raw) internal pure {
        if (vm.stackSize == MAX_STACK) revert StackOverflow();
        uint256 i = vm.stackSize++;
        if (vm.isStackRaw(i) != raw) vm.stackBits ^= 1 << i;
        vm.stack[i] = x;
    }
    function isStackRaw(
        Machine memory vm,
        uint256 i
    ) internal pure returns (bool) {
        return (vm.stackBits & (1 << i)) != 0;
    }
    function isStackZeros(
        Machine memory vm,
        uint256 i
    ) internal pure returns (bool) {
        return
            vm.isStackRaw(i)
                ? vm.stackAsUint256(i) == 0
                : isZeros(vm.stackAsBytes(i));
    }
    function stackAsUint256(
        Machine memory vm,
        uint256 i
    ) internal pure returns (uint256 x) {
        x = vm.stack[i];
        if (!vm.isStackRaw(i)) {
            uint256 n;
            assembly {
                n := mload(x) // length
                x := mload(add(x, 32)) // first 32 bytes w/right pad
                if lt(n, 32) {
                    x := shr(shl(3, sub(32, n)), x) // remove right pad
                }
            }
        }
    }
    function stackAsBytes(
        Machine memory vm,
        uint256 i
    ) internal pure returns (bytes memory v) {
        uint256 x = vm.stack[i];
        if (vm.isStackRaw(i)) {
            v = abi.encode(x);
        } else {
            assembly {
                v := x // ptr => bytes
            }
        }
    }

    function popAsUint256(Machine memory vm) internal pure returns (uint256) {
        return vm.stackAsUint256(vm.pop());
    }
    function popAsBytes(
        Machine memory vm
    ) internal pure returns (bytes memory) {
        return vm.stackAsBytes(vm.pop());
    }
    function pop(Machine memory vm) internal pure returns (uint256) {
        return vm.stackSize = vm.checkBack(0);
    }

    function checkBack(
        Machine memory vm,
        uint256 back
    ) internal pure returns (uint256) {
        if (back >= vm.stackSize) revert InvalidStackIndex();
        unchecked {
            return vm.stackSize - 1 - back;
        }
    }
    function checkRead(
        Machine memory vm,
        uint256 n
    ) internal pure returns (uint256 ptr) {
        uint256 pos = vm.pos;
        bytes memory buf = vm.buf;
        uint256 end = pos + n;
        if (end > buf.length) revert InvalidRequest();
        vm.pos = end;
        assembly {
            ptr := add(add(buf, 32), pos) // ptr of start in vm.buf
        }
    }

    function readByte(Machine memory vm) internal pure returns (uint8 i) {
        uint256 src = vm.checkRead(1);
        assembly {
            i := shr(248, mload(src)) // read one byte
        }
    }
    function readUint(
        Machine memory vm,
        uint256 n
    ) internal pure returns (uint256 x) {
        if (n == 0) return 0;
        if (n > 32) revert InvalidRequest();
        uint256 src = vm.checkRead(n);
        assembly {
            x := shr(shl(3, sub(32, n)), mload(src)) // remove right pad
        }
    }
    function readBytes(
        Machine memory vm,
        uint256 n
    ) internal pure returns (bytes memory v) {
        v = Bytes.slice(vm.buf, vm.pos, n); // throws on overflow
        vm.pos += n;
    }
    function readProof(Machine memory vm) internal pure returns (bytes memory) {
        ProofSequence memory p = vm.proofs;
        return p.proofs[uint8(p.order[p.index++])];
    }

    function getStorage(
        Machine memory vm,
        uint256 slot
    ) internal view returns (uint256) {
        bytes memory proof = vm.readProof();
        if (vm.storageRoot == NOT_A_CONTRACT) return 0;
        return
            uint256(
                vm.proofs.hooks.verifyStorageValue(
                    vm.storageRoot,
                    vm.target,
                    slot,
                    proof
                )
            );
    }
    function proveSlots(
        Machine memory vm,
        uint256 count
    ) internal view returns (bytes memory v) {
        v = new bytes(count << 5); // memory for count slots
        for (uint256 i; i < count; ) {
            uint256 value = vm.getStorage(vm.slot + i);
            assembly {
                i := add(i, 1)
                mstore(add(v, shl(5, i)), value) // append(value)
            }
        }
    }
    function proveBytes(
        Machine memory vm
    ) internal view returns (bytes memory v) {
        uint256 first = vm.getStorage(vm.slot);
        if ((first & 1) == 0) {
            // small
            v = new bytes((first & 0xFF) >> 1);
            assembly {
                mstore(add(v, 32), first) // set first 32 bytes
            }
        } else {
            // large
            uint256 size = first >> 1; // number of bytes
            first = (size + 31) >> 5; // number of slots
            v = new bytes(size);
            uint256 slot = uint256(smallKeccak(bytes32(vm.slot))); // array start
            for (uint256 i; i < first; ) {
                uint256 value = vm.getStorage(slot + i);
                assembly {
                    i := add(i, 1)
                    mstore(add(v, shl(5, i)), value) // append(value)
                }
            }
        }
    }
    function proveArray(
        Machine memory vm,
        uint256 step
    ) internal view returns (bytes memory v) {
        uint256 first = vm.getStorage(vm.slot);
        uint256 count;
        if (step < 32) {
            uint256 per = 32 / step;
            count = (first + per - 1) / per;
        } else {
            count = first * ((step + 31) >> 5);
        }
        v = new bytes((1 + count) << 5); // +1 for length
        assembly {
            mstore(add(v, 32), first) // store length
        }
        uint256 slot = uint256(smallKeccak(bytes32(vm.slot))); // array start
        for (uint256 i; i < count; ) {
            uint256 value = vm.getStorage(slot + i);
            assembly {
                i := add(i, 1)
                mstore(add(v, shl(5, add(i, 1))), value) // append(value)
            }
        }
    }

    function createMachine() internal pure returns (Machine memory vm) {
        vm.pos = 0;
        vm.stack = new uint256[](MAX_STACK);
        vm.stackBits = 0;
        vm.stackSize = 0;
        vm.target = address(0);
        vm.storageRoot = NOT_A_CONTRACT;
        vm.slot = 0;
    }

    function evalRequest(
        GatewayRequest memory req,
        ProofSequence memory proofs
    ) external view returns (bytes[] memory outputs, uint8 exitCode) {
        Machine memory vm = createMachine();
        vm.buf = req.ops;
        vm.proofs = proofs;
        outputs = new bytes[](vm.readByte()); // NOTE: implies maximum outputs is 255
        exitCode = vm.evalCommand(outputs);
    }

    function evalCommand(
        Machine memory vm,
        bytes[] memory outputs
    ) internal view returns (uint8 exitCode) {
        while (vm.pos < vm.buf.length) {
            //uint256 g = gasleft();
            uint8 op = vm.readByte();
            if (op <= GatewayOP.PUSH_32) {
                vm.pushUint256(vm.readUint(op));
            } else if (op == GatewayOP.PUSH_BYTES) {
                vm.pushBytes(vm.readBytes(vm.readUint(vm.readByte())));
            } else if (op == GatewayOP.SET_TARGET) {
                vm.target = address(uint160(vm.popAsUint256()));
                vm.storageRoot = vm.proofs.hooks.verifyAccountState(
                    vm.proofs.stateRoot,
                    vm.target,
                    vm.readProof()
                );
                vm.slot = 0;
            } else if (op == GatewayOP.SET_OUTPUT) {
                uint256 i = vm.popAsUint256(); // rhs evaluates BEFORE lhs
                outputs[i] = vm.popAsBytes();
            } else if (op == GatewayOP.ASSERT) {
                uint8 code = vm.readByte();
                if (vm.isStackZeros(vm.pop())) return code;
            } else if (op == GatewayOP.READ_SLOT) {
                vm.pushBytes(vm.proveSlots(1));
            } else if (op == GatewayOP.READ_SLOTS) {
                vm.pushBytes(vm.proveSlots(vm.popAsUint256()));
            } else if (op == GatewayOP.READ_BYTES) {
                vm.pushBytes(vm.proveBytes());
            } else if (op == GatewayOP.READ_HASHED_BYTES) {
                bytes memory v = vm.readProof();
                if (keccak256(v) != bytes32(vm.popAsUint256()))
                    revert InvalidProof();
                vm.pushBytes(v);
            } else if (op == GatewayOP.READ_ARRAY) {
                vm.pushBytes(vm.proveArray(vm.popAsUint256()));
            } else if (op == GatewayOP.SET_SLOT) {
                vm.slot = vm.popAsUint256();
            } else if (op == GatewayOP.ADD_SLOT) {
                vm.slot += vm.popAsUint256();
            } else if (op == GatewayOP.FOLLOW) {
                vm.slot = uint256(
                    keccak256(abi.encodePacked(vm.popAsBytes(), vm.slot))
                );
            } else if (op == GatewayOP.PUSH_STACK) {
                uint256 i = vm.popAsUint256();
                if (i >= vm.stackSize) revert InvalidStackIndex();
                vm.push(vm.stack[i], vm.isStackRaw(i));
            } else if (op == GatewayOP.PUSH_OUTPUT) {
                vm.pushBytes(outputs[vm.popAsUint256()]);
            } else if (op == GatewayOP.GET_SLOT) {
                vm.pushUint256(vm.slot);
            } else if (op == GatewayOP.GET_TARGET) {
                vm.pushBytes(abi.encodePacked(vm.target)); // NOTE: 20 bytes
            } else if (op == GatewayOP.STACK_SIZE) {
                vm.pushUint256(vm.stackSize);
            } else if (op == GatewayOP.IS_CONTRACT) {
                vm.pushBoolean(vm.storageRoot != NOT_A_CONTRACT);
            } else if (op == GatewayOP.DUP) {
                uint256 i = vm.checkBack(vm.popAsUint256());
                vm.push(vm.stack[i], vm.isStackRaw(i));
            } else if (op == GatewayOP.POP) {
                if (vm.stackSize > 0) --vm.stackSize;
            } else if (op == GatewayOP.SWAP) {
                uint256 i = vm.checkBack(vm.popAsUint256());
                uint256 j = vm.checkBack(0);
                (vm.stack[i], vm.stack[j]) = (vm.stack[j], vm.stack[i]);
                if (vm.isStackRaw(i) != vm.isStackRaw(j)) {
                    vm.stackBits ^= (1 << i) | (1 << j);
                }
            } else if (op == GatewayOP.SLICE) {
                uint256 size = vm.popAsUint256();
                uint256 pos = vm.popAsUint256();
                bytes memory v = vm.popAsBytes();
                uint256 end = pos + size;
                if (end <= v.length) {
                    vm.pushBytes(Bytes.slice(v, pos, size));
                } else if (pos >= v.length) {
                    vm.pushBytes(new bytes(size)); // beyond end
                } else {
                    vm.pushBytes(
                        bytes.concat(
                            Bytes.slice(v, pos, v.length - pos), // partial
                            new bytes(end - v.length)
                        )
                    );
                }
            } else if (op == GatewayOP.KECCAK) {
                uint256 i = vm.pop();
                if (vm.isStackRaw(i)) {
                    vm.pushUint256(
                        uint256(smallKeccak(bytes32(vm.stackAsUint256(i))))
                    );
                } else {
                    vm.pushUint256(uint256(keccak256(vm.stackAsBytes(i))));
                }
            } else if (op == GatewayOP.LENGTH) {
                uint256 i = vm.pop();
                vm.pushUint256(
                    vm.isStackRaw(i) ? 32 : vm.stackAsBytes(i).length
                );
            } else if (op == GatewayOP.CONCAT) {
                bytes memory last = vm.popAsBytes();
                vm.pushBytes(bytes.concat(vm.popAsBytes(), last));
            } else if (op == GatewayOP.PLUS) {
                uint256 last = vm.popAsUint256();
                unchecked {
                    vm.pushUint256(vm.popAsUint256() + last);
                }
            } else if (op == GatewayOP.TIMES) {
                uint256 last = vm.popAsUint256();
                unchecked {
                    vm.pushUint256(vm.popAsUint256() * last);
                }
            } else if (op == GatewayOP.DIVIDE) {
                uint256 last = vm.popAsUint256();
                unchecked {
                    vm.pushUint256(vm.popAsUint256() / last); // revert on 0
                }
            } else if (op == GatewayOP.MOD) {
                uint256 last = vm.popAsUint256();
                vm.pushUint256(vm.popAsUint256() % last); // revert on 0
            } else if (op == GatewayOP.POW) {
                uint256 last = vm.popAsUint256();
                unchecked {
                    vm.pushUint256(vm.popAsUint256() ** last);
                }
            } else if (op == GatewayOP.AND) {
                uint256 last = vm.popAsUint256();
                vm.pushUint256(vm.popAsUint256() & last);
            } else if (op == GatewayOP.OR) {
                uint256 last = vm.popAsUint256();
                vm.pushUint256(vm.popAsUint256() | last);
            } else if (op == GatewayOP.XOR) {
                uint256 last = vm.popAsUint256();
                vm.pushUint256(vm.popAsUint256() ^ last);
            } else if (op == GatewayOP.SHIFT_LEFT) {
                vm.pushUint256(vm.popAsUint256() << vm.popAsUint256());
            } else if (op == GatewayOP.SHIFT_RIGHT) {
                vm.pushUint256(vm.popAsUint256() >> vm.popAsUint256());
            } else if (op == GatewayOP.EQ) {
                uint256 last = vm.popAsUint256();
                vm.pushBoolean(vm.popAsUint256() == last);
            } else if (op == GatewayOP.LT) {
                uint256 last = vm.popAsUint256();
                vm.pushBoolean(vm.popAsUint256() < last);
            } else if (op == GatewayOP.GT) {
                uint256 last = vm.popAsUint256();
                vm.pushBoolean(vm.popAsUint256() > last);
            } else if (op == GatewayOP.NOT) {
                vm.pushUint256(~vm.popAsUint256());
            } else if (op == GatewayOP.IS_ZERO) {
                vm.pushBoolean(vm.isStackZeros(vm.pop()));
            } else if (op == GatewayOP.EVAL) {
                bool cond = !vm.isStackZeros(vm.pop());
                bytes memory program = vm.popAsBytes();
                if (cond) {
                    (uint256 pos, bytes memory buf) = (vm.pos, vm.buf); // save program
                    vm.buf = program;
                    vm.pos = 0;
                    exitCode = vm.evalCommand(outputs);
                    if (exitCode != 0) return exitCode;
                    (vm.pos, vm.buf) = (pos, buf); // restore program
                }
            } else if (op == GatewayOP.EVAL_LOOP) {
                uint8 flags = vm.readByte();
                uint256 count = vm.popAsUint256();
                Machine memory vm2;
                vm2.buf = vm.popAsBytes();
                vm2.proofs = vm.proofs;
                vm2.stack = new uint256[](MAX_STACK);
                if (count > vm.stackSize) count = vm.stackSize;
                while (count > 0) {
                    --count;
                    vm2.target = vm.target;
                    vm2.storageRoot = vm.storageRoot;
                    vm2.slot = vm.slot;
                    vm2.pos = 0;
                    vm2.stackSize = 0;
                    uint256 i = vm.pop();
                    vm2.push(vm.stack[i], vm.isStackRaw(i));
                    if (
                        (flags &
                            (
                                vm2.evalCommand(outputs) != 0
                                    ? EvalFlag.STOP_ON_FAILURE
                                    : EvalFlag.STOP_ON_SUCCESS
                            )) != 0
                    ) {
                        if ((flags & EvalFlag.KEEP_ARGS) == 0) {
                            vm.stackSize -= count;
                        }
                        if ((flags & EvalFlag.ACQUIRE_STATE) != 0) {
                            vm.target = vm2.target;
                            vm.storageRoot = vm2.storageRoot;
                            vm.slot = vm2.slot;
                            for (i = 0; i < vm2.stackSize; i++) {
                                vm.push(vm2.stack[i], vm2.isStackRaw(i));
                            }
                            // NOTE: does not acquire exitCode
                        }
                        break;
                    }
                }
            } else if (op == GatewayOP.DEBUG) {
                vm.dump(string(vm.readBytes(vm.readByte())));
            } else {
                revert InvalidRequest();
            }
            //console.log("op=%s gas=%s", op, g - gasleft());
        }
        return 0;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// https://github.com/Consensys/linea-contracts/blob/main/contracts/interfaces/l1/ILineaRollup.sol
// https://github.com/Consensys/linea-contracts/blob/main/contracts/LineaRollup.sol
// https://github.com/Consensys/linea-contracts/blob/main/contracts/ZkEvmV2.sol

interface ILineaRollup {
    function currentL2BlockNumber() external view returns (uint256);
    function stateRootHashes(
        uint256 l2BlockNumber
    ) external view returns (bytes32);
    function shnarfFinalBlockNumbers(
        bytes32 shnarf
    ) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import {GatewayRequest} from './GatewayRequest.sol';

error CommitTooOld(uint256 latest, uint256 got, uint256 window);
error CommitTooNew(uint256 latest, uint256 got);

interface IGatewayVerifier {
    function getLatestContext() external view returns (bytes memory);
    function gatewayURLs() external view returns (string[] memory);

    function getStorageValues(
        bytes memory context,
        GatewayRequest memory req,
        bytes memory proof
    ) external view returns (bytes[] memory values, uint8 exitCode);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

bytes32 constant NOT_A_CONTRACT = 0x0000000000000000000000000000000000000000000000000000000000000000;
bytes32 constant NULL_CODE_HASH = keccak256('');

error InvalidProof();

interface IVerifierHooks {
    function verifyAccountState(
        bytes32 stateRoot,
        address target,
        bytes memory proof
    ) external view returns (bytes32 storageRoot);
    function verifyStorageValue(
        bytes32 storageRoot,
        address target,
        uint256 slot,
        bytes memory proof
    ) external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

struct GatewayRequest {
    bytes ops;
}

library EvalFlag {
    uint8 constant STOP_ON_SUCCESS = 1 << 0;
    uint8 constant STOP_ON_FAILURE = 1 << 1;
    uint8 constant ACQUIRE_STATE = 1 << 2;
    uint8 constant KEEP_ARGS = 1 << 3;
}

library GatewayOP {
    uint8 constant PUSH_0 = 0;
    uint8 constant PUSH_1 = 1;
    uint8 constant PUSH_2 = 2;
    uint8 constant PUSH_3 = 3;
    uint8 constant PUSH_4 = 4;
    uint8 constant PUSH_5 = 5;
    uint8 constant PUSH_6 = 6;
    uint8 constant PUSH_7 = 7;
    uint8 constant PUSH_8 = 8;
    uint8 constant PUSH_9 = 9;
    uint8 constant PUSH_10 = 10;
    uint8 constant PUSH_11 = 11;
    uint8 constant PUSH_12 = 12;
    uint8 constant PUSH_13 = 13;
    uint8 constant PUSH_14 = 14;
    uint8 constant PUSH_15 = 15;
    uint8 constant PUSH_16 = 16;
    uint8 constant PUSH_17 = 17;
    uint8 constant PUSH_18 = 18;
    uint8 constant PUSH_19 = 19;
    uint8 constant PUSH_20 = 20;
    uint8 constant PUSH_21 = 21;
    uint8 constant PUSH_22 = 22;
    uint8 constant PUSH_23 = 23;
    uint8 constant PUSH_24 = 24;
    uint8 constant PUSH_25 = 25;
    uint8 constant PUSH_26 = 26;
    uint8 constant PUSH_27 = 27;
    uint8 constant PUSH_28 = 28;
    uint8 constant PUSH_29 = 29;
    uint8 constant PUSH_30 = 30;
    uint8 constant PUSH_31 = 31;
    uint8 constant PUSH_32 = 32;

    uint8 constant GET_SLOT = 33;
    uint8 constant GET_TARGET = 34;
    uint8 constant STACK_SIZE = 35;
	uint8 constant IS_CONTRACT = 36;

    uint8 constant PUSH_BYTES = 40;
    uint8 constant PUSH_STACK = 41;
    uint8 constant PUSH_OUTPUT = 42;

    uint8 constant SET_TARGET = 50;
    uint8 constant SET_OUTPUT = 51;
    uint8 constant EVAL_LOOP = 52;
    uint8 constant EVAL = 53;
    uint8 constant ASSERT = 54;

    uint8 constant READ_SLOT = 60;
    uint8 constant READ_BYTES = 61;
    uint8 constant READ_ARRAY = 62;
    uint8 constant READ_HASHED_BYTES = 63;
    uint8 constant READ_SLOTS = 64;

    uint8 constant SET_SLOT = 70;
    uint8 constant ADD_SLOT = 71;
    uint8 constant FOLLOW = 72;

    uint8 constant DUP = 80;
    uint8 constant POP = 81;
    uint8 constant SWAP = 82;

    uint8 constant KECCAK = 90;
    uint8 constant CONCAT = 91;
    uint8 constant SLICE = 92;
    uint8 constant LENGTH = 93;

    uint8 constant PLUS = 100;
    uint8 constant TIMES = 101;
    uint8 constant DIVIDE = 102;
    uint8 constant MOD = 103;
	uint8 constant POW = 104;

    uint8 constant AND = 110;
    uint8 constant OR = 111;
    uint8 constant XOR = 112;
    uint8 constant SHIFT_LEFT = 113;
    uint8 constant SHIFT_RIGHT = 114;
    uint8 constant NOT = 115;

    uint8 constant IS_ZERO = 120;
    uint8 constant EQ = 121;
    uint8 constant LT = 122;
    uint8 constant GT = 123;

    uint8 constant DEBUG = 255;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @title Bytes
/// @notice Bytes is a library for manipulating byte arrays.
library Bytes {
    /// @custom:attribution https://github.com/GNSPS/solidity-bytes-utils
    /// @notice Slices a byte array with a given starting index and length. Returns a new byte array
    ///         as opposed to a pointer to the original array. Will throw if trying to slice more
    ///         bytes than exist in the array.
    /// @param _bytes Byte array to slice.
    /// @param _start Starting index of the slice.
    /// @param _length Length of the slice.
    /// @return Slice of the input byte array.
    function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory) {
        unchecked {
            require(_length + 31 >= _length, "slice_overflow");
            require(_start + _length >= _start, "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;
    }

    /// @notice Slices a byte array with a given starting index up to the end of the original byte
    ///         array. Returns a new array rathern than a pointer to the original.
    /// @param _bytes Byte array to slice.
    /// @param _start Starting index of the slice.
    /// @return Slice of the input byte array.
    function slice(bytes memory _bytes, uint256 _start) internal pure returns (bytes memory) {
        if (_start >= _bytes.length) {
            return bytes("");
        }
        return slice(_bytes, _start, _bytes.length - _start);
    }

    /// @notice Converts a byte array into a nibble array by splitting each byte into two nibbles.
    ///         Resulting nibble array will be exactly twice as long as the input byte array.
    /// @param _bytes Input byte array to convert.
    /// @return Resulting nibble array.
    function toNibbles(bytes memory _bytes) internal pure returns (bytes memory) {
        bytes memory _nibbles;
        assembly {
            // Grab a free memory offset for the new array
            _nibbles := mload(0x40)

            // Load the length of the passed bytes array from memory
            let bytesLength := mload(_bytes)

            // Calculate the length of the new nibble array
            // This is the length of the input array times 2
            let nibblesLength := shl(0x01, bytesLength)

            // Update the free memory pointer to allocate memory for the new array.
            // To do this, we add the length of the new array + 32 bytes for the array length
            // rounded up to the nearest 32 byte boundary to the current free memory pointer.
            mstore(0x40, add(_nibbles, and(not(0x1F), add(nibblesLength, 0x3F))))

            // Store the length of the new array in memory
            mstore(_nibbles, nibblesLength)

            // Store the memory offset of the _bytes array's contents on the stack
            let bytesStart := add(_bytes, 0x20)

            // Store the memory offset of the nibbles array's contents on the stack
            let nibblesStart := add(_nibbles, 0x20)

            // Loop through each byte in the input array
            for { let i := 0x00 } lt(i, bytesLength) { i := add(i, 0x01) } {
                // Get the starting offset of the next 2 bytes in the nibbles array
                let offset := add(nibblesStart, shl(0x01, i))
                // Load the byte at the current index within the `_bytes` array
                let b := byte(0x00, mload(add(bytesStart, i)))

                // Pull out the first nibble and store it in the new array
                mstore8(offset, shr(0x04, b))
                // Pull out the second nibble and store it in the new array
                mstore8(add(offset, 0x01), and(b, 0x0F))
            }
        }
        return _nibbles;
    }

    /// @notice Compares two byte arrays by comparing their keccak256 hashes.
    /// @param _bytes First byte array to compare.
    /// @param _other Second byte array to compare.
    /// @return True if the two byte arrays are equal, false otherwise.
    function equal(bytes memory _bytes, bytes memory _other) internal pure returns (bool) {
        return keccak256(_bytes) == keccak256(_other);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

library console {
    address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

    function _castLogPayloadViewToPure(
        function(bytes memory) internal view fnIn
    ) internal pure returns (function(bytes memory) internal pure fnOut) {
        assembly {
            fnOut := fnIn
        }
    }

    function _sendLogPayload(bytes memory payload) internal pure {
        _castLogPayloadViewToPure(_sendLogPayloadView)(payload);
    }

    function _sendLogPayloadView(bytes memory payload) private view {
        uint256 payloadLength = payload.length;
        address consoleAddress = CONSOLE_ADDRESS;
        /// @solidity memory-safe-assembly
        assembly {
            let payloadStart := add(payload, 32)
            let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
        }
    }

    function log() internal pure {
        _sendLogPayload(abi.encodeWithSignature("log()"));
    }

    function logInt(int p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(int)", p0));
    }

    function logUint(uint p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
    }

    function logString(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function logBool(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function logAddress(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function logBytes(bytes memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
    }

    function logBytes1(bytes1 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
    }

    function logBytes2(bytes2 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
    }

    function logBytes3(bytes3 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
    }

    function logBytes4(bytes4 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
    }

    function logBytes5(bytes5 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
    }

    function logBytes6(bytes6 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
    }

    function logBytes7(bytes7 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
    }

    function logBytes8(bytes8 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
    }

    function logBytes9(bytes9 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
    }

    function logBytes10(bytes10 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
    }

    function logBytes11(bytes11 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
    }

    function logBytes12(bytes12 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
    }

    function logBytes13(bytes13 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
    }

    function logBytes14(bytes14 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
    }

    function logBytes15(bytes15 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
    }

    function logBytes16(bytes16 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
    }

    function logBytes17(bytes17 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
    }

    function logBytes18(bytes18 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
    }

    function logBytes19(bytes19 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
    }

    function logBytes20(bytes20 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
    }

    function logBytes21(bytes21 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
    }

    function logBytes22(bytes22 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
    }

    function logBytes23(bytes23 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
    }

    function logBytes24(bytes24 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
    }

    function logBytes25(bytes25 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
    }

    function logBytes26(bytes26 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
    }

    function logBytes27(bytes27 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
    }

    function logBytes28(bytes28 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
    }

    function logBytes29(bytes29 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
    }

    function logBytes30(bytes30 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
    }

    function logBytes31(bytes31 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
    }

    function logBytes32(bytes32 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
    }

    function log(uint p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
    }

    function log(int p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(int)", p0));
    }

    function log(string memory p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string)", p0));
    }

    function log(bool p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
    }

    function log(address p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address)", p0));
    }

    function log(uint p0, uint p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
    }

    function log(uint p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
    }

    function log(uint p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
    }

    function log(uint p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
    }

    function log(string memory p0, uint p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
    }

    function log(string memory p0, int p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,int)", p0, p1));
    }

    function log(string memory p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
    }

    function log(string memory p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
    }

    function log(string memory p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
    }

    function log(bool p0, uint p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
    }

    function log(bool p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
    }

    function log(bool p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
    }

    function log(bool p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
    }

    function log(address p0, uint p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
    }

    function log(address p0, string memory p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
    }

    function log(address p0, bool p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
    }

    function log(address p0, address p1) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
    }

    function log(uint p0, uint p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
    }

    function log(uint p0, uint p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
    }

    function log(uint p0, uint p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
    }

    function log(uint p0, uint p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
    }

    function log(uint p0, string memory p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
    }

    function log(uint p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
    }

    function log(uint p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
    }

    function log(uint p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
    }

    function log(uint p0, bool p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
    }

    function log(uint p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
    }

    function log(uint p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
    }

    function log(uint p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
    }

    function log(uint p0, address p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
    }

    function log(uint p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
    }

    function log(uint p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
    }

    function log(uint p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
    }

    function log(string memory p0, uint p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
    }

    function log(string memory p0, uint p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
    }

    function log(string memory p0, uint p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
    }

    function log(string memory p0, uint p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
    }

    function log(string memory p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
    }

    function log(string memory p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
    }

    function log(string memory p0, address p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
    }

    function log(string memory p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
    }

    function log(string memory p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
    }

    function log(string memory p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
    }

    function log(bool p0, uint p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
    }

    function log(bool p0, uint p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
    }

    function log(bool p0, uint p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
    }

    function log(bool p0, uint p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
    }

    function log(bool p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
    }

    function log(bool p0, bool p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
    }

    function log(bool p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
    }

    function log(bool p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
    }

    function log(bool p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
    }

    function log(bool p0, address p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
    }

    function log(bool p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
    }

    function log(bool p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
    }

    function log(bool p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
    }

    function log(address p0, uint p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
    }

    function log(address p0, uint p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
    }

    function log(address p0, uint p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
    }

    function log(address p0, uint p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
    }

    function log(address p0, string memory p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
    }

    function log(address p0, string memory p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
    }

    function log(address p0, string memory p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
    }

    function log(address p0, string memory p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
    }

    function log(address p0, bool p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
    }

    function log(address p0, bool p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
    }

    function log(address p0, bool p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
    }

    function log(address p0, bool p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
    }

    function log(address p0, address p1, uint p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
    }

    function log(address p0, address p1, string memory p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
    }

    function log(address p0, address p1, bool p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
    }

    function log(address p0, address p1, address p2) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
    }

    function log(uint p0, uint p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, uint p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
    }

    function log(uint p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, uint p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
    }

    function log(string memory p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, uint p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
    }

    function log(bool p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, uint p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, string memory p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, bool p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, uint p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, string memory p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, bool p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, uint p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, string memory p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, bool p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
    }

    function log(address p0, address p1, address p2, address p3) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

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

{
  "remappings": [
    "@unruggable/=lib/unruggable-gateways/",
    "@eth-optimism/=lib/unruggable-gateways/lib/optimism/packages/",
    "@openzeppelin/contracts/=lib/unruggable-gateways/lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/unruggable-gateways/lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/unruggable-gateways/lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/unruggable-gateways/lib/forge-std/src/",
    "openzeppelin-contracts/=lib/unruggable-gateways/lib/openzeppelin-contracts/",
    "optimism/=lib/unruggable-gateways/lib/optimism/packages/contracts-bedrock/src/",
    "unruggable-gateways/=lib/unruggable-gateways/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {
    "lib/unruggable-gateways/contracts/GatewayVM.sol": {
      "GatewayVM": "0xEe6B722f889D8CFC6e23beD17e134b4BCC98119c"
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string[]","name":"urls","type":"string[]"},{"internalType":"uint256","name":"window","type":"uint256"},{"internalType":"contract IVerifierHooks","name":"hooks","type":"address"},{"internalType":"contract ILineaRollup","name":"rollup","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"latest","type":"uint256"},{"internalType":"uint256","name":"got","type":"uint256"}],"name":"CommitTooNew","type":"error"},{"inputs":[{"internalType":"uint256","name":"latest","type":"uint256"},{"internalType":"uint256","name":"got","type":"uint256"},{"internalType":"uint256","name":"window","type":"uint256"}],"name":"CommitTooOld","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[],"name":"GatewayURLsChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"gatewayURLs","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getHooks","outputs":[{"internalType":"contract IVerifierHooks","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestContext","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"context","type":"bytes"},{"components":[{"internalType":"bytes","name":"ops","type":"bytes"}],"internalType":"struct GatewayRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"proof","type":"bytes"}],"name":"getStorageValues","outputs":[{"internalType":"bytes[]","name":"","type":"bytes[]"},{"internalType":"uint8","name":"exitCode","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWindow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string[]","name":"urls","type":"string[]"}],"name":"setGatewayURLs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000ea60000000000000000000000000bf74ee1ad8057985e8f8397b0bba4c19346f4e59000000000000000000000000d19d4b5d358258f05d7b411e21a1460d11b0876f00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002468747470733a2f2f6c696e65612e676174657761792e756e7275676761626c652e636f6d00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : urls (string[]): https://linea.gateway.unruggable.com
Arg [1] : window (uint256): 60000
Arg [2] : hooks (address): 0xBF74eE1ad8057985E8F8397B0bBa4C19346F4E59
Arg [3] : rollup (address): 0xd19d4B5d358258f05D7B411E21A1460D11B0876F

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 000000000000000000000000000000000000000000000000000000000000ea60
Arg [2] : 000000000000000000000000bf74ee1ad8057985e8f8397b0bba4c19346f4e59
Arg [3] : 000000000000000000000000d19d4b5d358258f05d7b411e21a1460d11b0876f
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000024
Arg [7] : 68747470733a2f2f6c696e65612e676174657761792e756e7275676761626c65
Arg [8] : 2e636f6d00000000000000000000000000000000000000000000000000000000