opcodes.sol

pragma solcore;

// Generated by scripts/gen-std-opcodes.py. Run the script to regenerate.

export {
    stop,
    add,
    mul,
    sub,
    div,
    sdiv,
    mod,
    smod,
    addmod,
    mulmod,
    exp,
    signextend,
    lt,
    gt,
    slt,
    sgt,
    eq,
    iszero,
    and,
    or,
    xor,
    not,
    byte,
    shl,
    shr,
    sar,
    clz,
    keccak256,
    address,
    balance,
    origin,
    caller,
    callvalue,
    calldataload,
    calldatasize,
    calldatacopy,
    codesize,
    codecopy,
    gasprice,
    extcodesize,
    extcodecopy,
    returndatasize,
    returndatacopy,
    extcodehash,
    blockhash,
    coinbase,
    timestamp,
    number,
    prevrandao,
    gaslimit,
    chainid,
    selfbalance,
    basefee,
    blobhash,
    blobbasefee,
    pop,
    mload,
    mstore,
    mstore8,
    sload,
    sstore,
    msize,
    gas,
    tload,
    tstore,
    mcopy,
    log0,
    log1,
    log2,
    log3,
    log4,
    create,
    call,
    callcode,
    return_,
    delegatecall,
    create2,
    staticcall,
    revert_,
    invalid,
    selfdestruct
};

function stop() returns (()) {
    assembly {
        stop()
    }
}

function add(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := add(a, b)
    }
    return res;
}

function mul(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := mul(a, b)
    }
    return res;
}

function sub(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := sub(a, b)
    }
    return res;
}

function div(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := div(a, b)
    }
    return res;
}

function sdiv(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := sdiv(a, b)
    }
    return res;
}

function mod(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := mod(a, b)
    }
    return res;
}

function smod(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := smod(a, b)
    }
    return res;
}

function addmod(a: word, b: word, c: word) returns (word) {
    let res;
    assembly {
        res := addmod(a, b, c)
    }
    return res;
}

function mulmod(a: word, b: word, c: word) returns (word) {
    let res;
    assembly {
        res := mulmod(a, b, c)
    }
    return res;
}

function exp(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := exp(a, b)
    }
    return res;
}

function signextend(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := signextend(a, b)
    }
    return res;
}

function lt(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := lt(a, b)
    }
    return res;
}

function gt(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := gt(a, b)
    }
    return res;
}

function slt(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := slt(a, b)
    }
    return res;
}

function sgt(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := sgt(a, b)
    }
    return res;
}

function eq(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := eq(a, b)
    }
    return res;
}

function iszero(a: word) returns (word) {
    let res;
    assembly {
        res := iszero(a)
    }
    return res;
}

function and(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := and(a, b)
    }
    return res;
}

function or(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := or(a, b)
    }
    return res;
}

function xor(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := xor(a, b)
    }
    return res;
}

function not(a: word) returns (word) {
    let res;
    assembly {
        res := not(a)
    }
    return res;
}

function byte(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := byte(a, b)
    }
    return res;
}

function shl(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := shl(a, b)
    }
    return res;
}

function shr(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := shr(a, b)
    }
    return res;
}

function sar(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := sar(a, b)
    }
    return res;
}

function clz(a: word) returns (word) {
    let res;
    assembly {
        res := clz(a)
    }
    return res;
}

function keccak256(a: word, b: word) returns (word) {
    let res;
    assembly {
        res := keccak256(a, b)
    }
    return res;
}

function address() returns (word) {
    let res;
    assembly {
        res := address()
    }
    return res;
}

function balance(a: word) returns (word) {
    let res;
    assembly {
        res := balance(a)
    }
    return res;
}

function origin() returns (word) {
    let res;
    assembly {
        res := origin()
    }
    return res;
}

function caller() returns (word) {
    let res;
    assembly {
        res := caller()
    }
    return res;
}

function callvalue() returns (word) {
    let res;
    assembly {
        res := callvalue()
    }
    return res;
}

function calldataload(a: word) returns (word) {
    let res;
    assembly {
        res := calldataload(a)
    }
    return res;
}

function calldatasize() returns (word) {
    let res;
    assembly {
        res := calldatasize()
    }
    return res;
}

function calldatacopy(a: word, b: word, c: word) returns (()) {
    assembly {
        calldatacopy(a, b, c)
    }
}

function codesize() returns (word) {
    let res;
    assembly {
        res := codesize()
    }
    return res;
}

function codecopy(a: word, b: word, c: word) returns (()) {
    assembly {
        codecopy(a, b, c)
    }
}

function gasprice() returns (word) {
    let res;
    assembly {
        res := gasprice()
    }
    return res;
}

function extcodesize(a: word) returns (word) {
    let res;
    assembly {
        res := extcodesize(a)
    }
    return res;
}

function extcodecopy(a: word, b: word, c: word, d: word) returns (()) {
    assembly {
        extcodecopy(a, b, c, d)
    }
}

function returndatasize() returns (word) {
    let res;
    assembly {
        res := returndatasize()
    }
    return res;
}

function returndatacopy(a: word, b: word, c: word) returns (()) {
    assembly {
        returndatacopy(a, b, c)
    }
}

function extcodehash(a: word) returns (word) {
    let res;
    assembly {
        res := extcodehash(a)
    }
    return res;
}

function blockhash(a: word) returns (word) {
    let res;
    assembly {
        res := blockhash(a)
    }
    return res;
}

function coinbase() returns (word) {
    let res;
    assembly {
        res := coinbase()
    }
    return res;
}

function timestamp() returns (word) {
    let res;
    assembly {
        res := timestamp()
    }
    return res;
}

function number() returns (word) {
    let res;
    assembly {
        res := number()
    }
    return res;
}

function prevrandao() returns (word) {
    let res;
    assembly {
        res := prevrandao()
    }
    return res;
}

function gaslimit() returns (word) {
    let res;
    assembly {
        res := gaslimit()
    }
    return res;
}

function chainid() returns (word) {
    let res;
    assembly {
        res := chainid()
    }
    return res;
}

function selfbalance() returns (word) {
    let res;
    assembly {
        res := selfbalance()
    }
    return res;
}

function basefee() returns (word) {
    let res;
    assembly {
        res := basefee()
    }
    return res;
}

function blobhash(a: word) returns (word) {
    let res;
    assembly {
        res := blobhash(a)
    }
    return res;
}

function blobbasefee() returns (word) {
    let res;
    assembly {
        res := blobbasefee()
    }
    return res;
}

function pop(a: word) returns (()) {
    assembly {
        pop(a)
    }
}

function mload(a: word) returns (word) {
    let res;
    assembly {
        res := mload(a)
    }
    return res;
}

function mstore(a: word, b: word) returns (()) {
    assembly {
        mstore(a, b)
    }
}

function mstore8(a: word, b: word) returns (()) {
    assembly {
        mstore8(a, b)
    }
}

function sload(a: word) returns (word) {
    let res;
    assembly {
        res := sload(a)
    }
    return res;
}

function sstore(a: word, b: word) returns (()) {
    assembly {
        sstore(a, b)
    }
}

function msize() returns (word) {
    let res;
    assembly {
        res := msize()
    }
    return res;
}

function gas() returns (word) {
    let res;
    assembly {
        res := gas()
    }
    return res;
}

function tload(a: word) returns (word) {
    let res;
    assembly {
        res := tload(a)
    }
    return res;
}

function tstore(a: word, b: word) returns (()) {
    assembly {
        tstore(a, b)
    }
}

function mcopy(a: word, b: word, c: word) returns (()) {
    assembly {
        mcopy(a, b, c)
    }
}

function log0(a: word, b: word) returns (()) {
    assembly {
        log0(a, b)
    }
}

function log1(a: word, b: word, c: word) returns (()) {
    assembly {
        log1(a, b, c)
    }
}

function log2(a: word, b: word, c: word, d: word) returns (()) {
    assembly {
        log2(a, b, c, d)
    }
}

function log3(a: word, b: word, c: word, d: word, e: word) returns (()) {
    assembly {
        log3(a, b, c, d, e)
    }
}

function log4(a: word, b: word, c: word, d: word, e: word, f: word) returns (()) {
    assembly {
        log4(a, b, c, d, e, f)
    }
}

function create(a: word, b: word, c: word) returns (word) {
    let res;
    assembly {
        res := create(a, b, c)
    }
    return res;
}

function call(a: word, b: word, c: word, d: word, e: word, f: word, g: word) returns (word) {
    let res;
    assembly {
        res := call(a, b, c, d, e, f, g)
    }
    return res;
}

function callcode(a: word, b: word, c: word, d: word, e: word, f: word, g: word) returns (word) {
    let res;
    assembly {
        res := callcode(a, b, c, d, e, f, g)
    }
    return res;
}

function return_(a: word, b: word) returns (()) {
    assembly {
        return (a, b)
    }
}

function delegatecall(a: word, b: word, c: word, d: word, e: word, f: word) returns (word) {
    let res;
    assembly {
        res := delegatecall(a, b, c, d, e, f)
    }
    return res;
}

function create2(a: word, b: word, c: word, d: word) returns (word) {
    let res;
    assembly {
        res := create2(a, b, c, d)
    }
    return res;
}

function staticcall(a: word, b: word, c: word, d: word, e: word, f: word) returns (word) {
    let res;
    assembly {
        res := staticcall(a, b, c, d, e, f)
    }
    return res;
}

function revert_(a: word, b: word) returns (()) {
    assembly {
        revert(a, b)
    }
}

function invalid() returns (()) {
    assembly {
        invalid()
    }
}

function selfdestruct(a: word) returns (()) {
    assembly {
        selfdestruct(a)
    }
}