// AUTOGENERATED, DO NOT EDIT, generated by ../generator/gen-types.ts
import * as $ from "@/asm/runtime/util";
import * as c from "@/asm/runtime/constructors";
export const PUSHNAN: $.Type<c.PUSHNAN> = {
    load: (s) => {
        s.skip(16);
        return c.PUSHNAN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(33791, 16, val);
    },
};
export const ADD: $.Type<c.ADD> = {
    load: (s) => {
        s.skip(8);
        return c.ADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(160, 8, val);
    },
};
export const SUB: $.Type<c.SUB> = {
    load: (s) => {
        s.skip(8);
        return c.SUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(161, 8, val);
    },
};
export const SUBR: $.Type<c.SUBR> = {
    load: (s) => {
        s.skip(8);
        return c.SUBR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(162, 8, val);
    },
};
export const NEGATE: $.Type<c.NEGATE> = {
    load: (s) => {
        s.skip(8);
        return c.NEGATE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(163, 8, val);
    },
};
export const INC: $.Type<c.INC> = {
    load: (s) => {
        s.skip(8);
        return c.INC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(164, 8, val);
    },
};
export const DEC: $.Type<c.DEC> = {
    load: (s) => {
        s.skip(8);
        return c.DEC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(165, 8, val);
    },
};
export const MUL: $.Type<c.MUL> = {
    load: (s) => {
        s.skip(8);
        return c.MUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(168, 8, val);
    },
};
export const POW2: $.Type<c.POW2> = {
    load: (s) => {
        s.skip(8);
        return c.POW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(174, 8, val);
    },
};
export const AND: $.Type<c.AND> = {
    load: (s) => {
        s.skip(8);
        return c.AND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(176, 8, val);
    },
};
export const OR: $.Type<c.OR> = {
    load: (s) => {
        s.skip(8);
        return c.OR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(177, 8, val);
    },
};
export const XOR: $.Type<c.XOR> = {
    load: (s) => {
        s.skip(8);
        return c.XOR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(178, 8, val);
    },
};
export const NOT: $.Type<c.NOT> = {
    load: (s) => {
        s.skip(8);
        return c.NOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(179, 8, val);
    },
};
export const FITSX: $.Type<c.FITSX> = {
    load: (s) => {
        s.skip(16);
        return c.FITSX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46592, 16, val);
    },
};
export const UFITSX: $.Type<c.UFITSX> = {
    load: (s) => {
        s.skip(16);
        return c.UFITSX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46593, 16, val);
    },
};
export const BITSIZE: $.Type<c.BITSIZE> = {
    load: (s) => {
        s.skip(16);
        return c.BITSIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46594, 16, val);
    },
};
export const UBITSIZE: $.Type<c.UBITSIZE> = {
    load: (s) => {
        s.skip(16);
        return c.UBITSIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46595, 16, val);
    },
};
export const MIN: $.Type<c.MIN> = {
    load: (s) => {
        s.skip(16);
        return c.MIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46600, 16, val);
    },
};
export const MAX: $.Type<c.MAX> = {
    load: (s) => {
        s.skip(16);
        return c.MAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46601, 16, val);
    },
};
export const MINMAX: $.Type<c.MINMAX> = {
    load: (s) => {
        s.skip(16);
        return c.MINMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46602, 16, val);
    },
};
export const ABS: $.Type<c.ABS> = {
    load: (s) => {
        s.skip(16);
        return c.ABS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(46603, 16, val);
    },
};
export const QADD: $.Type<c.QADD> = {
    load: (s) => {
        s.skip(16);
        return c.QADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47008, 16, val);
    },
};
export const QSUB: $.Type<c.QSUB> = {
    load: (s) => {
        s.skip(16);
        return c.QSUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47009, 16, val);
    },
};
export const QSUBR: $.Type<c.QSUBR> = {
    load: (s) => {
        s.skip(16);
        return c.QSUBR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47010, 16, val);
    },
};
export const QNEGATE: $.Type<c.QNEGATE> = {
    load: (s) => {
        s.skip(16);
        return c.QNEGATE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47011, 16, val);
    },
};
export const QINC: $.Type<c.QINC> = {
    load: (s) => {
        s.skip(16);
        return c.QINC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47012, 16, val);
    },
};
export const QDEC: $.Type<c.QDEC> = {
    load: (s) => {
        s.skip(16);
        return c.QDEC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47013, 16, val);
    },
};
export const QMUL: $.Type<c.QMUL> = {
    load: (s) => {
        s.skip(16);
        return c.QMUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47016, 16, val);
    },
};
export const QPOW2: $.Type<c.QPOW2> = {
    load: (s) => {
        s.skip(16);
        return c.QPOW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47022, 16, val);
    },
};
export const QAND: $.Type<c.QAND> = {
    load: (s) => {
        s.skip(16);
        return c.QAND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47024, 16, val);
    },
};
export const QOR: $.Type<c.QOR> = {
    load: (s) => {
        s.skip(16);
        return c.QOR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47025, 16, val);
    },
};
export const QXOR: $.Type<c.QXOR> = {
    load: (s) => {
        s.skip(16);
        return c.QXOR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47026, 16, val);
    },
};
export const QNOT: $.Type<c.QNOT> = {
    load: (s) => {
        s.skip(16);
        return c.QNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47027, 16, val);
    },
};
export const QFITSX: $.Type<c.QFITSX> = {
    load: (s) => {
        s.skip(24);
        return c.QFITSX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039680, 24, val);
    },
};
export const QUFITSX: $.Type<c.QUFITSX> = {
    load: (s) => {
        s.skip(24);
        return c.QUFITSX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039681, 24, val);
    },
};
export const QBITSIZE: $.Type<c.QBITSIZE> = {
    load: (s) => {
        s.skip(24);
        return c.QBITSIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039682, 24, val);
    },
};
export const QUBITSIZE: $.Type<c.QUBITSIZE> = {
    load: (s) => {
        s.skip(24);
        return c.QUBITSIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039683, 24, val);
    },
};
export const QMIN: $.Type<c.QMIN> = {
    load: (s) => {
        s.skip(24);
        return c.QMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039688, 24, val);
    },
};
export const QMAX: $.Type<c.QMAX> = {
    load: (s) => {
        s.skip(24);
        return c.QMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039689, 24, val);
    },
};
export const QMINMAX: $.Type<c.QMINMAX> = {
    load: (s) => {
        s.skip(24);
        return c.QMINMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039690, 24, val);
    },
};
export const QABS: $.Type<c.QABS> = {
    load: (s) => {
        s.skip(24);
        return c.QABS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12039691, 24, val);
    },
};
export const SGN: $.Type<c.SGN> = {
    load: (s) => {
        s.skip(8);
        return c.SGN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(184, 8, val);
    },
};
export const LESS: $.Type<c.LESS> = {
    load: (s) => {
        s.skip(8);
        return c.LESS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(185, 8, val);
    },
};
export const EQUAL: $.Type<c.EQUAL> = {
    load: (s) => {
        s.skip(8);
        return c.EQUAL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(186, 8, val);
    },
};
export const LEQ: $.Type<c.LEQ> = {
    load: (s) => {
        s.skip(8);
        return c.LEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(187, 8, val);
    },
};
export const GREATER: $.Type<c.GREATER> = {
    load: (s) => {
        s.skip(8);
        return c.GREATER();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(188, 8, val);
    },
};
export const NEQ: $.Type<c.NEQ> = {
    load: (s) => {
        s.skip(8);
        return c.NEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(189, 8, val);
    },
};
export const GEQ: $.Type<c.GEQ> = {
    load: (s) => {
        s.skip(8);
        return c.GEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(190, 8, val);
    },
};
export const CMP: $.Type<c.CMP> = {
    load: (s) => {
        s.skip(8);
        return c.CMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(191, 8, val);
    },
};
export const ISNAN: $.Type<c.ISNAN> = {
    load: (s) => {
        s.skip(8);
        return c.ISNAN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(196, 8, val);
    },
};
export const CHKNAN: $.Type<c.CHKNAN> = {
    load: (s) => {
        s.skip(8);
        return c.CHKNAN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(197, 8, val);
    },
};
export const QSGN: $.Type<c.QSGN> = {
    load: (s) => {
        s.skip(16);
        return c.QSGN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47032, 16, val);
    },
};
export const QLESS: $.Type<c.QLESS> = {
    load: (s) => {
        s.skip(16);
        return c.QLESS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47033, 16, val);
    },
};
export const QEQUAL: $.Type<c.QEQUAL> = {
    load: (s) => {
        s.skip(16);
        return c.QEQUAL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47034, 16, val);
    },
};
export const QLEQ: $.Type<c.QLEQ> = {
    load: (s) => {
        s.skip(16);
        return c.QLEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47035, 16, val);
    },
};
export const QGREATER: $.Type<c.QGREATER> = {
    load: (s) => {
        s.skip(16);
        return c.QGREATER();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47036, 16, val);
    },
};
export const QNEQ: $.Type<c.QNEQ> = {
    load: (s) => {
        s.skip(16);
        return c.QNEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47037, 16, val);
    },
};
export const QGEQ: $.Type<c.QGEQ> = {
    load: (s) => {
        s.skip(16);
        return c.QGEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47038, 16, val);
    },
};
export const QCMP: $.Type<c.QCMP> = {
    load: (s) => {
        s.skip(16);
        return c.QCMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47039, 16, val);
    },
};
export const SEMPTY: $.Type<c.SEMPTY> = {
    load: (s) => {
        s.skip(16);
        return c.SEMPTY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50944, 16, val);
    },
};
export const SDEMPTY: $.Type<c.SDEMPTY> = {
    load: (s) => {
        s.skip(16);
        return c.SDEMPTY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50945, 16, val);
    },
};
export const SREMPTY: $.Type<c.SREMPTY> = {
    load: (s) => {
        s.skip(16);
        return c.SREMPTY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50946, 16, val);
    },
};
export const SDFIRST: $.Type<c.SDFIRST> = {
    load: (s) => {
        s.skip(16);
        return c.SDFIRST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50947, 16, val);
    },
};
export const SDLEXCMP: $.Type<c.SDLEXCMP> = {
    load: (s) => {
        s.skip(16);
        return c.SDLEXCMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50948, 16, val);
    },
};
export const SDEQ: $.Type<c.SDEQ> = {
    load: (s) => {
        s.skip(16);
        return c.SDEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50949, 16, val);
    },
};
export const SDPFX: $.Type<c.SDPFX> = {
    load: (s) => {
        s.skip(16);
        return c.SDPFX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50952, 16, val);
    },
};
export const SDPFXREV: $.Type<c.SDPFXREV> = {
    load: (s) => {
        s.skip(16);
        return c.SDPFXREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50953, 16, val);
    },
};
export const SDPPFX: $.Type<c.SDPPFX> = {
    load: (s) => {
        s.skip(16);
        return c.SDPPFX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50954, 16, val);
    },
};
export const SDPPFXREV: $.Type<c.SDPPFXREV> = {
    load: (s) => {
        s.skip(16);
        return c.SDPPFXREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50955, 16, val);
    },
};
export const SDSFX: $.Type<c.SDSFX> = {
    load: (s) => {
        s.skip(16);
        return c.SDSFX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50956, 16, val);
    },
};
export const SDSFXREV: $.Type<c.SDSFXREV> = {
    load: (s) => {
        s.skip(16);
        return c.SDSFXREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50957, 16, val);
    },
};
export const SDPSFX: $.Type<c.SDPSFX> = {
    load: (s) => {
        s.skip(16);
        return c.SDPSFX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50958, 16, val);
    },
};
export const SDPSFXREV: $.Type<c.SDPSFXREV> = {
    load: (s) => {
        s.skip(16);
        return c.SDPSFXREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50959, 16, val);
    },
};
export const SDCNTLEAD0: $.Type<c.SDCNTLEAD0> = {
    load: (s) => {
        s.skip(16);
        return c.SDCNTLEAD0();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50960, 16, val);
    },
};
export const SDCNTLEAD1: $.Type<c.SDCNTLEAD1> = {
    load: (s) => {
        s.skip(16);
        return c.SDCNTLEAD1();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50961, 16, val);
    },
};
export const SDCNTTRAIL0: $.Type<c.SDCNTTRAIL0> = {
    load: (s) => {
        s.skip(16);
        return c.SDCNTTRAIL0();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50962, 16, val);
    },
};
export const SDCNTTRAIL1: $.Type<c.SDCNTTRAIL1> = {
    load: (s) => {
        s.skip(16);
        return c.SDCNTTRAIL1();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50963, 16, val);
    },
};
export const NEWC: $.Type<c.NEWC> = {
    load: (s) => {
        s.skip(8);
        return c.NEWC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(200, 8, val);
    },
};
export const ENDC: $.Type<c.ENDC> = {
    load: (s) => {
        s.skip(8);
        return c.ENDC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(201, 8, val);
    },
};
export const ENDCST: $.Type<c.ENDCST> = {
    load: (s) => {
        s.skip(8);
        return c.ENDCST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(205, 8, val);
    },
};
export const STBREF: $.Type<c.STBREF> = {
    load: (s) => {
        s.skip(16);
        return c.STBREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53009, 16, val);
    },
};
export const STB: $.Type<c.STB> = {
    load: (s) => {
        s.skip(16);
        return c.STB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53011, 16, val);
    },
};
export const STREFR: $.Type<c.STREFR> = {
    load: (s) => {
        s.skip(16);
        return c.STREFR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53012, 16, val);
    },
};
export const STBREFR: $.Type<c.STBREFR> = {
    load: (s) => {
        s.skip(16);
        return c.STBREFR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53013, 16, val);
    },
};
export const STSLICER: $.Type<c.STSLICER> = {
    load: (s) => {
        s.skip(16);
        return c.STSLICER();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53014, 16, val);
    },
};
export const STBR: $.Type<c.STBR> = {
    load: (s) => {
        s.skip(16);
        return c.STBR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53015, 16, val);
    },
};
export const STREFQ: $.Type<c.STREFQ> = {
    load: (s) => {
        s.skip(16);
        return c.STREFQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53016, 16, val);
    },
};
export const STBREFQ: $.Type<c.STBREFQ> = {
    load: (s) => {
        s.skip(16);
        return c.STBREFQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53017, 16, val);
    },
};
export const STSLICEQ: $.Type<c.STSLICEQ> = {
    load: (s) => {
        s.skip(16);
        return c.STSLICEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53018, 16, val);
    },
};
export const STBQ: $.Type<c.STBQ> = {
    load: (s) => {
        s.skip(16);
        return c.STBQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53019, 16, val);
    },
};
export const STREFRQ: $.Type<c.STREFRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STREFRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53020, 16, val);
    },
};
export const STBREFRQ: $.Type<c.STBREFRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STBREFRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53021, 16, val);
    },
};
export const STSLICERQ: $.Type<c.STSLICERQ> = {
    load: (s) => {
        s.skip(16);
        return c.STSLICERQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53022, 16, val);
    },
};
export const STBRQ: $.Type<c.STBRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STBRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53023, 16, val);
    },
};
export const ENDXC: $.Type<c.ENDXC> = {
    load: (s) => {
        s.skip(16);
        return c.ENDXC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53027, 16, val);
    },
};
export const BDEPTH: $.Type<c.BDEPTH> = {
    load: (s) => {
        s.skip(16);
        return c.BDEPTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53040, 16, val);
    },
};
export const BBITS: $.Type<c.BBITS> = {
    load: (s) => {
        s.skip(16);
        return c.BBITS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53041, 16, val);
    },
};
export const BREFS: $.Type<c.BREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53042, 16, val);
    },
};
export const BBITREFS: $.Type<c.BBITREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BBITREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53043, 16, val);
    },
};
export const BREMBITS: $.Type<c.BREMBITS> = {
    load: (s) => {
        s.skip(16);
        return c.BREMBITS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53045, 16, val);
    },
};
export const BREMREFS: $.Type<c.BREMREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BREMREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53046, 16, val);
    },
};
export const BREMBITREFS: $.Type<c.BREMBITREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BREMBITREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53047, 16, val);
    },
};
export const BCHKREFS: $.Type<c.BCHKREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53050, 16, val);
    },
};
export const BCHKBITREFS: $.Type<c.BCHKBITREFS> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53051, 16, val);
    },
};
export const BCHKREFSQ: $.Type<c.BCHKREFSQ> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKREFSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53054, 16, val);
    },
};
export const BCHKBITREFSQ: $.Type<c.BCHKBITREFSQ> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITREFSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53055, 16, val);
    },
};
export const STZEROES: $.Type<c.STZEROES> = {
    load: (s) => {
        s.skip(16);
        return c.STZEROES();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53056, 16, val);
    },
};
export const STONES: $.Type<c.STONES> = {
    load: (s) => {
        s.skip(16);
        return c.STONES();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53057, 16, val);
    },
};
export const STSAME: $.Type<c.STSAME> = {
    load: (s) => {
        s.skip(16);
        return c.STSAME();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53058, 16, val);
    },
};
export const CTOS: $.Type<c.CTOS> = {
    load: (s) => {
        s.skip(8);
        return c.CTOS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(208, 8, val);
    },
};
export const ENDS: $.Type<c.ENDS> = {
    load: (s) => {
        s.skip(8);
        return c.ENDS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(209, 8, val);
    },
};
export const LDREF: $.Type<c.LDREF> = {
    load: (s) => {
        s.skip(8);
        return c.LDREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(212, 8, val);
    },
};
export const LDREFRTOS: $.Type<c.LDREFRTOS> = {
    load: (s) => {
        s.skip(8);
        return c.LDREFRTOS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(213, 8, val);
    },
};
export const SDCUTFIRST: $.Type<c.SDCUTFIRST> = {
    load: (s) => {
        s.skip(16);
        return c.SDCUTFIRST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55072, 16, val);
    },
};
export const SDSKIPFIRST: $.Type<c.SDSKIPFIRST> = {
    load: (s) => {
        s.skip(16);
        return c.SDSKIPFIRST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55073, 16, val);
    },
};
export const SDCUTLAST: $.Type<c.SDCUTLAST> = {
    load: (s) => {
        s.skip(16);
        return c.SDCUTLAST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55074, 16, val);
    },
};
export const SDSKIPLAST: $.Type<c.SDSKIPLAST> = {
    load: (s) => {
        s.skip(16);
        return c.SDSKIPLAST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55075, 16, val);
    },
};
export const SDSUBSTR: $.Type<c.SDSUBSTR> = {
    load: (s) => {
        s.skip(16);
        return c.SDSUBSTR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55076, 16, val);
    },
};
export const SCUTFIRST: $.Type<c.SCUTFIRST> = {
    load: (s) => {
        s.skip(16);
        return c.SCUTFIRST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55088, 16, val);
    },
};
export const SSKIPFIRST: $.Type<c.SSKIPFIRST> = {
    load: (s) => {
        s.skip(16);
        return c.SSKIPFIRST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55089, 16, val);
    },
};
export const SCUTLAST: $.Type<c.SCUTLAST> = {
    load: (s) => {
        s.skip(16);
        return c.SCUTLAST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55090, 16, val);
    },
};
export const SSKIPLAST: $.Type<c.SSKIPLAST> = {
    load: (s) => {
        s.skip(16);
        return c.SSKIPLAST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55091, 16, val);
    },
};
export const SUBSLICE: $.Type<c.SUBSLICE> = {
    load: (s) => {
        s.skip(16);
        return c.SUBSLICE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55092, 16, val);
    },
};
export const SPLIT: $.Type<c.SPLIT> = {
    load: (s) => {
        s.skip(16);
        return c.SPLIT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55094, 16, val);
    },
};
export const SPLITQ: $.Type<c.SPLITQ> = {
    load: (s) => {
        s.skip(16);
        return c.SPLITQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55095, 16, val);
    },
};
export const XCTOS: $.Type<c.XCTOS> = {
    load: (s) => {
        s.skip(16);
        return c.XCTOS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55097, 16, val);
    },
};
export const XLOAD: $.Type<c.XLOAD> = {
    load: (s) => {
        s.skip(16);
        return c.XLOAD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55098, 16, val);
    },
};
export const XLOADQ: $.Type<c.XLOADQ> = {
    load: (s) => {
        s.skip(16);
        return c.XLOADQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55099, 16, val);
    },
};
export const SCHKBITS: $.Type<c.SCHKBITS> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKBITS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55105, 16, val);
    },
};
export const SCHKREFS: $.Type<c.SCHKREFS> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55106, 16, val);
    },
};
export const SCHKBITREFS: $.Type<c.SCHKBITREFS> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKBITREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55107, 16, val);
    },
};
export const SCHKBITSQ: $.Type<c.SCHKBITSQ> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKBITSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55109, 16, val);
    },
};
export const SCHKREFSQ: $.Type<c.SCHKREFSQ> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKREFSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55110, 16, val);
    },
};
export const SCHKBITREFSQ: $.Type<c.SCHKBITREFSQ> = {
    load: (s) => {
        s.skip(16);
        return c.SCHKBITREFSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55111, 16, val);
    },
};
export const PLDREFVAR: $.Type<c.PLDREFVAR> = {
    load: (s) => {
        s.skip(16);
        return c.PLDREFVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55112, 16, val);
    },
};
export const SBITS: $.Type<c.SBITS> = {
    load: (s) => {
        s.skip(16);
        return c.SBITS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55113, 16, val);
    },
};
export const SREFS: $.Type<c.SREFS> = {
    load: (s) => {
        s.skip(16);
        return c.SREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55114, 16, val);
    },
};
export const SBITREFS: $.Type<c.SBITREFS> = {
    load: (s) => {
        s.skip(16);
        return c.SBITREFS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55115, 16, val);
    },
};
export const LDZEROES: $.Type<c.LDZEROES> = {
    load: (s) => {
        s.skip(16);
        return c.LDZEROES();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55136, 16, val);
    },
};
export const LDONES: $.Type<c.LDONES> = {
    load: (s) => {
        s.skip(16);
        return c.LDONES();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55137, 16, val);
    },
};
export const LDSAME: $.Type<c.LDSAME> = {
    load: (s) => {
        s.skip(16);
        return c.LDSAME();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55138, 16, val);
    },
};
export const SDEPTH: $.Type<c.SDEPTH> = {
    load: (s) => {
        s.skip(16);
        return c.SDEPTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55140, 16, val);
    },
};
export const CDEPTH: $.Type<c.CDEPTH> = {
    load: (s) => {
        s.skip(16);
        return c.CDEPTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55141, 16, val);
    },
};
export const CLEVEL: $.Type<c.CLEVEL> = {
    load: (s) => {
        s.skip(16);
        return c.CLEVEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55142, 16, val);
    },
};
export const CLEVELMASK: $.Type<c.CLEVELMASK> = {
    load: (s) => {
        s.skip(16);
        return c.CLEVELMASK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55143, 16, val);
    },
};
export const CHASHIX: $.Type<c.CHASHIX> = {
    load: (s) => {
        s.skip(16);
        return c.CHASHIX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55152, 16, val);
    },
};
export const CDEPTHIX: $.Type<c.CDEPTHIX> = {
    load: (s) => {
        s.skip(16);
        return c.CDEPTHIX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55153, 16, val);
    },
};
export const EXECUTE: $.Type<c.EXECUTE> = {
    load: (s) => {
        s.skip(8);
        return c.EXECUTE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(216, 8, val);
    },
};
export const JMPX: $.Type<c.JMPX> = {
    load: (s) => {
        s.skip(8);
        return c.JMPX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(217, 8, val);
    },
};
export const RET: $.Type<c.RET> = {
    load: (s) => {
        s.skip(16);
        return c.RET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56112, 16, val);
    },
};
export const RETALT: $.Type<c.RETALT> = {
    load: (s) => {
        s.skip(16);
        return c.RETALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56113, 16, val);
    },
};
export const RETBOOL: $.Type<c.RETBOOL> = {
    load: (s) => {
        s.skip(16);
        return c.RETBOOL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56114, 16, val);
    },
};
export const CALLCC: $.Type<c.CALLCC> = {
    load: (s) => {
        s.skip(16);
        return c.CALLCC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56116, 16, val);
    },
};
export const JMPXDATA: $.Type<c.JMPXDATA> = {
    load: (s) => {
        s.skip(16);
        return c.JMPXDATA();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56117, 16, val);
    },
};
export const CALLXVARARGS: $.Type<c.CALLXVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.CALLXVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56120, 16, val);
    },
};
export const RETVARARGS: $.Type<c.RETVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.RETVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56121, 16, val);
    },
};
export const JMPXVARARGS: $.Type<c.JMPXVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.JMPXVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56122, 16, val);
    },
};
export const CALLCCVARARGS: $.Type<c.CALLCCVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.CALLCCVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56123, 16, val);
    },
};
export const RETDATA: $.Type<c.RETDATA> = {
    load: (s) => {
        s.skip(16);
        return c.RETDATA();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56127, 16, val);
    },
};
export const RUNVMX: $.Type<c.RUNVMX> = {
    load: (s) => {
        s.skip(16);
        return c.RUNVMX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56144, 16, val);
    },
};
export const IFRET: $.Type<c.IFRET> = {
    load: (s) => {
        s.skip(8);
        return c.IFRET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(220, 8, val);
    },
};
export const IFNOTRET: $.Type<c.IFNOTRET> = {
    load: (s) => {
        s.skip(8);
        return c.IFNOTRET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(221, 8, val);
    },
};
export const IF: $.Type<c.IF> = {
    load: (s) => {
        s.skip(8);
        return c.IF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(222, 8, val);
    },
};
export const IFNOT: $.Type<c.IFNOT> = {
    load: (s) => {
        s.skip(8);
        return c.IFNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(223, 8, val);
    },
};
export const IFJMP: $.Type<c.IFJMP> = {
    load: (s) => {
        s.skip(8);
        return c.IFJMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(224, 8, val);
    },
};
export const IFNOTJMP: $.Type<c.IFNOTJMP> = {
    load: (s) => {
        s.skip(8);
        return c.IFNOTJMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(225, 8, val);
    },
};
export const IFELSE: $.Type<c.IFELSE> = {
    load: (s) => {
        s.skip(8);
        return c.IFELSE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(226, 8, val);
    },
};
export const CONDSEL: $.Type<c.CONDSEL> = {
    load: (s) => {
        s.skip(16);
        return c.CONDSEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58116, 16, val);
    },
};
export const CONDSELCHK: $.Type<c.CONDSELCHK> = {
    load: (s) => {
        s.skip(16);
        return c.CONDSELCHK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58117, 16, val);
    },
};
export const IFRETALT: $.Type<c.IFRETALT> = {
    load: (s) => {
        s.skip(16);
        return c.IFRETALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58120, 16, val);
    },
};
export const IFNOTRETALT: $.Type<c.IFNOTRETALT> = {
    load: (s) => {
        s.skip(16);
        return c.IFNOTRETALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58121, 16, val);
    },
};
export const REPEAT: $.Type<c.REPEAT> = {
    load: (s) => {
        s.skip(8);
        return c.REPEAT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(228, 8, val);
    },
};
export const REPEATEND: $.Type<c.REPEATEND> = {
    load: (s) => {
        s.skip(8);
        return c.REPEATEND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(229, 8, val);
    },
};
export const UNTIL: $.Type<c.UNTIL> = {
    load: (s) => {
        s.skip(8);
        return c.UNTIL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(230, 8, val);
    },
};
export const UNTILEND: $.Type<c.UNTILEND> = {
    load: (s) => {
        s.skip(8);
        return c.UNTILEND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(231, 8, val);
    },
};
export const WHILE: $.Type<c.WHILE> = {
    load: (s) => {
        s.skip(8);
        return c.WHILE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(232, 8, val);
    },
};
export const WHILEEND: $.Type<c.WHILEEND> = {
    load: (s) => {
        s.skip(8);
        return c.WHILEEND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(233, 8, val);
    },
};
export const AGAIN: $.Type<c.AGAIN> = {
    load: (s) => {
        s.skip(8);
        return c.AGAIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(234, 8, val);
    },
};
export const AGAINEND: $.Type<c.AGAINEND> = {
    load: (s) => {
        s.skip(8);
        return c.AGAINEND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(235, 8, val);
    },
};
export const REPEATBRK: $.Type<c.REPEATBRK> = {
    load: (s) => {
        s.skip(16);
        return c.REPEATBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58132, 16, val);
    },
};
export const REPEATENDBRK: $.Type<c.REPEATENDBRK> = {
    load: (s) => {
        s.skip(16);
        return c.REPEATENDBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58133, 16, val);
    },
};
export const UNTILBRK: $.Type<c.UNTILBRK> = {
    load: (s) => {
        s.skip(16);
        return c.UNTILBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58134, 16, val);
    },
};
export const UNTILENDBRK: $.Type<c.UNTILENDBRK> = {
    load: (s) => {
        s.skip(16);
        return c.UNTILENDBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58135, 16, val);
    },
};
export const WHILEBRK: $.Type<c.WHILEBRK> = {
    load: (s) => {
        s.skip(16);
        return c.WHILEBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58136, 16, val);
    },
};
export const WHILEENDBRK: $.Type<c.WHILEENDBRK> = {
    load: (s) => {
        s.skip(16);
        return c.WHILEENDBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58137, 16, val);
    },
};
export const AGAINBRK: $.Type<c.AGAINBRK> = {
    load: (s) => {
        s.skip(16);
        return c.AGAINBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58138, 16, val);
    },
};
export const AGAINENDBRK: $.Type<c.AGAINENDBRK> = {
    load: (s) => {
        s.skip(16);
        return c.AGAINENDBRK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58139, 16, val);
    },
};
export const RETURNVARARGS: $.Type<c.RETURNVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.RETURNVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60688, 16, val);
    },
};
export const SETCONTVARARGS: $.Type<c.SETCONTVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.SETCONTVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60689, 16, val);
    },
};
export const SETNUMVARARGS: $.Type<c.SETNUMVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.SETNUMVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60690, 16, val);
    },
};
export const BLESS: $.Type<c.BLESS> = {
    load: (s) => {
        s.skip(16);
        return c.BLESS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60702, 16, val);
    },
};
export const BLESSVARARGS: $.Type<c.BLESSVARARGS> = {
    load: (s) => {
        s.skip(16);
        return c.BLESSVARARGS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60703, 16, val);
    },
};
export const PUSHCTRX: $.Type<c.PUSHCTRX> = {
    load: (s) => {
        s.skip(16);
        return c.PUSHCTRX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60896, 16, val);
    },
};
export const POPCTRX: $.Type<c.POPCTRX> = {
    load: (s) => {
        s.skip(16);
        return c.POPCTRX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60897, 16, val);
    },
};
export const SETCONTCTRX: $.Type<c.SETCONTCTRX> = {
    load: (s) => {
        s.skip(16);
        return c.SETCONTCTRX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60898, 16, val);
    },
};
export const SETCONTCTRMANYX: $.Type<c.SETCONTCTRMANYX> = {
    load: (s) => {
        s.skip(16);
        return c.SETCONTCTRMANYX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60900, 16, val);
    },
};
export const BOOLAND: $.Type<c.BOOLAND> = {
    load: (s) => {
        s.skip(16);
        return c.BOOLAND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60912, 16, val);
    },
};
export const BOOLOR: $.Type<c.BOOLOR> = {
    load: (s) => {
        s.skip(16);
        return c.BOOLOR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60913, 16, val);
    },
};
export const COMPOSBOTH: $.Type<c.COMPOSBOTH> = {
    load: (s) => {
        s.skip(16);
        return c.COMPOSBOTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60914, 16, val);
    },
};
export const ATEXIT: $.Type<c.ATEXIT> = {
    load: (s) => {
        s.skip(16);
        return c.ATEXIT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60915, 16, val);
    },
};
export const ATEXITALT: $.Type<c.ATEXITALT> = {
    load: (s) => {
        s.skip(16);
        return c.ATEXITALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60916, 16, val);
    },
};
export const SETEXITALT: $.Type<c.SETEXITALT> = {
    load: (s) => {
        s.skip(16);
        return c.SETEXITALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60917, 16, val);
    },
};
export const THENRET: $.Type<c.THENRET> = {
    load: (s) => {
        s.skip(16);
        return c.THENRET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60918, 16, val);
    },
};
export const THENRETALT: $.Type<c.THENRETALT> = {
    load: (s) => {
        s.skip(16);
        return c.THENRETALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60919, 16, val);
    },
};
export const INVERT: $.Type<c.INVERT> = {
    load: (s) => {
        s.skip(16);
        return c.INVERT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60920, 16, val);
    },
};
export const BOOLEVAL: $.Type<c.BOOLEVAL> = {
    load: (s) => {
        s.skip(16);
        return c.BOOLEVAL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60921, 16, val);
    },
};
export const SAMEALT: $.Type<c.SAMEALT> = {
    load: (s) => {
        s.skip(16);
        return c.SAMEALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60922, 16, val);
    },
};
export const SAMEALTSAVE: $.Type<c.SAMEALTSAVE> = {
    load: (s) => {
        s.skip(16);
        return c.SAMEALTSAVE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60923, 16, val);
    },
};
export const TRY: $.Type<c.TRY> = {
    load: (s) => {
        s.skip(16);
        return c.TRY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62207, 16, val);
    },
};
export const SETCPX: $.Type<c.SETCPX> = {
    load: (s) => {
        s.skip(16);
        return c.SETCPX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65520, 16, val);
    },
};
export const STDICT: $.Type<c.STDICT> = {
    load: (s) => {
        s.skip(16);
        return c.STDICT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62464, 16, val);
    },
};
export const SKIPDICT: $.Type<c.SKIPDICT> = {
    load: (s) => {
        s.skip(16);
        return c.SKIPDICT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62465, 16, val);
    },
};
export const LDDICTS: $.Type<c.LDDICTS> = {
    load: (s) => {
        s.skip(16);
        return c.LDDICTS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62466, 16, val);
    },
};
export const PLDDICTS: $.Type<c.PLDDICTS> = {
    load: (s) => {
        s.skip(16);
        return c.PLDDICTS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62467, 16, val);
    },
};
export const LDDICT: $.Type<c.LDDICT> = {
    load: (s) => {
        s.skip(16);
        return c.LDDICT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62468, 16, val);
    },
};
export const PLDDICT: $.Type<c.PLDDICT> = {
    load: (s) => {
        s.skip(16);
        return c.PLDDICT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62469, 16, val);
    },
};
export const LDDICTQ: $.Type<c.LDDICTQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDDICTQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62470, 16, val);
    },
};
export const PLDDICTQ: $.Type<c.PLDDICTQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDDICTQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62471, 16, val);
    },
};
export const PFXDICTSET: $.Type<c.PFXDICTSET> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTSET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62576, 16, val);
    },
};
export const PFXDICTREPLACE: $.Type<c.PFXDICTREPLACE> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTREPLACE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62577, 16, val);
    },
};
export const PFXDICTADD: $.Type<c.PFXDICTADD> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62578, 16, val);
    },
};
export const PFXDICTDEL: $.Type<c.PFXDICTDEL> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTDEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62579, 16, val);
    },
};
export const PFXDICTGETQ: $.Type<c.PFXDICTGETQ> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTGETQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62632, 16, val);
    },
};
export const PFXDICTGET: $.Type<c.PFXDICTGET> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62633, 16, val);
    },
};
export const PFXDICTGETJMP: $.Type<c.PFXDICTGETJMP> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTGETJMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62634, 16, val);
    },
};
export const PFXDICTGETEXEC: $.Type<c.PFXDICTGETEXEC> = {
    load: (s) => {
        s.skip(16);
        return c.PFXDICTGETEXEC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62635, 16, val);
    },
};
export const NOP: $.Type<c.NOP> = {
    load: (s) => {
        s.skip(8);
        return c.NOP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(0, 8, val);
    },
};
export const SWAP: $.Type<c.SWAP> = {
    load: (s) => {
        s.skip(8);
        return c.SWAP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1, 8, val);
    },
};
export const DUP: $.Type<c.DUP> = {
    load: (s) => {
        s.skip(8);
        return c.DUP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(32, 8, val);
    },
};
export const OVER: $.Type<c.OVER> = {
    load: (s) => {
        s.skip(8);
        return c.OVER();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(33, 8, val);
    },
};
export const DROP: $.Type<c.DROP> = {
    load: (s) => {
        s.skip(8);
        return c.DROP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(48, 8, val);
    },
};
export const NIP: $.Type<c.NIP> = {
    load: (s) => {
        s.skip(8);
        return c.NIP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(49, 8, val);
    },
};
export const ROT: $.Type<c.ROT> = {
    load: (s) => {
        s.skip(8);
        return c.ROT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(88, 8, val);
    },
};
export const ROTREV: $.Type<c.ROTREV> = {
    load: (s) => {
        s.skip(8);
        return c.ROTREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(89, 8, val);
    },
};
export const PICK: $.Type<c.PICK> = {
    load: (s) => {
        s.skip(8);
        return c.PICK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(96, 8, val);
    },
};
export const ROLL: $.Type<c.ROLL> = {
    load: (s) => {
        s.skip(8);
        return c.ROLL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(97, 8, val);
    },
};
export const ROLLREV: $.Type<c.ROLLREV> = {
    load: (s) => {
        s.skip(8);
        return c.ROLLREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(98, 8, val);
    },
};
export const BLKSWX: $.Type<c.BLKSWX> = {
    load: (s) => {
        s.skip(8);
        return c.BLKSWX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(99, 8, val);
    },
};
export const REVX: $.Type<c.REVX> = {
    load: (s) => {
        s.skip(8);
        return c.REVX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(100, 8, val);
    },
};
export const DROPX: $.Type<c.DROPX> = {
    load: (s) => {
        s.skip(8);
        return c.DROPX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(101, 8, val);
    },
};
export const TUCK: $.Type<c.TUCK> = {
    load: (s) => {
        s.skip(8);
        return c.TUCK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(102, 8, val);
    },
};
export const XCHGX: $.Type<c.XCHGX> = {
    load: (s) => {
        s.skip(8);
        return c.XCHGX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(103, 8, val);
    },
};
export const DEPTH: $.Type<c.DEPTH> = {
    load: (s) => {
        s.skip(8);
        return c.DEPTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(104, 8, val);
    },
};
export const CHKDEPTH: $.Type<c.CHKDEPTH> = {
    load: (s) => {
        s.skip(8);
        return c.CHKDEPTH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(105, 8, val);
    },
};
export const ONLYTOPX: $.Type<c.ONLYTOPX> = {
    load: (s) => {
        s.skip(8);
        return c.ONLYTOPX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(106, 8, val);
    },
};
export const ONLYX: $.Type<c.ONLYX> = {
    load: (s) => {
        s.skip(8);
        return c.ONLYX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(107, 8, val);
    },
};
export const ACCEPT: $.Type<c.ACCEPT> = {
    load: (s) => {
        s.skip(16);
        return c.ACCEPT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63488, 16, val);
    },
};
export const SETGASLIMIT: $.Type<c.SETGASLIMIT> = {
    load: (s) => {
        s.skip(16);
        return c.SETGASLIMIT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63489, 16, val);
    },
};
export const GASCONSUMED: $.Type<c.GASCONSUMED> = {
    load: (s) => {
        s.skip(16);
        return c.GASCONSUMED();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63495, 16, val);
    },
};
export const COMMIT: $.Type<c.COMMIT> = {
    load: (s) => {
        s.skip(16);
        return c.COMMIT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63503, 16, val);
    },
};
export const NOW: $.Type<c.NOW> = {
    load: (s) => {
        s.skip(16);
        return c.NOW();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63523, 16, val);
    },
};
export const BLOCKLT: $.Type<c.BLOCKLT> = {
    load: (s) => {
        s.skip(16);
        return c.BLOCKLT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63524, 16, val);
    },
};
export const LTIME: $.Type<c.LTIME> = {
    load: (s) => {
        s.skip(16);
        return c.LTIME();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63525, 16, val);
    },
};
export const RANDSEED: $.Type<c.RANDSEED> = {
    load: (s) => {
        s.skip(16);
        return c.RANDSEED();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63526, 16, val);
    },
};
export const BALANCE: $.Type<c.BALANCE> = {
    load: (s) => {
        s.skip(16);
        return c.BALANCE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63527, 16, val);
    },
};
export const MYADDR: $.Type<c.MYADDR> = {
    load: (s) => {
        s.skip(16);
        return c.MYADDR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63528, 16, val);
    },
};
export const CONFIGROOT: $.Type<c.CONFIGROOT> = {
    load: (s) => {
        s.skip(16);
        return c.CONFIGROOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63529, 16, val);
    },
};
export const MYCODE: $.Type<c.MYCODE> = {
    load: (s) => {
        s.skip(16);
        return c.MYCODE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63530, 16, val);
    },
};
export const INCOMINGVALUE: $.Type<c.INCOMINGVALUE> = {
    load: (s) => {
        s.skip(16);
        return c.INCOMINGVALUE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63531, 16, val);
    },
};
export const STORAGEFEES: $.Type<c.STORAGEFEES> = {
    load: (s) => {
        s.skip(16);
        return c.STORAGEFEES();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63532, 16, val);
    },
};
export const PREVBLOCKSINFOTUPLE: $.Type<c.PREVBLOCKSINFOTUPLE> = {
    load: (s) => {
        s.skip(16);
        return c.PREVBLOCKSINFOTUPLE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63533, 16, val);
    },
};
export const UNPACKEDCONFIGTUPLE: $.Type<c.UNPACKEDCONFIGTUPLE> = {
    load: (s) => {
        s.skip(16);
        return c.UNPACKEDCONFIGTUPLE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63534, 16, val);
    },
};
export const DUEPAYMENT: $.Type<c.DUEPAYMENT> = {
    load: (s) => {
        s.skip(16);
        return c.DUEPAYMENT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63535, 16, val);
    },
};
export const CONFIGDICT: $.Type<c.CONFIGDICT> = {
    load: (s) => {
        s.skip(16);
        return c.CONFIGDICT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63536, 16, val);
    },
};
export const CONFIGPARAM: $.Type<c.CONFIGPARAM> = {
    load: (s) => {
        s.skip(16);
        return c.CONFIGPARAM();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63538, 16, val);
    },
};
export const CONFIGOPTPARAM: $.Type<c.CONFIGOPTPARAM> = {
    load: (s) => {
        s.skip(16);
        return c.CONFIGOPTPARAM();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63539, 16, val);
    },
};
export const PREVMCBLOCKS: $.Type<c.PREVMCBLOCKS> = {
    load: (s) => {
        s.skip(24);
        return c.PREVMCBLOCKS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16266240, 24, val);
    },
};
export const PREVKEYBLOCK: $.Type<c.PREVKEYBLOCK> = {
    load: (s) => {
        s.skip(24);
        return c.PREVKEYBLOCK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16266241, 24, val);
    },
};
export const PREVMCBLOCKS_100: $.Type<c.PREVMCBLOCKS_100> = {
    load: (s) => {
        s.skip(24);
        return c.PREVMCBLOCKS_100();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16266242, 24, val);
    },
};
export const GLOBALID: $.Type<c.GLOBALID> = {
    load: (s) => {
        s.skip(16);
        return c.GLOBALID();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63541, 16, val);
    },
};
export const GETGASFEE: $.Type<c.GETGASFEE> = {
    load: (s) => {
        s.skip(16);
        return c.GETGASFEE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63542, 16, val);
    },
};
export const GETSTORAGEFEE: $.Type<c.GETSTORAGEFEE> = {
    load: (s) => {
        s.skip(16);
        return c.GETSTORAGEFEE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63543, 16, val);
    },
};
export const GETFORWARDFEE: $.Type<c.GETFORWARDFEE> = {
    load: (s) => {
        s.skip(16);
        return c.GETFORWARDFEE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63544, 16, val);
    },
};
export const GETPRECOMPILEDGAS: $.Type<c.GETPRECOMPILEDGAS> = {
    load: (s) => {
        s.skip(16);
        return c.GETPRECOMPILEDGAS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63545, 16, val);
    },
};
export const GETORIGINALFWDFEE: $.Type<c.GETORIGINALFWDFEE> = {
    load: (s) => {
        s.skip(16);
        return c.GETORIGINALFWDFEE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63546, 16, val);
    },
};
export const GETGASFEESIMPLE: $.Type<c.GETGASFEESIMPLE> = {
    load: (s) => {
        s.skip(16);
        return c.GETGASFEESIMPLE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63547, 16, val);
    },
};
export const GETFORWARDFEESIMPLE: $.Type<c.GETFORWARDFEESIMPLE> = {
    load: (s) => {
        s.skip(16);
        return c.GETFORWARDFEESIMPLE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63548, 16, val);
    },
};
export const GETGLOBVAR: $.Type<c.GETGLOBVAR> = {
    load: (s) => {
        s.skip(16);
        return c.GETGLOBVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63552, 16, val);
    },
};
export const SETGLOBVAR: $.Type<c.SETGLOBVAR> = {
    load: (s) => {
        s.skip(16);
        return c.SETGLOBVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63584, 16, val);
    },
};
export const RANDU256: $.Type<c.RANDU256> = {
    load: (s) => {
        s.skip(16);
        return c.RANDU256();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63504, 16, val);
    },
};
export const RAND: $.Type<c.RAND> = {
    load: (s) => {
        s.skip(16);
        return c.RAND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63505, 16, val);
    },
};
export const SETRAND: $.Type<c.SETRAND> = {
    load: (s) => {
        s.skip(16);
        return c.SETRAND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63508, 16, val);
    },
};
export const ADDRAND: $.Type<c.ADDRAND> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRAND();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63509, 16, val);
    },
};
export const HASHCU: $.Type<c.HASHCU> = {
    load: (s) => {
        s.skip(16);
        return c.HASHCU();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63744, 16, val);
    },
};
export const HASHSU: $.Type<c.HASHSU> = {
    load: (s) => {
        s.skip(16);
        return c.HASHSU();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63745, 16, val);
    },
};
export const SHA256U: $.Type<c.SHA256U> = {
    load: (s) => {
        s.skip(16);
        return c.SHA256U();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63746, 16, val);
    },
};
export const CHKSIGNU: $.Type<c.CHKSIGNU> = {
    load: (s) => {
        s.skip(16);
        return c.CHKSIGNU();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63760, 16, val);
    },
};
export const CHKSIGNS: $.Type<c.CHKSIGNS> = {
    load: (s) => {
        s.skip(16);
        return c.CHKSIGNS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63761, 16, val);
    },
};
export const ECRECOVER: $.Type<c.ECRECOVER> = {
    load: (s) => {
        s.skip(16);
        return c.ECRECOVER();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63762, 16, val);
    },
};
export const SECP256K1_XONLY_PUBKEY_TWEAK_ADD: $.Type<c.SECP256K1_XONLY_PUBKEY_TWEAK_ADD> =
    {
        load: (s) => {
            s.skip(16);
            return c.SECP256K1_XONLY_PUBKEY_TWEAK_ADD();
        },
        store: (b, val) => {
            b.storeInstructionPrefix(63763, 16, val);
        },
    };
export const P256_CHKSIGNU: $.Type<c.P256_CHKSIGNU> = {
    load: (s) => {
        s.skip(16);
        return c.P256_CHKSIGNU();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63764, 16, val);
    },
};
export const P256_CHKSIGNS: $.Type<c.P256_CHKSIGNS> = {
    load: (s) => {
        s.skip(16);
        return c.P256_CHKSIGNS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63765, 16, val);
    },
};
export const RIST255_FROMHASH: $.Type<c.RIST255_FROMHASH> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_FROMHASH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63776, 16, val);
    },
};
export const RIST255_VALIDATE: $.Type<c.RIST255_VALIDATE> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_VALIDATE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63777, 16, val);
    },
};
export const RIST255_ADD: $.Type<c.RIST255_ADD> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_ADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63778, 16, val);
    },
};
export const RIST255_SUB: $.Type<c.RIST255_SUB> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_SUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63779, 16, val);
    },
};
export const RIST255_MUL: $.Type<c.RIST255_MUL> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_MUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63780, 16, val);
    },
};
export const RIST255_MULBASE: $.Type<c.RIST255_MULBASE> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_MULBASE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63781, 16, val);
    },
};
export const RIST255_PUSHL: $.Type<c.RIST255_PUSHL> = {
    load: (s) => {
        s.skip(16);
        return c.RIST255_PUSHL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63782, 16, val);
    },
};
export const RIST255_QVALIDATE: $.Type<c.RIST255_QVALIDATE> = {
    load: (s) => {
        s.skip(24);
        return c.RIST255_QVALIDATE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12056865, 24, val);
    },
};
export const RIST255_QADD: $.Type<c.RIST255_QADD> = {
    load: (s) => {
        s.skip(24);
        return c.RIST255_QADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12056866, 24, val);
    },
};
export const RIST255_QSUB: $.Type<c.RIST255_QSUB> = {
    load: (s) => {
        s.skip(24);
        return c.RIST255_QSUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12056867, 24, val);
    },
};
export const RIST255_QMUL: $.Type<c.RIST255_QMUL> = {
    load: (s) => {
        s.skip(24);
        return c.RIST255_QMUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12056868, 24, val);
    },
};
export const RIST255_QMULBASE: $.Type<c.RIST255_QMULBASE> = {
    load: (s) => {
        s.skip(24);
        return c.RIST255_QMULBASE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12056869, 24, val);
    },
};
export const BLS_VERIFY: $.Type<c.BLS_VERIFY> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_VERIFY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330752, 24, val);
    },
};
export const BLS_AGGREGATE: $.Type<c.BLS_AGGREGATE> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_AGGREGATE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330753, 24, val);
    },
};
export const BLS_FASTAGGREGATEVERIFY: $.Type<c.BLS_FASTAGGREGATEVERIFY> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_FASTAGGREGATEVERIFY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330754, 24, val);
    },
};
export const BLS_AGGREGATEVERIFY: $.Type<c.BLS_AGGREGATEVERIFY> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_AGGREGATEVERIFY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330755, 24, val);
    },
};
export const BLS_G1_ADD: $.Type<c.BLS_G1_ADD> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_ADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330768, 24, val);
    },
};
export const BLS_G1_SUB: $.Type<c.BLS_G1_SUB> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_SUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330769, 24, val);
    },
};
export const BLS_G1_NEG: $.Type<c.BLS_G1_NEG> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_NEG();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330770, 24, val);
    },
};
export const BLS_G1_MUL: $.Type<c.BLS_G1_MUL> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_MUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330771, 24, val);
    },
};
export const BLS_G1_MULTIEXP: $.Type<c.BLS_G1_MULTIEXP> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_MULTIEXP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330772, 24, val);
    },
};
export const BLS_G1_ZERO: $.Type<c.BLS_G1_ZERO> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_ZERO();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330773, 24, val);
    },
};
export const BLS_MAP_TO_G1: $.Type<c.BLS_MAP_TO_G1> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_MAP_TO_G1();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330774, 24, val);
    },
};
export const BLS_G1_INGROUP: $.Type<c.BLS_G1_INGROUP> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_INGROUP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330775, 24, val);
    },
};
export const BLS_G1_ISZERO: $.Type<c.BLS_G1_ISZERO> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G1_ISZERO();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330776, 24, val);
    },
};
export const BLS_G2_ADD: $.Type<c.BLS_G2_ADD> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_ADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330784, 24, val);
    },
};
export const BLS_G2_SUB: $.Type<c.BLS_G2_SUB> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_SUB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330785, 24, val);
    },
};
export const BLS_G2_NEG: $.Type<c.BLS_G2_NEG> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_NEG();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330786, 24, val);
    },
};
export const BLS_G2_MUL: $.Type<c.BLS_G2_MUL> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_MUL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330787, 24, val);
    },
};
export const BLS_G2_MULTIEXP: $.Type<c.BLS_G2_MULTIEXP> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_MULTIEXP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330788, 24, val);
    },
};
export const BLS_G2_ZERO: $.Type<c.BLS_G2_ZERO> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_ZERO();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330789, 24, val);
    },
};
export const BLS_MAP_TO_G2: $.Type<c.BLS_MAP_TO_G2> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_MAP_TO_G2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330790, 24, val);
    },
};
export const BLS_G2_INGROUP: $.Type<c.BLS_G2_INGROUP> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_INGROUP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330791, 24, val);
    },
};
export const BLS_G2_ISZERO: $.Type<c.BLS_G2_ISZERO> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_G2_ISZERO();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330792, 24, val);
    },
};
export const BLS_PAIRING: $.Type<c.BLS_PAIRING> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_PAIRING();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330800, 24, val);
    },
};
export const BLS_PUSHR: $.Type<c.BLS_PUSHR> = {
    load: (s) => {
        s.skip(24);
        return c.BLS_PUSHR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16330801, 24, val);
    },
};
export const CDATASIZEQ: $.Type<c.CDATASIZEQ> = {
    load: (s) => {
        s.skip(16);
        return c.CDATASIZEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63808, 16, val);
    },
};
export const CDATASIZE: $.Type<c.CDATASIZE> = {
    load: (s) => {
        s.skip(16);
        return c.CDATASIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63809, 16, val);
    },
};
export const SDATASIZEQ: $.Type<c.SDATASIZEQ> = {
    load: (s) => {
        s.skip(16);
        return c.SDATASIZEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63810, 16, val);
    },
};
export const SDATASIZE: $.Type<c.SDATASIZE> = {
    load: (s) => {
        s.skip(16);
        return c.SDATASIZE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63811, 16, val);
    },
};
export const LDGRAMS: $.Type<c.LDGRAMS> = {
    load: (s) => {
        s.skip(16);
        return c.LDGRAMS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64000, 16, val);
    },
};
export const LDVARINT16: $.Type<c.LDVARINT16> = {
    load: (s) => {
        s.skip(16);
        return c.LDVARINT16();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64001, 16, val);
    },
};
export const STGRAMS: $.Type<c.STGRAMS> = {
    load: (s) => {
        s.skip(16);
        return c.STGRAMS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64002, 16, val);
    },
};
export const STVARINT16: $.Type<c.STVARINT16> = {
    load: (s) => {
        s.skip(16);
        return c.STVARINT16();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64003, 16, val);
    },
};
export const LDVARUINT32: $.Type<c.LDVARUINT32> = {
    load: (s) => {
        s.skip(16);
        return c.LDVARUINT32();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64004, 16, val);
    },
};
export const LDVARINT32: $.Type<c.LDVARINT32> = {
    load: (s) => {
        s.skip(16);
        return c.LDVARINT32();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64005, 16, val);
    },
};
export const STVARUINT32: $.Type<c.STVARUINT32> = {
    load: (s) => {
        s.skip(16);
        return c.STVARUINT32();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64006, 16, val);
    },
};
export const STVARINT32: $.Type<c.STVARINT32> = {
    load: (s) => {
        s.skip(16);
        return c.STVARINT32();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64007, 16, val);
    },
};
export const LDMSGADDR: $.Type<c.LDMSGADDR> = {
    load: (s) => {
        s.skip(16);
        return c.LDMSGADDR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64064, 16, val);
    },
};
export const LDMSGADDRQ: $.Type<c.LDMSGADDRQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDMSGADDRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64065, 16, val);
    },
};
export const PARSEMSGADDR: $.Type<c.PARSEMSGADDR> = {
    load: (s) => {
        s.skip(16);
        return c.PARSEMSGADDR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64066, 16, val);
    },
};
export const PARSEMSGADDRQ: $.Type<c.PARSEMSGADDRQ> = {
    load: (s) => {
        s.skip(16);
        return c.PARSEMSGADDRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64067, 16, val);
    },
};
export const REWRITESTDADDR: $.Type<c.REWRITESTDADDR> = {
    load: (s) => {
        s.skip(16);
        return c.REWRITESTDADDR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64068, 16, val);
    },
};
export const REWRITESTDADDRQ: $.Type<c.REWRITESTDADDRQ> = {
    load: (s) => {
        s.skip(16);
        return c.REWRITESTDADDRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64069, 16, val);
    },
};
export const REWRITEVARADDR: $.Type<c.REWRITEVARADDR> = {
    load: (s) => {
        s.skip(16);
        return c.REWRITEVARADDR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64070, 16, val);
    },
};
export const REWRITEVARADDRQ: $.Type<c.REWRITEVARADDRQ> = {
    load: (s) => {
        s.skip(16);
        return c.REWRITEVARADDRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64071, 16, val);
    },
};
export const SENDRAWMSG: $.Type<c.SENDRAWMSG> = {
    load: (s) => {
        s.skip(16);
        return c.SENDRAWMSG();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64256, 16, val);
    },
};
export const RAWRESERVE: $.Type<c.RAWRESERVE> = {
    load: (s) => {
        s.skip(16);
        return c.RAWRESERVE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64258, 16, val);
    },
};
export const RAWRESERVEX: $.Type<c.RAWRESERVEX> = {
    load: (s) => {
        s.skip(16);
        return c.RAWRESERVEX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64259, 16, val);
    },
};
export const SETCODE: $.Type<c.SETCODE> = {
    load: (s) => {
        s.skip(16);
        return c.SETCODE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64260, 16, val);
    },
};
export const SETLIBCODE: $.Type<c.SETLIBCODE> = {
    load: (s) => {
        s.skip(16);
        return c.SETLIBCODE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64262, 16, val);
    },
};
export const CHANGELIB: $.Type<c.CHANGELIB> = {
    load: (s) => {
        s.skip(16);
        return c.CHANGELIB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64263, 16, val);
    },
};
export const SENDMSG: $.Type<c.SENDMSG> = {
    load: (s) => {
        s.skip(16);
        return c.SENDMSG();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(64264, 16, val);
    },
};
export const PUSHNULL: $.Type<c.PUSHNULL> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHNULL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(109, 8, val);
    },
};
export const ISNULL: $.Type<c.ISNULL> = {
    load: (s) => {
        s.skip(8);
        return c.ISNULL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(110, 8, val);
    },
};
export const TUPLEVAR: $.Type<c.TUPLEVAR> = {
    load: (s) => {
        s.skip(16);
        return c.TUPLEVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28544, 16, val);
    },
};
export const INDEXVAR: $.Type<c.INDEXVAR> = {
    load: (s) => {
        s.skip(16);
        return c.INDEXVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28545, 16, val);
    },
};
export const UNTUPLEVAR: $.Type<c.UNTUPLEVAR> = {
    load: (s) => {
        s.skip(16);
        return c.UNTUPLEVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28546, 16, val);
    },
};
export const UNPACKFIRSTVAR: $.Type<c.UNPACKFIRSTVAR> = {
    load: (s) => {
        s.skip(16);
        return c.UNPACKFIRSTVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28547, 16, val);
    },
};
export const EXPLODEVAR: $.Type<c.EXPLODEVAR> = {
    load: (s) => {
        s.skip(16);
        return c.EXPLODEVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28548, 16, val);
    },
};
export const SETINDEXVAR: $.Type<c.SETINDEXVAR> = {
    load: (s) => {
        s.skip(16);
        return c.SETINDEXVAR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28549, 16, val);
    },
};
export const INDEXVARQ: $.Type<c.INDEXVARQ> = {
    load: (s) => {
        s.skip(16);
        return c.INDEXVARQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28550, 16, val);
    },
};
export const SETINDEXVARQ: $.Type<c.SETINDEXVARQ> = {
    load: (s) => {
        s.skip(16);
        return c.SETINDEXVARQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28551, 16, val);
    },
};
export const TLEN: $.Type<c.TLEN> = {
    load: (s) => {
        s.skip(16);
        return c.TLEN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28552, 16, val);
    },
};
export const QTLEN: $.Type<c.QTLEN> = {
    load: (s) => {
        s.skip(16);
        return c.QTLEN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28553, 16, val);
    },
};
export const ISTUPLE: $.Type<c.ISTUPLE> = {
    load: (s) => {
        s.skip(16);
        return c.ISTUPLE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28554, 16, val);
    },
};
export const LAST: $.Type<c.LAST> = {
    load: (s) => {
        s.skip(16);
        return c.LAST();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28555, 16, val);
    },
};
export const TPUSH: $.Type<c.TPUSH> = {
    load: (s) => {
        s.skip(16);
        return c.TPUSH();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28556, 16, val);
    },
};
export const TPOP: $.Type<c.TPOP> = {
    load: (s) => {
        s.skip(16);
        return c.TPOP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28557, 16, val);
    },
};
export const NULLSWAPIF: $.Type<c.NULLSWAPIF> = {
    load: (s) => {
        s.skip(16);
        return c.NULLSWAPIF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28576, 16, val);
    },
};
export const NULLSWAPIFNOT: $.Type<c.NULLSWAPIFNOT> = {
    load: (s) => {
        s.skip(16);
        return c.NULLSWAPIFNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28577, 16, val);
    },
};
export const NULLROTRIF: $.Type<c.NULLROTRIF> = {
    load: (s) => {
        s.skip(16);
        return c.NULLROTRIF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28578, 16, val);
    },
};
export const NULLROTRIFNOT: $.Type<c.NULLROTRIFNOT> = {
    load: (s) => {
        s.skip(16);
        return c.NULLROTRIFNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28579, 16, val);
    },
};
export const NULLSWAPIF2: $.Type<c.NULLSWAPIF2> = {
    load: (s) => {
        s.skip(16);
        return c.NULLSWAPIF2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28580, 16, val);
    },
};
export const NULLSWAPIFNOT2: $.Type<c.NULLSWAPIFNOT2> = {
    load: (s) => {
        s.skip(16);
        return c.NULLSWAPIFNOT2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28581, 16, val);
    },
};
export const NULLROTRIF2: $.Type<c.NULLROTRIF2> = {
    load: (s) => {
        s.skip(16);
        return c.NULLROTRIF2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28582, 16, val);
    },
};
export const NULLROTRIFNOT2: $.Type<c.NULLROTRIFNOT2> = {
    load: (s) => {
        s.skip(16);
        return c.NULLROTRIFNOT2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(28583, 16, val);
    },
};
export const ADDDIVMOD: $.Type<c.ADDDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.ADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43264, 16, val);
    },
};
export const ADDDIVMODR: $.Type<c.ADDDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.ADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43265, 16, val);
    },
};
export const ADDDIVMODC: $.Type<c.ADDDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.ADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43266, 16, val);
    },
};
export const DIV: $.Type<c.DIV> = {
    load: (s) => {
        s.skip(16);
        return c.DIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43268, 16, val);
    },
};
export const DIVR: $.Type<c.DIVR> = {
    load: (s) => {
        s.skip(16);
        return c.DIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43269, 16, val);
    },
};
export const DIVC: $.Type<c.DIVC> = {
    load: (s) => {
        s.skip(16);
        return c.DIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43270, 16, val);
    },
};
export const MOD: $.Type<c.MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43272, 16, val);
    },
};
export const MODR: $.Type<c.MODR> = {
    load: (s) => {
        s.skip(16);
        return c.MODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43273, 16, val);
    },
};
export const MODC: $.Type<c.MODC> = {
    load: (s) => {
        s.skip(16);
        return c.MODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43274, 16, val);
    },
};
export const DIVMOD: $.Type<c.DIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.DIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43276, 16, val);
    },
};
export const DIVMODR: $.Type<c.DIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.DIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43277, 16, val);
    },
};
export const DIVMODC: $.Type<c.DIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.DIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43278, 16, val);
    },
};
export const QADDDIVMOD: $.Type<c.QADDDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036352, 24, val);
    },
};
export const QADDDIVMODR: $.Type<c.QADDDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036353, 24, val);
    },
};
export const QADDDIVMODC: $.Type<c.QADDDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036354, 24, val);
    },
};
export const QDIV: $.Type<c.QDIV> = {
    load: (s) => {
        s.skip(24);
        return c.QDIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036356, 24, val);
    },
};
export const QDIVR: $.Type<c.QDIVR> = {
    load: (s) => {
        s.skip(24);
        return c.QDIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036357, 24, val);
    },
};
export const QDIVC: $.Type<c.QDIVC> = {
    load: (s) => {
        s.skip(24);
        return c.QDIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036358, 24, val);
    },
};
export const QMOD: $.Type<c.QMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036360, 24, val);
    },
};
export const QMODR: $.Type<c.QMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036361, 24, val);
    },
};
export const QMODC: $.Type<c.QMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036362, 24, val);
    },
};
export const QDIVMOD: $.Type<c.QDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036364, 24, val);
    },
};
export const QDIVMODR: $.Type<c.QDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036365, 24, val);
    },
};
export const QDIVMODC: $.Type<c.QDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036366, 24, val);
    },
};
export const ADDRSHIFTMOD: $.Type<c.ADDRSHIFTMOD> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43296, 16, val);
    },
};
export const ADDRSHIFTMODR: $.Type<c.ADDRSHIFTMODR> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43297, 16, val);
    },
};
export const ADDRSHIFTMODC: $.Type<c.ADDRSHIFTMODC> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43298, 16, val);
    },
};
export const RSHIFTR: $.Type<c.RSHIFTR> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43301, 16, val);
    },
};
export const RSHIFTC: $.Type<c.RSHIFTC> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43302, 16, val);
    },
};
export const MODPOW2: $.Type<c.MODPOW2> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43304, 16, val);
    },
};
export const MODPOW2R: $.Type<c.MODPOW2R> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2R();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43305, 16, val);
    },
};
export const MODPOW2C: $.Type<c.MODPOW2C> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2C();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43306, 16, val);
    },
};
export const RSHIFTMOD: $.Type<c.RSHIFTMOD> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43308, 16, val);
    },
};
export const RSHIFTMODR: $.Type<c.RSHIFTMODR> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43309, 16, val);
    },
};
export const RSHIFTMODC: $.Type<c.RSHIFTMODC> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43310, 16, val);
    },
};
export const QADDRSHIFTMOD: $.Type<c.QADDRSHIFTMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QADDRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036384, 24, val);
    },
};
export const QADDRSHIFTMODR: $.Type<c.QADDRSHIFTMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QADDRSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036385, 24, val);
    },
};
export const QADDRSHIFTMODC: $.Type<c.QADDRSHIFTMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QADDRSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036386, 24, val);
    },
};
export const QRSHIFTR: $.Type<c.QRSHIFTR> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFTR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036389, 24, val);
    },
};
export const QRSHIFTC: $.Type<c.QRSHIFTC> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFTC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036390, 24, val);
    },
};
export const QMODPOW2: $.Type<c.QMODPOW2> = {
    load: (s) => {
        s.skip(24);
        return c.QMODPOW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036392, 24, val);
    },
};
export const QMODPOW2R: $.Type<c.QMODPOW2R> = {
    load: (s) => {
        s.skip(24);
        return c.QMODPOW2R();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036393, 24, val);
    },
};
export const QMODPOW2C: $.Type<c.QMODPOW2C> = {
    load: (s) => {
        s.skip(24);
        return c.QMODPOW2C();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036394, 24, val);
    },
};
export const QRSHIFTMOD: $.Type<c.QRSHIFTMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036396, 24, val);
    },
};
export const QRSHIFTMODR: $.Type<c.QRSHIFTMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036397, 24, val);
    },
};
export const QRSHIFTMODC: $.Type<c.QRSHIFTMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036398, 24, val);
    },
};
export const MULADDDIVMOD: $.Type<c.MULADDDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43392, 16, val);
    },
};
export const MULADDDIVMODR: $.Type<c.MULADDDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43393, 16, val);
    },
};
export const MULADDDIVMODC: $.Type<c.MULADDDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43394, 16, val);
    },
};
export const MULDIV: $.Type<c.MULDIV> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43396, 16, val);
    },
};
export const MULDIVR: $.Type<c.MULDIVR> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43397, 16, val);
    },
};
export const MULDIVC: $.Type<c.MULDIVC> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43398, 16, val);
    },
};
export const MULMOD: $.Type<c.MULMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43400, 16, val);
    },
};
export const MULMODR: $.Type<c.MULMODR> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43401, 16, val);
    },
};
export const MULMODC: $.Type<c.MULMODC> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43402, 16, val);
    },
};
export const MULDIVMOD: $.Type<c.MULDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43404, 16, val);
    },
};
export const MULDIVMODR: $.Type<c.MULDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43405, 16, val);
    },
};
export const MULDIVMODC: $.Type<c.MULDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.MULDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43406, 16, val);
    },
};
export const QMULADDDIVMOD: $.Type<c.QMULADDDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036480, 24, val);
    },
};
export const QMULADDDIVMODR: $.Type<c.QMULADDDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036481, 24, val);
    },
};
export const QMULADDDIVMODC: $.Type<c.QMULADDDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036482, 24, val);
    },
};
export const QMULDIV: $.Type<c.QMULDIV> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036484, 24, val);
    },
};
export const QMULDIVR: $.Type<c.QMULDIVR> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036485, 24, val);
    },
};
export const QMULDIVC: $.Type<c.QMULDIVC> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036486, 24, val);
    },
};
export const QMULMOD: $.Type<c.QMULMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036488, 24, val);
    },
};
export const QMULMODR: $.Type<c.QMULMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036489, 24, val);
    },
};
export const QMULMODC: $.Type<c.QMULMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036490, 24, val);
    },
};
export const QMULDIVMOD: $.Type<c.QMULDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036492, 24, val);
    },
};
export const QMULDIVMODR: $.Type<c.QMULDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036493, 24, val);
    },
};
export const QMULDIVMODC: $.Type<c.QMULDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QMULDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036494, 24, val);
    },
};
export const MULADDRSHIFTMOD: $.Type<c.MULADDRSHIFTMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43424, 16, val);
    },
};
export const MULADDRSHIFTRMOD: $.Type<c.MULADDRSHIFTRMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFTRMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43425, 16, val);
    },
};
export const MULADDRSHIFTCMOD: $.Type<c.MULADDRSHIFTCMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFTCMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43426, 16, val);
    },
};
export const MULRSHIFT: $.Type<c.MULRSHIFT> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43428, 16, val);
    },
};
export const MULRSHIFTR: $.Type<c.MULRSHIFTR> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43429, 16, val);
    },
};
export const MULRSHIFTC: $.Type<c.MULRSHIFTC> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43430, 16, val);
    },
};
export const MULMODPOW2: $.Type<c.MULMODPOW2> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43432, 16, val);
    },
};
export const MULMODPOW2R: $.Type<c.MULMODPOW2R> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2R();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43433, 16, val);
    },
};
export const MULMODPOW2C: $.Type<c.MULMODPOW2C> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2C();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43434, 16, val);
    },
};
export const MULRSHIFTMOD: $.Type<c.MULRSHIFTMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43436, 16, val);
    },
};
export const MULRSHIFTRMOD: $.Type<c.MULRSHIFTRMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTRMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43437, 16, val);
    },
};
export const MULRSHIFTCMOD: $.Type<c.MULRSHIFTCMOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTCMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43438, 16, val);
    },
};
export const QMULADDRSHIFTMOD: $.Type<c.QMULADDRSHIFTMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036512, 24, val);
    },
};
export const QMULADDRSHIFTRMOD: $.Type<c.QMULADDRSHIFTRMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDRSHIFTRMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036513, 24, val);
    },
};
export const QMULADDRSHIFTCMOD: $.Type<c.QMULADDRSHIFTCMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULADDRSHIFTCMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036514, 24, val);
    },
};
export const QMULRSHIFT: $.Type<c.QMULRSHIFT> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036516, 24, val);
    },
};
export const QMULRSHIFTR: $.Type<c.QMULRSHIFTR> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFTR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036517, 24, val);
    },
};
export const QMULRSHIFTC: $.Type<c.QMULRSHIFTC> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFTC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036518, 24, val);
    },
};
export const QMULMODPOW2: $.Type<c.QMULMODPOW2> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMODPOW2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036520, 24, val);
    },
};
export const QMULMODPOW2R: $.Type<c.QMULMODPOW2R> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMODPOW2R();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036521, 24, val);
    },
};
export const QMULMODPOW2C: $.Type<c.QMULMODPOW2C> = {
    load: (s) => {
        s.skip(24);
        return c.QMULMODPOW2C();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036522, 24, val);
    },
};
export const QMULRSHIFTMOD: $.Type<c.QMULRSHIFTMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036524, 24, val);
    },
};
export const QMULRSHIFTRMOD: $.Type<c.QMULRSHIFTRMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFTRMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036525, 24, val);
    },
};
export const QMULRSHIFTCMOD: $.Type<c.QMULRSHIFTCMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QMULRSHIFTCMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036526, 24, val);
    },
};
export const LSHIFTADDDIVMOD: $.Type<c.LSHIFTADDDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43456, 16, val);
    },
};
export const LSHIFTADDDIVMODR: $.Type<c.LSHIFTADDDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43457, 16, val);
    },
};
export const LSHIFTADDDIVMODC: $.Type<c.LSHIFTADDDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43458, 16, val);
    },
};
export const LSHIFTDIV: $.Type<c.LSHIFTDIV> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43460, 16, val);
    },
};
export const LSHIFTDIVR: $.Type<c.LSHIFTDIVR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43461, 16, val);
    },
};
export const LSHIFTDIVC: $.Type<c.LSHIFTDIVC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43462, 16, val);
    },
};
export const LSHIFTMOD: $.Type<c.LSHIFTMOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43464, 16, val);
    },
};
export const LSHIFTMODR: $.Type<c.LSHIFTMODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43465, 16, val);
    },
};
export const LSHIFTMODC: $.Type<c.LSHIFTMODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43466, 16, val);
    },
};
export const LSHIFTDIVMOD: $.Type<c.LSHIFTDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43468, 16, val);
    },
};
export const LSHIFTDIVMODR: $.Type<c.LSHIFTDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43469, 16, val);
    },
};
export const LSHIFTDIVMODC: $.Type<c.LSHIFTDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFTDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43470, 16, val);
    },
};
export const QLSHIFTADDDIVMOD: $.Type<c.QLSHIFTADDDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTADDDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036544, 24, val);
    },
};
export const QLSHIFTADDDIVMODR: $.Type<c.QLSHIFTADDDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTADDDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036545, 24, val);
    },
};
export const QLSHIFTADDDIVMODC: $.Type<c.QLSHIFTADDDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTADDDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036546, 24, val);
    },
};
export const QLSHIFTDIV: $.Type<c.QLSHIFTDIV> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036548, 24, val);
    },
};
export const QLSHIFTDIVR: $.Type<c.QLSHIFTDIVR> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIVR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036549, 24, val);
    },
};
export const QLSHIFTDIVC: $.Type<c.QLSHIFTDIVC> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIVC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036550, 24, val);
    },
};
export const QLSHIFTMOD: $.Type<c.QLSHIFTMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036552, 24, val);
    },
};
export const QLSHIFTMODR: $.Type<c.QLSHIFTMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036553, 24, val);
    },
};
export const QLSHIFTMODC: $.Type<c.QLSHIFTMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036554, 24, val);
    },
};
export const QLSHIFTDIVMOD: $.Type<c.QLSHIFTDIVMOD> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIVMOD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036556, 24, val);
    },
};
export const QLSHIFTDIVMODR: $.Type<c.QLSHIFTDIVMODR> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIVMODR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036557, 24, val);
    },
};
export const QLSHIFTDIVMODC: $.Type<c.QLSHIFTDIVMODC> = {
    load: (s) => {
        s.skip(24);
        return c.QLSHIFTDIVMODC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036558, 24, val);
    },
};
export const STIX: $.Type<c.STIX> = {
    load: (s) => {
        s.skip(16);
        return c.STIX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52992, 16, val);
    },
};
export const STUX: $.Type<c.STUX> = {
    load: (s) => {
        s.skip(16);
        return c.STUX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52993, 16, val);
    },
};
export const STIXR: $.Type<c.STIXR> = {
    load: (s) => {
        s.skip(16);
        return c.STIXR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52994, 16, val);
    },
};
export const STUXR: $.Type<c.STUXR> = {
    load: (s) => {
        s.skip(16);
        return c.STUXR();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52995, 16, val);
    },
};
export const STIXQ: $.Type<c.STIXQ> = {
    load: (s) => {
        s.skip(16);
        return c.STIXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52996, 16, val);
    },
};
export const STUXQ: $.Type<c.STUXQ> = {
    load: (s) => {
        s.skip(16);
        return c.STUXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52997, 16, val);
    },
};
export const STIXRQ: $.Type<c.STIXRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STIXRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52998, 16, val);
    },
};
export const STUXRQ: $.Type<c.STUXRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STUXRQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(52999, 16, val);
    },
};
export const STILE4: $.Type<c.STILE4> = {
    load: (s) => {
        s.skip(16);
        return c.STILE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53032, 16, val);
    },
};
export const STULE4: $.Type<c.STULE4> = {
    load: (s) => {
        s.skip(16);
        return c.STULE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53033, 16, val);
    },
};
export const STILE8: $.Type<c.STILE8> = {
    load: (s) => {
        s.skip(16);
        return c.STILE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53034, 16, val);
    },
};
export const STULE8: $.Type<c.STULE8> = {
    load: (s) => {
        s.skip(16);
        return c.STULE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53035, 16, val);
    },
};
export const LDIX: $.Type<c.LDIX> = {
    load: (s) => {
        s.skip(16);
        return c.LDIX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55040, 16, val);
    },
};
export const LDUX: $.Type<c.LDUX> = {
    load: (s) => {
        s.skip(16);
        return c.LDUX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55041, 16, val);
    },
};
export const PLDIX: $.Type<c.PLDIX> = {
    load: (s) => {
        s.skip(16);
        return c.PLDIX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55042, 16, val);
    },
};
export const PLDUX: $.Type<c.PLDUX> = {
    load: (s) => {
        s.skip(16);
        return c.PLDUX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55043, 16, val);
    },
};
export const LDIXQ: $.Type<c.LDIXQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDIXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55044, 16, val);
    },
};
export const LDUXQ: $.Type<c.LDUXQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDUXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55045, 16, val);
    },
};
export const PLDIXQ: $.Type<c.PLDIXQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDIXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55046, 16, val);
    },
};
export const PLDUXQ: $.Type<c.PLDUXQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDUXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55047, 16, val);
    },
};
export const LDSLICEX: $.Type<c.LDSLICEX> = {
    load: (s) => {
        s.skip(16);
        return c.LDSLICEX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55064, 16, val);
    },
};
export const PLDSLICEX: $.Type<c.PLDSLICEX> = {
    load: (s) => {
        s.skip(16);
        return c.PLDSLICEX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55065, 16, val);
    },
};
export const LDSLICEXQ: $.Type<c.LDSLICEXQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDSLICEXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55066, 16, val);
    },
};
export const PLDSLICEXQ: $.Type<c.PLDSLICEXQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDSLICEXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55067, 16, val);
    },
};
export const LDILE4: $.Type<c.LDILE4> = {
    load: (s) => {
        s.skip(16);
        return c.LDILE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55120, 16, val);
    },
};
export const LDULE4: $.Type<c.LDULE4> = {
    load: (s) => {
        s.skip(16);
        return c.LDULE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55121, 16, val);
    },
};
export const LDILE8: $.Type<c.LDILE8> = {
    load: (s) => {
        s.skip(16);
        return c.LDILE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55122, 16, val);
    },
};
export const LDULE8: $.Type<c.LDULE8> = {
    load: (s) => {
        s.skip(16);
        return c.LDULE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55123, 16, val);
    },
};
export const PLDILE4: $.Type<c.PLDILE4> = {
    load: (s) => {
        s.skip(16);
        return c.PLDILE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55124, 16, val);
    },
};
export const PLDULE4: $.Type<c.PLDULE4> = {
    load: (s) => {
        s.skip(16);
        return c.PLDULE4();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55125, 16, val);
    },
};
export const PLDILE8: $.Type<c.PLDILE8> = {
    load: (s) => {
        s.skip(16);
        return c.PLDILE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55126, 16, val);
    },
};
export const PLDULE8: $.Type<c.PLDULE8> = {
    load: (s) => {
        s.skip(16);
        return c.PLDULE8();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55127, 16, val);
    },
};
export const LDILE4Q: $.Type<c.LDILE4Q> = {
    load: (s) => {
        s.skip(16);
        return c.LDILE4Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55128, 16, val);
    },
};
export const LDULE4Q: $.Type<c.LDULE4Q> = {
    load: (s) => {
        s.skip(16);
        return c.LDULE4Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55129, 16, val);
    },
};
export const LDILE8Q: $.Type<c.LDILE8Q> = {
    load: (s) => {
        s.skip(16);
        return c.LDILE8Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55130, 16, val);
    },
};
export const LDULE8Q: $.Type<c.LDULE8Q> = {
    load: (s) => {
        s.skip(16);
        return c.LDULE8Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55131, 16, val);
    },
};
export const PLDILE4Q: $.Type<c.PLDILE4Q> = {
    load: (s) => {
        s.skip(16);
        return c.PLDILE4Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55132, 16, val);
    },
};
export const PLDULE4Q: $.Type<c.PLDULE4Q> = {
    load: (s) => {
        s.skip(16);
        return c.PLDULE4Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55133, 16, val);
    },
};
export const PLDILE8Q: $.Type<c.PLDILE8Q> = {
    load: (s) => {
        s.skip(16);
        return c.PLDILE8Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55134, 16, val);
    },
};
export const PLDULE8Q: $.Type<c.PLDULE8Q> = {
    load: (s) => {
        s.skip(16);
        return c.PLDULE8Q();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55135, 16, val);
    },
};
export const DICTIGETJMP: $.Type<c.DICTIGETJMP> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETJMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62624, 16, val);
    },
};
export const DICTUGETJMP: $.Type<c.DICTUGETJMP> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETJMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62625, 16, val);
    },
};
export const DICTIGETEXEC: $.Type<c.DICTIGETEXEC> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETEXEC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62626, 16, val);
    },
};
export const DICTUGETEXEC: $.Type<c.DICTUGETEXEC> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETEXEC();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62627, 16, val);
    },
};
export const DICTIGETJMPZ: $.Type<c.DICTIGETJMPZ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETJMPZ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62652, 16, val);
    },
};
export const DICTUGETJMPZ: $.Type<c.DICTUGETJMPZ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETJMPZ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62653, 16, val);
    },
};
export const DICTIGETEXECZ: $.Type<c.DICTIGETEXECZ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETEXECZ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62654, 16, val);
    },
};
export const DICTUGETEXECZ: $.Type<c.DICTUGETEXECZ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETEXECZ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62655, 16, val);
    },
};
export const DICTGET: $.Type<c.DICTGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62474, 16, val);
    },
};
export const DICTGETREF: $.Type<c.DICTGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62475, 16, val);
    },
};
export const DICTIGET: $.Type<c.DICTIGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62476, 16, val);
    },
};
export const DICTIGETREF: $.Type<c.DICTIGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62477, 16, val);
    },
};
export const DICTUGET: $.Type<c.DICTUGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62478, 16, val);
    },
};
export const DICTUGETREF: $.Type<c.DICTUGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62479, 16, val);
    },
};
export const DICTSET: $.Type<c.DICTSET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62482, 16, val);
    },
};
export const DICTSETREF: $.Type<c.DICTSETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62483, 16, val);
    },
};
export const DICTISET: $.Type<c.DICTISET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62484, 16, val);
    },
};
export const DICTISETREF: $.Type<c.DICTISETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62485, 16, val);
    },
};
export const DICTUSET: $.Type<c.DICTUSET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62486, 16, val);
    },
};
export const DICTUSETREF: $.Type<c.DICTUSETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62487, 16, val);
    },
};
export const DICTSETGET: $.Type<c.DICTSETGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62490, 16, val);
    },
};
export const DICTSETGETREF: $.Type<c.DICTSETGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62491, 16, val);
    },
};
export const DICTISETGET: $.Type<c.DICTISETGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62492, 16, val);
    },
};
export const DICTISETGETREF: $.Type<c.DICTISETGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62493, 16, val);
    },
};
export const DICTUSETGET: $.Type<c.DICTUSETGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62494, 16, val);
    },
};
export const DICTUSETGETREF: $.Type<c.DICTUSETGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62495, 16, val);
    },
};
export const DICTREPLACE: $.Type<c.DICTREPLACE> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62498, 16, val);
    },
};
export const DICTREPLACEREF: $.Type<c.DICTREPLACEREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACEREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62499, 16, val);
    },
};
export const DICTIREPLACE: $.Type<c.DICTIREPLACE> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62500, 16, val);
    },
};
export const DICTIREPLACEREF: $.Type<c.DICTIREPLACEREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACEREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62501, 16, val);
    },
};
export const DICTUREPLACE: $.Type<c.DICTUREPLACE> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62502, 16, val);
    },
};
export const DICTUREPLACEREF: $.Type<c.DICTUREPLACEREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACEREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62503, 16, val);
    },
};
export const DICTREPLACEGET: $.Type<c.DICTREPLACEGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACEGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62506, 16, val);
    },
};
export const DICTREPLACEGETREF: $.Type<c.DICTREPLACEGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACEGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62507, 16, val);
    },
};
export const DICTIREPLACEGET: $.Type<c.DICTIREPLACEGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACEGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62508, 16, val);
    },
};
export const DICTIREPLACEGETREF: $.Type<c.DICTIREPLACEGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACEGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62509, 16, val);
    },
};
export const DICTUREPLACEGET: $.Type<c.DICTUREPLACEGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACEGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62510, 16, val);
    },
};
export const DICTUREPLACEGETREF: $.Type<c.DICTUREPLACEGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACEGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62511, 16, val);
    },
};
export const DICTADD: $.Type<c.DICTADD> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62514, 16, val);
    },
};
export const DICTADDREF: $.Type<c.DICTADDREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADDREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62515, 16, val);
    },
};
export const DICTIADD: $.Type<c.DICTIADD> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62516, 16, val);
    },
};
export const DICTIADDREF: $.Type<c.DICTIADDREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADDREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62517, 16, val);
    },
};
export const DICTUADD: $.Type<c.DICTUADD> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADD();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62518, 16, val);
    },
};
export const DICTUADDREF: $.Type<c.DICTUADDREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADDREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62519, 16, val);
    },
};
export const DICTADDGET: $.Type<c.DICTADDGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADDGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62522, 16, val);
    },
};
export const DICTADDGETREF: $.Type<c.DICTADDGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADDGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62523, 16, val);
    },
};
export const DICTIADDGET: $.Type<c.DICTIADDGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADDGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62524, 16, val);
    },
};
export const DICTIADDGETREF: $.Type<c.DICTIADDGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADDGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62525, 16, val);
    },
};
export const DICTUADDGET: $.Type<c.DICTUADDGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADDGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62526, 16, val);
    },
};
export const DICTUADDGETREF: $.Type<c.DICTUADDGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADDGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62527, 16, val);
    },
};
export const DICTDELGET: $.Type<c.DICTDELGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTDELGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62562, 16, val);
    },
};
export const DICTDELGETREF: $.Type<c.DICTDELGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTDELGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62563, 16, val);
    },
};
export const DICTIDELGET: $.Type<c.DICTIDELGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIDELGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62564, 16, val);
    },
};
export const DICTIDELGETREF: $.Type<c.DICTIDELGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIDELGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62565, 16, val);
    },
};
export const DICTUDELGET: $.Type<c.DICTUDELGET> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUDELGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62566, 16, val);
    },
};
export const DICTUDELGETREF: $.Type<c.DICTUDELGETREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUDELGETREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62567, 16, val);
    },
};
export const DICTMIN: $.Type<c.DICTMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62594, 16, val);
    },
};
export const DICTMINREF: $.Type<c.DICTMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62595, 16, val);
    },
};
export const DICTIMIN: $.Type<c.DICTIMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62596, 16, val);
    },
};
export const DICTIMINREF: $.Type<c.DICTIMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62597, 16, val);
    },
};
export const DICTUMIN: $.Type<c.DICTUMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62598, 16, val);
    },
};
export const DICTUMINREF: $.Type<c.DICTUMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62599, 16, val);
    },
};
export const DICTMAX: $.Type<c.DICTMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62602, 16, val);
    },
};
export const DICTMAXREF: $.Type<c.DICTMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62603, 16, val);
    },
};
export const DICTIMAX: $.Type<c.DICTIMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62604, 16, val);
    },
};
export const DICTIMAXREF: $.Type<c.DICTIMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62605, 16, val);
    },
};
export const DICTUMAX: $.Type<c.DICTUMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62606, 16, val);
    },
};
export const DICTUMAXREF: $.Type<c.DICTUMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62607, 16, val);
    },
};
export const DICTREMMIN: $.Type<c.DICTREMMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREMMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62610, 16, val);
    },
};
export const DICTREMMINREF: $.Type<c.DICTREMMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREMMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62611, 16, val);
    },
};
export const DICTIREMMIN: $.Type<c.DICTIREMMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREMMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62612, 16, val);
    },
};
export const DICTIREMMINREF: $.Type<c.DICTIREMMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREMMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62613, 16, val);
    },
};
export const DICTUREMMIN: $.Type<c.DICTUREMMIN> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREMMIN();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62614, 16, val);
    },
};
export const DICTUREMMINREF: $.Type<c.DICTUREMMINREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREMMINREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62615, 16, val);
    },
};
export const DICTREMMAX: $.Type<c.DICTREMMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREMMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62618, 16, val);
    },
};
export const DICTREMMAXREF: $.Type<c.DICTREMMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREMMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62619, 16, val);
    },
};
export const DICTIREMMAX: $.Type<c.DICTIREMMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREMMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62620, 16, val);
    },
};
export const DICTIREMMAXREF: $.Type<c.DICTIREMMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREMMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62621, 16, val);
    },
};
export const DICTUREMMAX: $.Type<c.DICTUREMMAX> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREMMAX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62622, 16, val);
    },
};
export const DICTUREMMAXREF: $.Type<c.DICTUREMMAXREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREMMAXREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62623, 16, val);
    },
};
export const DICTSETB: $.Type<c.DICTSETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62529, 16, val);
    },
};
export const DICTISETB: $.Type<c.DICTISETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62530, 16, val);
    },
};
export const DICTUSETB: $.Type<c.DICTUSETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62531, 16, val);
    },
};
export const DICTSETGETB: $.Type<c.DICTSETGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62533, 16, val);
    },
};
export const DICTISETGETB: $.Type<c.DICTISETGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62534, 16, val);
    },
};
export const DICTUSETGETB: $.Type<c.DICTUSETGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62535, 16, val);
    },
};
export const DICTREPLACEB: $.Type<c.DICTREPLACEB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACEB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62537, 16, val);
    },
};
export const DICTIREPLACEB: $.Type<c.DICTIREPLACEB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACEB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62538, 16, val);
    },
};
export const DICTUREPLACEB: $.Type<c.DICTUREPLACEB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACEB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62539, 16, val);
    },
};
export const DICTREPLACEGETB: $.Type<c.DICTREPLACEGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTREPLACEGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62541, 16, val);
    },
};
export const DICTIREPLACEGETB: $.Type<c.DICTIREPLACEGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIREPLACEGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62542, 16, val);
    },
};
export const DICTUREPLACEGETB: $.Type<c.DICTUREPLACEGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUREPLACEGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62543, 16, val);
    },
};
export const DICTADDB: $.Type<c.DICTADDB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADDB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62545, 16, val);
    },
};
export const DICTIADDB: $.Type<c.DICTIADDB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADDB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62546, 16, val);
    },
};
export const DICTUADDB: $.Type<c.DICTUADDB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADDB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62547, 16, val);
    },
};
export const DICTADDGETB: $.Type<c.DICTADDGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTADDGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62549, 16, val);
    },
};
export const DICTIADDGETB: $.Type<c.DICTIADDGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIADDGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62550, 16, val);
    },
};
export const DICTUADDGETB: $.Type<c.DICTUADDGETB> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUADDGETB();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62551, 16, val);
    },
};
export const DICTDEL: $.Type<c.DICTDEL> = {
    load: (s) => {
        s.skip(16);
        return c.DICTDEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62553, 16, val);
    },
};
export const DICTIDEL: $.Type<c.DICTIDEL> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIDEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62554, 16, val);
    },
};
export const DICTUDEL: $.Type<c.DICTUDEL> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUDEL();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62555, 16, val);
    },
};
export const DICTGETOPTREF: $.Type<c.DICTGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62569, 16, val);
    },
};
export const DICTIGETOPTREF: $.Type<c.DICTIGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62570, 16, val);
    },
};
export const DICTUGETOPTREF: $.Type<c.DICTUGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62571, 16, val);
    },
};
export const DICTSETGETOPTREF: $.Type<c.DICTSETGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTSETGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62573, 16, val);
    },
};
export const DICTISETGETOPTREF: $.Type<c.DICTISETGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTISETGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62574, 16, val);
    },
};
export const DICTUSETGETOPTREF: $.Type<c.DICTUSETGETOPTREF> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUSETGETOPTREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62575, 16, val);
    },
};
export const SUBDICTGET: $.Type<c.SUBDICTGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62641, 16, val);
    },
};
export const SUBDICTIGET: $.Type<c.SUBDICTIGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTIGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62642, 16, val);
    },
};
export const SUBDICTUGET: $.Type<c.SUBDICTUGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTUGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62643, 16, val);
    },
};
export const SUBDICTRPGET: $.Type<c.SUBDICTRPGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTRPGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62645, 16, val);
    },
};
export const SUBDICTIRPGET: $.Type<c.SUBDICTIRPGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTIRPGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62646, 16, val);
    },
};
export const SUBDICTURPGET: $.Type<c.SUBDICTURPGET> = {
    load: (s) => {
        s.skip(16);
        return c.SUBDICTURPGET();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62647, 16, val);
    },
};
export const THROWANY: $.Type<c.THROWANY> = {
    load: (s) => {
        s.skip(16);
        return c.THROWANY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62192, 16, val);
    },
};
export const THROWARGANY: $.Type<c.THROWARGANY> = {
    load: (s) => {
        s.skip(16);
        return c.THROWARGANY();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62193, 16, val);
    },
};
export const THROWANYIFNOT: $.Type<c.THROWANYIFNOT> = {
    load: (s) => {
        s.skip(16);
        return c.THROWANYIFNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62196, 16, val);
    },
};
export const THROWARGANYIFNOT: $.Type<c.THROWARGANYIFNOT> = {
    load: (s) => {
        s.skip(16);
        return c.THROWARGANYIFNOT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62197, 16, val);
    },
};
export const DICTGETNEXT: $.Type<c.DICTGETNEXT> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETNEXT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62580, 16, val);
    },
};
export const DICTGETNEXTEQ: $.Type<c.DICTGETNEXTEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETNEXTEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62581, 16, val);
    },
};
export const DICTGETPREV: $.Type<c.DICTGETPREV> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETPREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62582, 16, val);
    },
};
export const DICTGETPREVEQ: $.Type<c.DICTGETPREVEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTGETPREVEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62583, 16, val);
    },
};
export const DICTIGETNEXT: $.Type<c.DICTIGETNEXT> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETNEXT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62584, 16, val);
    },
};
export const DICTIGETNEXTEQ: $.Type<c.DICTIGETNEXTEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETNEXTEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62585, 16, val);
    },
};
export const DICTIGETPREV: $.Type<c.DICTIGETPREV> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETPREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62586, 16, val);
    },
};
export const DICTIGETPREVEQ: $.Type<c.DICTIGETPREVEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTIGETPREVEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62587, 16, val);
    },
};
export const DICTUGETNEXT: $.Type<c.DICTUGETNEXT> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETNEXT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62588, 16, val);
    },
};
export const DICTUGETNEXTEQ: $.Type<c.DICTUGETNEXTEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETNEXTEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62589, 16, val);
    },
};
export const DICTUGETPREV: $.Type<c.DICTUGETPREV> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETPREV();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62590, 16, val);
    },
};
export const DICTUGETPREVEQ: $.Type<c.DICTUGETPREVEQ> = {
    load: (s) => {
        s.skip(16);
        return c.DICTUGETPREVEQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62591, 16, val);
    },
};
export const ADDINT: $.Type<c.ADDINT> = {
    load: (s) => {
        s.skip(8);
        return c.ADDINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(166, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const MULINT: $.Type<c.MULINT> = {
    load: (s) => {
        s.skip(8);
        return c.MULINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(167, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QADDINT: $.Type<c.QADDINT> = {
    load: (s) => {
        s.skip(16);
        return c.QADDINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47014, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QMULINT: $.Type<c.QMULINT> = {
    load: (s) => {
        s.skip(16);
        return c.QMULINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47015, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const EQINT: $.Type<c.EQINT> = {
    load: (s) => {
        s.skip(8);
        return c.EQINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(192, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const LESSINT: $.Type<c.LESSINT> = {
    load: (s) => {
        s.skip(8);
        return c.LESSINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(193, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const GTINT: $.Type<c.GTINT> = {
    load: (s) => {
        s.skip(8);
        return c.GTINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(194, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const NEQINT: $.Type<c.NEQINT> = {
    load: (s) => {
        s.skip(8);
        return c.NEQINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(195, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QEQINT: $.Type<c.QEQINT> = {
    load: (s) => {
        s.skip(16);
        return c.QEQINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47040, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QLESSINT: $.Type<c.QLESSINT> = {
    load: (s) => {
        s.skip(16);
        return c.QLESSINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47041, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QGTINT: $.Type<c.QGTINT> = {
    load: (s) => {
        s.skip(16);
        return c.QGTINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47042, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const QNEQINT: $.Type<c.QNEQINT> = {
    load: (s) => {
        s.skip(16);
        return c.QNEQINT($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47043, 16, val);
        $.int(8).store(b, val.arg0);
    },
};
export const PUSHPOW2DEC: $.Type<c.PUSHPOW2DEC> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHPOW2DEC($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(132, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PUSHNEGPOW2: $.Type<c.PUSHNEGPOW2> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHNEGPOW2($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(133, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const FITS: $.Type<c.FITS> = {
    load: (s) => {
        s.skip(8);
        return c.FITS($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(180, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const UFITS: $.Type<c.UFITS> = {
    load: (s) => {
        s.skip(8);
        return c.UFITS($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(181, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const QFITS: $.Type<c.QFITS> = {
    load: (s) => {
        s.skip(16);
        return c.QFITS($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47028, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const QUFITS: $.Type<c.QUFITS> = {
    load: (s) => {
        s.skip(16);
        return c.QUFITS($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47029, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const SETCONTCTRMANY: $.Type<c.SETCONTCTRMANY> = {
    load: (s) => {
        s.skip(16);
        return c.SETCONTCTRMANY($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60899, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const CALLCCARGS: $.Type<c.CALLCCARGS> = {
    load: (s) => {
        s.skip(16);
        return c.CALLCCARGS($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56118, 16, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const TRYARGS: $.Type<c.TRYARGS> = {
    load: (s) => {
        s.skip(8);
        return c.TRYARGS($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(243, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const PLDREFIDX: $.Type<c.PLDREFIDX> = {
    load: (s) => {
        s.skip(14);
        return c.PLDREFIDX($.uint(2).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(13779, 14, val);
        $.uint(2).store(b, val.arg0);
    },
};
export const CHASHI: $.Type<c.CHASHI> = {
    load: (s) => {
        s.skip(14);
        return c.CHASHI($.uint(2).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(13786, 14, val);
        $.uint(2).store(b, val.arg0);
    },
};
export const CDEPTHI: $.Type<c.CDEPTHI> = {
    load: (s) => {
        s.skip(14);
        return c.CDEPTHI($.uint(2).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(13787, 14, val);
        $.uint(2).store(b, val.arg0);
    },
};
export const JMPDICT: $.Type<c.JMPDICT> = {
    load: (s) => {
        s.skip(10);
        return c.JMPDICT($.uint(14).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(965, 10, val);
        $.uint(14).store(b, val.arg0);
    },
};
export const PREPAREDICT: $.Type<c.PREPAREDICT> = {
    load: (s) => {
        s.skip(10);
        return c.PREPAREDICT($.uint(14).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(966, 10, val);
        $.uint(14).store(b, val.arg0);
    },
};
export const THROWARG: $.Type<c.THROWARG> = {
    load: (s) => {
        s.skip(13);
        return c.THROWARG($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7769, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const THROWARGIF: $.Type<c.THROWARGIF> = {
    load: (s) => {
        s.skip(13);
        return c.THROWARGIF($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7771, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const THROWARGIFNOT: $.Type<c.THROWARGIFNOT> = {
    load: (s) => {
        s.skip(13);
        return c.THROWARGIFNOT($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7773, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const JMPXARGS: $.Type<c.JMPXARGS> = {
    load: (s) => {
        s.skip(12);
        return c.JMPXARGS($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(3505, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const RETARGS: $.Type<c.RETARGS> = {
    load: (s) => {
        s.skip(12);
        return c.RETARGS($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(3506, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const RETURNARGS: $.Type<c.RETURNARGS> = {
    load: (s) => {
        s.skip(12);
        return c.RETURNARGS($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(3792, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const BLKDROP: $.Type<c.BLKDROP> = {
    load: (s) => {
        s.skip(12);
        return c.BLKDROP($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1520, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const TUPLE: $.Type<c.TUPLE> = {
    load: (s) => {
        s.skip(12);
        return c.TUPLE($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1776, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const INDEX: $.Type<c.INDEX> = {
    load: (s) => {
        s.skip(12);
        return c.INDEX($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1777, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const UNTUPLE: $.Type<c.UNTUPLE> = {
    load: (s) => {
        s.skip(12);
        return c.UNTUPLE($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1778, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const UNPACKFIRST: $.Type<c.UNPACKFIRST> = {
    load: (s) => {
        s.skip(12);
        return c.UNPACKFIRST($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1779, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const EXPLODE: $.Type<c.EXPLODE> = {
    load: (s) => {
        s.skip(12);
        return c.EXPLODE($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1780, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const SETINDEX: $.Type<c.SETINDEX> = {
    load: (s) => {
        s.skip(12);
        return c.SETINDEX($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1781, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const INDEXQ: $.Type<c.INDEXQ> = {
    load: (s) => {
        s.skip(12);
        return c.INDEXQ($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1782, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const SETINDEXQ: $.Type<c.SETINDEXQ> = {
    load: (s) => {
        s.skip(12);
        return c.SETINDEXQ($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1783, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const XC2PU: $.Type<c.XC2PU> = {
    load: (s) => {
        s.skip(12);
        return c.XC2PU($.uint(4).load(s), $.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1345, 12, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.uint(4).store(b, val.arg2);
    },
};
export const XCPU2: $.Type<c.XCPU2> = {
    load: (s) => {
        s.skip(12);
        return c.XCPU2($.uint(4).load(s), $.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1347, 12, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.uint(4).store(b, val.arg2);
    },
};
export const PUSH3: $.Type<c.PUSH3> = {
    load: (s) => {
        s.skip(12);
        return c.PUSH3($.uint(4).load(s), $.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1351, 12, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.uint(4).store(b, val.arg2);
    },
};
export const XCHG2: $.Type<c.XCHG2> = {
    load: (s) => {
        s.skip(8);
        return c.XCHG2($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(80, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const XCPU: $.Type<c.XCPU> = {
    load: (s) => {
        s.skip(8);
        return c.XCPU($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(81, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const PUSH2: $.Type<c.PUSH2> = {
    load: (s) => {
        s.skip(8);
        return c.PUSH2($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(83, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const PUXC: $.Type<c.PUXC> = {
    load: (s) => {
        s.skip(8);
        return c.PUXC($.uint(4).load(s), $.delta(-1, $.uint(4)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(82, 8, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
    },
};
export const XCPUXC: $.Type<c.XCPUXC> = {
    load: (s) => {
        s.skip(12);
        return c.XCPUXC(
            $.uint(4).load(s),
            $.uint(4).load(s),
            $.delta(-1, $.uint(4)).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1346, 12, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.delta(-1, $.uint(4)).store(b, val.arg2);
    },
};
export const PUXC2: $.Type<c.PUXC2> = {
    load: (s) => {
        s.skip(12);
        return c.PUXC2(
            $.uint(4).load(s),
            $.delta(-1, $.uint(4)).load(s),
            $.delta(-1, $.uint(4)).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1348, 12, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
        $.delta(-1, $.uint(4)).store(b, val.arg2);
    },
};
export const PUXCPU: $.Type<c.PUXCPU> = {
    load: (s) => {
        s.skip(12);
        return c.PUXCPU(
            $.uint(4).load(s),
            $.delta(-1, $.uint(4)).load(s),
            $.delta(-1, $.uint(4)).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1349, 12, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
        $.delta(-1, $.uint(4)).store(b, val.arg2);
    },
};
export const PU2XC: $.Type<c.PU2XC> = {
    load: (s) => {
        s.skip(12);
        return c.PU2XC(
            $.uint(4).load(s),
            $.delta(-1, $.uint(4)).load(s),
            $.delta(-2, $.uint(4)).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1350, 12, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
        $.delta(-2, $.uint(4)).store(b, val.arg2);
    },
};
export const BLKSWAP: $.Type<c.BLKSWAP> = {
    load: (s) => {
        s.skip(8);
        return c.BLKSWAP(
            $.delta(1, $.uint(4)).load(s),
            $.delta(1, $.uint(4)).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(85, 8, val);
        $.delta(1, $.uint(4)).store(b, val.arg0);
        $.delta(1, $.uint(4)).store(b, val.arg1);
    },
};
export const REVERSE: $.Type<c.REVERSE> = {
    load: (s) => {
        s.skip(8);
        return c.REVERSE($.delta(2, $.uint(4)).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(94, 8, val);
        $.delta(2, $.uint(4)).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const SETCONTARGS: $.Type<c.SETCONTARGS> = {
    load: (s) => {
        s.skip(8);
        return c.SETCONTARGS($.uint(4).load(s), $.delta(-1, $.uint(4)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(236, 8, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
    },
};
export const BLESSARGS: $.Type<c.BLESSARGS> = {
    load: (s) => {
        s.skip(8);
        return c.BLESSARGS($.uint(4).load(s), $.delta(-1, $.uint(4)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(238, 8, val);
        $.uint(4).store(b, val.arg0);
        $.delta(-1, $.uint(4)).store(b, val.arg1);
    },
};
export const STIR: $.Type<c.STIR> = {
    load: (s) => {
        s.skip(16);
        return c.STIR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53002, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STUR: $.Type<c.STUR> = {
    load: (s) => {
        s.skip(16);
        return c.STUR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53003, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STIQ: $.Type<c.STIQ> = {
    load: (s) => {
        s.skip(16);
        return c.STIQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53004, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STUQ: $.Type<c.STUQ> = {
    load: (s) => {
        s.skip(16);
        return c.STUQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53005, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STIRQ: $.Type<c.STIRQ> = {
    load: (s) => {
        s.skip(16);
        return c.STIRQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53006, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STURQ: $.Type<c.STURQ> = {
    load: (s) => {
        s.skip(16);
        return c.STURQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53007, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDI: $.Type<c.PLDI> = {
    load: (s) => {
        s.skip(16);
        return c.PLDI($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55050, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDU: $.Type<c.PLDU> = {
    load: (s) => {
        s.skip(16);
        return c.PLDU($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55051, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDIQ: $.Type<c.LDIQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDIQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55052, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDUQ: $.Type<c.LDUQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDUQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55053, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDIQ: $.Type<c.PLDIQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDIQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55054, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDUQ: $.Type<c.PLDUQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDUQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55055, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDUZ: $.Type<c.PLDUZ> = {
    load: (s) => {
        s.skip(13);
        return c.PLDUZ($.plduzArg.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(6882, 13, val);
        $.plduzArg.store(b, val.arg0);
    },
};
export const PLDSLICE: $.Type<c.PLDSLICE> = {
    load: (s) => {
        s.skip(16);
        return c.PLDSLICE($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55069, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDSLICEQ: $.Type<c.LDSLICEQ> = {
    load: (s) => {
        s.skip(16);
        return c.LDSLICEQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55070, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const PLDSLICEQ: $.Type<c.PLDSLICEQ> = {
    load: (s) => {
        s.skip(16);
        return c.PLDSLICEQ($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55071, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const IFBITJMP: $.Type<c.IFBITJMP> = {
    load: (s) => {
        s.skip(11);
        return c.IFBITJMP($.uint(5).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1820, 11, val);
        $.uint(5).store(b, val.arg0);
    },
};
export const IFNBITJMP: $.Type<c.IFNBITJMP> = {
    load: (s) => {
        s.skip(11);
        return c.IFNBITJMP($.uint(5).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1821, 11, val);
        $.uint(5).store(b, val.arg0);
    },
};
export const INDEX2: $.Type<c.INDEX2> = {
    load: (s) => {
        s.skip(12);
        return c.INDEX2($.uint(2).load(s), $.uint(2).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1787, 12, val);
        $.uint(2).store(b, val.arg0);
        $.uint(2).store(b, val.arg1);
    },
};
export const INDEX3: $.Type<c.INDEX3> = {
    load: (s) => {
        s.skip(10);
        return c.INDEX3(
            $.uint(2).load(s),
            $.uint(2).load(s),
            $.uint(2).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(447, 10, val);
        $.uint(2).store(b, val.arg0);
        $.uint(2).store(b, val.arg1);
        $.uint(2).store(b, val.arg2);
    },
};
export const PUSHPOW2: $.Type<c.PUSHPOW2> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHPOW2($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(33536 >> 8, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const BLKPUSH: $.Type<c.BLKPUSH> = {
    load: (s) => {
        s.skip(8);
        return c.BLKPUSH($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(24336 >> 8, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const BLKDROP2: $.Type<c.BLKDROP2> = {
    load: (s) => {
        s.skip(8);
        return c.BLKDROP2($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(27664 >> 8, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const GETGLOB: $.Type<c.GETGLOB> = {
    load: (s) => {
        s.skip(11);
        return c.GETGLOB($.uint(5).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63553 >> 5, 11, val);
        $.uint(5).store(b, val.arg0);
    },
};
export const SETGLOB: $.Type<c.SETGLOB> = {
    load: (s) => {
        s.skip(11);
        return c.SETGLOB($.uint(5).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63585 >> 5, 11, val);
        $.uint(5).store(b, val.arg0);
    },
};
export const GETPARAM: $.Type<c.GETPARAM> = {
    load: (s) => {
        s.skip(12);
        return c.GETPARAM($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63520 >> 4, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const PUSHREF: $.Type<c.PUSHREF> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(136, 8, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const PUSHREFSLICE: $.Type<c.PUSHREFSLICE> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHREFSLICE($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(137, 8, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const PUSHREFCONT: $.Type<c.PUSHREFCONT> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHREFCONT($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(138, 8, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const CALLREF: $.Type<c.CALLREF> = {
    load: (s) => {
        s.skip(16);
        return c.CALLREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56124, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const JMPREF: $.Type<c.JMPREF> = {
    load: (s) => {
        s.skip(16);
        return c.JMPREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56125, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const JMPREFDATA: $.Type<c.JMPREFDATA> = {
    load: (s) => {
        s.skip(16);
        return c.JMPREFDATA($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(56126, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFREF: $.Type<c.IFREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58112, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFNOTREF: $.Type<c.IFNOTREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFNOTREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58113, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFJMPREF: $.Type<c.IFJMPREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFJMPREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58114, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFNOTJMPREF: $.Type<c.IFNOTJMPREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFNOTJMPREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58115, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFREFELSE: $.Type<c.IFREFELSE> = {
    load: (s) => {
        s.skip(16);
        return c.IFREFELSE($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58125, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFELSEREF: $.Type<c.IFELSEREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFELSEREF($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58126, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const IFREFELSEREF: $.Type<c.IFREFELSEREF> = {
    load: (s) => {
        s.skip(16);
        return c.IFREFELSEREF($.refCodeSlice.load(s), $.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(58127, 16, val);
        $.refCodeSlice.store(b, val.arg0);
        $.refCodeSlice.store(b, val.arg1);
    },
};
export const IFBITJMPREF: $.Type<c.IFBITJMPREF> = {
    load: (s) => {
        s.skip(11);
        return c.IFBITJMPREF($.uint(5).load(s), $.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1822, 11, val);
        $.uint(5).store(b, val.arg0);
        $.refCodeSlice.store(b, val.arg1);
    },
};
export const IFNBITJMPREF: $.Type<c.IFNBITJMPREF> = {
    load: (s) => {
        s.skip(11);
        return c.IFNBITJMPREF($.uint(5).load(s), $.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1823, 11, val);
        $.uint(5).store(b, val.arg0);
        $.refCodeSlice.store(b, val.arg1);
    },
};
export const DICTPUSHCONST: $.Type<c.DICTPUSHCONST> = {
    load: (s) => {
        s.skip(14);
        return c.DICTPUSHCONST(...$.dictpush.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(15657, 14, val);
        $.dictpush.store(b, [val.arg0, val.arg1]);
    },
};
export const PFXDICTSWITCH: $.Type<c.PFXDICTSWITCH> = {
    load: (s) => {
        s.skip(14);
        return c.PFXDICTSWITCH(...$.dictpush.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(15659, 14, val);
        $.dictpush.store(b, [val.arg0, val.arg1]);
    },
};
export const SDBEGINSX: $.Type<c.SDBEGINSX> = {
    load: (s) => {
        s.skip(16);
        return c.SDBEGINSX();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55078, 16, val);
    },
};
export const SDBEGINSXQ: $.Type<c.SDBEGINSXQ> = {
    load: (s) => {
        s.skip(16);
        return c.SDBEGINSXQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55079, 16, val);
    },
};
export const SDBEGINS: $.Type<c.SDBEGINS> = {
    load: (s) => {
        s.skip(14);
        return c.SDBEGINS($.slice($.refs(0), $.uint(7), 3).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(13770, 14, val);
        $.slice($.refs(0), $.uint(7), 3).store(b, val.arg0);
    },
};
export const SDBEGINSQ: $.Type<c.SDBEGINSQ> = {
    load: (s) => {
        s.skip(14);
        return c.SDBEGINSQ($.slice($.refs(0), $.uint(7), 3).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(13771, 14, val);
        $.slice($.refs(0), $.uint(7), 3).store(b, val.arg0);
    },
};
export const STREFCONST: $.Type<c.STREFCONST> = {
    load: (s) => {
        s.skip(16);
        return c.STREFCONST($.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53024 >> 0, 16, val);
        $.refCodeSlice.store(b, val.arg0);
    },
};
export const STREF2CONST: $.Type<c.STREF2CONST> = {
    load: (s) => {
        s.skip(16);
        return c.STREF2CONST($.refCodeSlice.load(s), $.refCodeSlice.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53025 >> 0, 16, val);
        $.refCodeSlice.store(b, val.arg0);
        $.refCodeSlice.store(b, val.arg1);
    },
};
export const THROWANYIF: $.Type<c.THROWANYIF> = {
    load: (s) => {
        s.skip(16);
        return c.THROWANYIF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62194, 16, val);
    },
};
export const THROWARGANYIF: $.Type<c.THROWARGANYIF> = {
    load: (s) => {
        s.skip(16);
        return c.THROWARGANYIF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(62195, 16, val);
    },
};
export const DEBUGSTR: $.Type<c.DEBUGSTR> = {
    load: (s) => {
        s.skip(12);
        return c.DEBUGSTR($.debugstr.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(4079, 12, val);
        $.debugstr.store(b, val.arg0);
    },
};
export const SETCONTCTR: $.Type<c.SETCONTCTR> = {
    load: (s) => {
        s.skip(12);
        return c.SETCONTCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60768 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const SETRETCTR: $.Type<c.SETRETCTR> = {
    load: (s) => {
        s.skip(12);
        return c.SETRETCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60784 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const SETALTCTR: $.Type<c.SETALTCTR> = {
    load: (s) => {
        s.skip(12);
        return c.SETALTCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60800 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const POPSAVE: $.Type<c.POPSAVE> = {
    load: (s) => {
        s.skip(12);
        return c.POPSAVE($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60816 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const SAVECTR: $.Type<c.SAVECTR> = {
    load: (s) => {
        s.skip(12);
        return c.SAVECTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60832 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const SAVEALTCTR: $.Type<c.SAVEALTCTR> = {
    load: (s) => {
        s.skip(12);
        return c.SAVEALTCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60848 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const SAVEBOTHCTR: $.Type<c.SAVEBOTHCTR> = {
    load: (s) => {
        s.skip(12);
        return c.SAVEBOTHCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60864 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const RUNVM: $.Type<c.RUNVM> = {
    load: (s) => {
        s.skip(12);
        return c.RUNVM($.runvmArg.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(3508, 12, val);
        $.runvmArg.store(b, val.arg0);
    },
};
export const SWAP2: $.Type<c.SWAP2> = {
    load: (s) => {
        s.skip(8);
        return c.SWAP2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(90, 8, val);
    },
};
export const DROP2: $.Type<c.DROP2> = {
    load: (s) => {
        s.skip(8);
        return c.DROP2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(91, 8, val);
    },
};
export const DUP2: $.Type<c.DUP2> = {
    load: (s) => {
        s.skip(8);
        return c.DUP2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(92, 8, val);
    },
};
export const OVER2: $.Type<c.OVER2> = {
    load: (s) => {
        s.skip(8);
        return c.OVER2();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(93, 8, val);
    },
};
export const ADDRSHIFT_MOD: $.Type<c.ADDRSHIFT_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFT_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43312, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const ADDRSHIFTR_MOD: $.Type<c.ADDRSHIFTR_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFTR_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43313, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const ADDRSHIFTC_MOD: $.Type<c.ADDRSHIFTC_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.ADDRSHIFTC_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43314, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFT_: $.Type<c.RSHIFT_> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFT_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43316, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFTR_: $.Type<c.RSHIFTR_> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTR_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43317, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFTC_: $.Type<c.RSHIFTC_> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTC_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43318, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MODPOW2_: $.Type<c.MODPOW2_> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43320, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MODPOW2R_: $.Type<c.MODPOW2R_> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2R_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43321, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MODPOW2C_: $.Type<c.MODPOW2C_> = {
    load: (s) => {
        s.skip(16);
        return c.MODPOW2C_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43322, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFT_MOD: $.Type<c.RSHIFT_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFT_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43324, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFTR_MOD: $.Type<c.RSHIFTR_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTR_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43325, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFTC_MOD: $.Type<c.RSHIFTC_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFTC_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43326, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULADDRSHIFT_MOD: $.Type<c.MULADDRSHIFT_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFT_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43440, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULADDRSHIFTR_MOD: $.Type<c.MULADDRSHIFTR_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFTR_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43441, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULADDRSHIFTC_MOD: $.Type<c.MULADDRSHIFTC_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULADDRSHIFTC_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43442, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFT_: $.Type<c.MULRSHIFT_> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFT_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43444, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFTR_: $.Type<c.MULRSHIFTR_> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTR_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43445, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFTC_: $.Type<c.MULRSHIFTC_> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTC_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43446, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULMODPOW2_: $.Type<c.MULMODPOW2_> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43448, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULMODPOW2R_: $.Type<c.MULMODPOW2R_> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2R_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43449, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULMODPOW2C_: $.Type<c.MULMODPOW2C_> = {
    load: (s) => {
        s.skip(16);
        return c.MULMODPOW2C_($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43450, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFT_MOD: $.Type<c.MULRSHIFT_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFT_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43452, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFTR_MOD: $.Type<c.MULRSHIFTR_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTR_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43453, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const MULRSHIFTC_MOD: $.Type<c.MULRSHIFTC_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.MULRSHIFTC_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43454, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_ADDDIVMOD: $.Type<c.LSHIFT_ADDDIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_ADDDIVMOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43472, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_ADDDIVMODR: $.Type<c.LSHIFT_ADDDIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_ADDDIVMODR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43473, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_ADDDIVMODC: $.Type<c.LSHIFT_ADDDIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_ADDDIVMODC($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43474, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIV: $.Type<c.LSHIFT_DIV> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIV($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43476, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIVR: $.Type<c.LSHIFT_DIVR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIVR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43477, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIVC: $.Type<c.LSHIFT_DIVC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIVC($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43478, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_MOD: $.Type<c.LSHIFT_MOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_MOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43480, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_MODR: $.Type<c.LSHIFT_MODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_MODR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43481, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_MODC: $.Type<c.LSHIFT_MODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_MODC($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43482, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIVMOD: $.Type<c.LSHIFT_DIVMOD> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIVMOD($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43484, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIVMODR: $.Type<c.LSHIFT_DIVMODR> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIVMODR($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43485, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT_DIVMODC: $.Type<c.LSHIFT_DIVMODC> = {
    load: (s) => {
        s.skip(16);
        return c.LSHIFT_DIVMODC($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43486, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const HASHEXT: $.Type<c.HASHEXT> = {
    load: (s) => {
        s.skip(16);
        return c.HASHEXT($.hash.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63748, 16, val);
        $.hash.store(b, val.arg0);
    },
};
export const HASHEXTR: $.Type<c.HASHEXTR> = {
    load: (s) => {
        s.skip(16);
        return c.HASHEXTR($.hash.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63749, 16, val);
        $.hash.store(b, val.arg0);
    },
};
export const HASHEXTA: $.Type<c.HASHEXTA> = {
    load: (s) => {
        s.skip(16);
        return c.HASHEXTA($.hash.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63750, 16, val);
        $.hash.store(b, val.arg0);
    },
};
export const HASHEXTAR: $.Type<c.HASHEXTAR> = {
    load: (s) => {
        s.skip(16);
        return c.HASHEXTAR($.hash.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(63751, 16, val);
        $.hash.store(b, val.arg0);
    },
};
export const STREF: $.Type<c.STREF> = {
    load: (s) => {
        s.skip(8);
        return c.STREF();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(204, 8, val);
    },
};
export const STREF_ALT: $.Type<c.STREF_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.STREF_ALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53008, 16, val);
    },
};
export const STSLICE: $.Type<c.STSLICE> = {
    load: (s) => {
        s.skip(8);
        return c.STSLICE();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(206, 8, val);
    },
};
export const STSLICE_ALT: $.Type<c.STSLICE_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.STSLICE_ALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53010, 16, val);
    },
};
export const XCHG3: $.Type<c.XCHG3> = {
    load: (s) => {
        s.skip(4);
        return c.XCHG3($.uint(4).load(s), $.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(4, 4, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.uint(4).store(b, val.arg2);
    },
};
export const XCHG3_ALT: $.Type<c.XCHG3_ALT> = {
    load: (s) => {
        s.skip(12);
        return c.XCHG3_ALT(
            $.uint(4).load(s),
            $.uint(4).load(s),
            $.uint(4).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(1344, 12, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
        $.uint(4).store(b, val.arg2);
    },
};
export const STI: $.Type<c.STI> = {
    load: (s) => {
        s.skip(8);
        return c.STI($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(202, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STI_ALT: $.Type<c.STI_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.STI_ALT($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53000, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STU: $.Type<c.STU> = {
    load: (s) => {
        s.skip(8);
        return c.STU($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(203, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const STU_ALT: $.Type<c.STU_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.STU_ALT($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53001, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDI: $.Type<c.LDI> = {
    load: (s) => {
        s.skip(8);
        return c.LDI($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(210, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDI_ALT: $.Type<c.LDI_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.LDI_ALT($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55048, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDU: $.Type<c.LDU> = {
    load: (s) => {
        s.skip(8);
        return c.LDU($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(211, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDU_ALT: $.Type<c.LDU_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.LDU_ALT($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55049, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDSLICE: $.Type<c.LDSLICE> = {
    load: (s) => {
        s.skip(8);
        return c.LDSLICE($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(214, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LDSLICE_ALT: $.Type<c.LDSLICE_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.LDSLICE_ALT($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(55068, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const LSHIFT: $.Type<c.LSHIFT> = {
    load: (s) => {
        s.skip(8);
        return c.LSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(172, 8, val);
    },
};
export const LSHIFT_1: $.Type<c.LSHIFT_1> = {
    load: (s) => {
        s.skip(8);
        return c.LSHIFT_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(170, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const QLSHIFT: $.Type<c.QLSHIFT> = {
    load: (s) => {
        s.skip(16);
        return c.QLSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47020, 16, val);
    },
};
export const QLSHIFT_1: $.Type<c.QLSHIFT_1> = {
    load: (s) => {
        s.skip(16);
        return c.QLSHIFT_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47018, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const BCHKBITS: $.Type<c.BCHKBITS> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITS();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53049, 16, val);
    },
};
export const BCHKBITS_1: $.Type<c.BCHKBITS_1> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITS_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53048, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const BCHKBITSQ: $.Type<c.BCHKBITSQ> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITSQ();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53053, 16, val);
    },
};
export const BCHKBITSQ_1: $.Type<c.BCHKBITSQ_1> = {
    load: (s) => {
        s.skip(16);
        return c.BCHKBITSQ_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(53052, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFT: $.Type<c.RSHIFT> = {
    load: (s) => {
        s.skip(8);
        return c.RSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(173, 8, val);
    },
};
export const RSHIFT_1: $.Type<c.RSHIFT_1> = {
    load: (s) => {
        s.skip(8);
        return c.RSHIFT_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(171, 8, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const RSHIFT_ALT: $.Type<c.RSHIFT_ALT> = {
    load: (s) => {
        s.skip(16);
        return c.RSHIFT_ALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(43300, 16, val);
    },
};
export const QRSHIFT: $.Type<c.QRSHIFT> = {
    load: (s) => {
        s.skip(16);
        return c.QRSHIFT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47021, 16, val);
    },
};
export const QRSHIFT_1: $.Type<c.QRSHIFT_1> = {
    load: (s) => {
        s.skip(16);
        return c.QRSHIFT_1($.delta(1, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(47019, 16, val);
        $.delta(1, $.uint(8)).store(b, val.arg0);
    },
};
export const QRSHIFT_ALT: $.Type<c.QRSHIFT_ALT> = {
    load: (s) => {
        s.skip(24);
        return c.QRSHIFT_ALT();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(12036388, 24, val);
    },
};
export const CALLDICT: $.Type<c.CALLDICT> = {
    load: (s) => {
        s.skip(8);
        return c.CALLDICT($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(240, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const CALLDICT_LONG: $.Type<c.CALLDICT_LONG> = {
    load: (s) => {
        s.skip(10);
        return c.CALLDICT_LONG($.uint(14).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(964, 10, val);
        $.uint(14).store(b, val.arg0);
    },
};
export const THROW_SHORT: $.Type<c.THROW_SHORT> = {
    load: (s) => {
        s.skip(10);
        return c.THROW_SHORT($.uint(6).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(968, 10, val);
        $.uint(6).store(b, val.arg0);
    },
};
export const THROW: $.Type<c.THROW> = {
    load: (s) => {
        s.skip(13);
        return c.THROW($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7768, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const THROWIF_SHORT: $.Type<c.THROWIF_SHORT> = {
    load: (s) => {
        s.skip(10);
        return c.THROWIF_SHORT($.uint(6).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(969, 10, val);
        $.uint(6).store(b, val.arg0);
    },
};
export const THROWIF: $.Type<c.THROWIF> = {
    load: (s) => {
        s.skip(13);
        return c.THROWIF($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7770, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const THROWIFNOT_SHORT: $.Type<c.THROWIFNOT_SHORT> = {
    load: (s) => {
        s.skip(10);
        return c.THROWIFNOT_SHORT($.uint(6).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(970, 10, val);
        $.uint(6).store(b, val.arg0);
    },
};
export const THROWIFNOT: $.Type<c.THROWIFNOT> = {
    load: (s) => {
        s.skip(13);
        return c.THROWIFNOT($.uint(11).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7772, 13, val);
        $.uint(11).store(b, val.arg0);
    },
};
export const PUSHINT: $.Type<c.PUSHINT> = {
    load: (s) => {
        s.skip(4);
        return c.PUSHINT($.tinyInt.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(7, 4, val);
        $.tinyInt.store(b, val.arg0);
    },
};
export const PUSHINT_8: $.Type<c.PUSHINT_8> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHINT_8($.int(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(128, 8, val);
        $.int(8).store(b, val.arg0);
    },
};
export const PUSHINT_16: $.Type<c.PUSHINT_16> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHINT_16($.int(16).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(129, 8, val);
        $.int(16).store(b, val.arg0);
    },
};
export const PUSHINT_LONG: $.Type<c.PUSHINT_LONG> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHINT_LONG($.largeInt.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(4160 >> 5, 8, val);
        $.largeInt.store(b, val.arg0);
    },
};
export const XCHG_LONG: $.Type<c.XCHG_LONG> = {
    load: (s) => {
        s.skip(8);
        return c.XCHG_LONG($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(17, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const XCHG_0: $.Type<c.XCHG_0> = {
    load: (s) => {
        s.skip(4);
        return c.XCHG_0($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(2 >> 4, 4, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const XCHG_1: $.Type<c.XCHG_1> = {
    load: (s) => {
        s.skip(8);
        return c.XCHG_1($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(16, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const XCHG_3: $.Type<c.XCHG_3> = {
    load: (s) => {
        s.skip(4);
        return c.XCHG_3($.s1.load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(18 >> 4, 4, val);
        $.s1.store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const DUMPSTK: $.Type<c.DUMPSTK> = {
    load: (s) => {
        s.skip(16);
        return c.DUMPSTK();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65024, 16, val);
    },
};
export const DEBUG: $.Type<c.DEBUG> = {
    load: (s) => {
        s.skip(8);
        return c.DEBUG($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65025 >> 8, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const STRDUMP: $.Type<c.STRDUMP> = {
    load: (s) => {
        s.skip(16);
        return c.STRDUMP();
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65044, 16, val);
    },
};
export const DEBUG_1: $.Type<c.DEBUG_1> = {
    load: (s) => {
        s.skip(8);
        return c.DEBUG_1($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65045 >> 8, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const DUMP: $.Type<c.DUMP> = {
    load: (s) => {
        s.skip(12);
        return c.DUMP($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(4066, 12, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const DEBUG_2: $.Type<c.DEBUG_2> = {
    load: (s) => {
        s.skip(8);
        return c.DEBUG_2($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65072 >> 8, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const PUSHCTR: $.Type<c.PUSHCTR> = {
    load: (s) => {
        s.skip(12);
        return c.PUSHCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60736 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const PUSH: $.Type<c.PUSH> = {
    load: (s) => {
        s.skip(4);
        return c.PUSH($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(34 >> 4, 4, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const PUSH_LONG: $.Type<c.PUSH_LONG> = {
    load: (s) => {
        s.skip(8);
        return c.PUSH_LONG($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(86, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const POPCTR: $.Type<c.POPCTR> = {
    load: (s) => {
        s.skip(12);
        return c.POPCTR($.control.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(60752 >> 4, 12, val);
        $.control.store(b, val.arg0);
    },
};
export const POP: $.Type<c.POP> = {
    load: (s) => {
        s.skip(4);
        return c.POP($.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(50 >> 4, 4, val);
        $.uint(4).store(b, val.arg0);
    },
};
export const POP_LONG: $.Type<c.POP_LONG> = {
    load: (s) => {
        s.skip(8);
        return c.POP_LONG($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(87, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const CALLXARGS: $.Type<c.CALLXARGS> = {
    load: (s) => {
        s.skip(12);
        return c.CALLXARGS($.uint(4).load(s), $.minusOne.load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(3504, 12, val);
        $.uint(4).store(b, val.arg0);
        $.minusOne.store(b, val.arg1);
    },
};
export const CALLXARGS_1: $.Type<c.CALLXARGS_1> = {
    load: (s) => {
        s.skip(8);
        return c.CALLXARGS_1($.uint(4).load(s), $.uint(4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(218, 8, val);
        $.uint(4).store(b, val.arg0);
        $.uint(4).store(b, val.arg1);
    },
};
export const PUSHSLICE: $.Type<c.PUSHSLICE> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHSLICE($.slice($.refs(0), $.uint(4), 4).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(139, 8, val);
        $.slice($.refs(0), $.uint(4), 4).store(b, val.arg0);
    },
};
export const PUSHSLICE_REFS_1: $.Type<c.PUSHSLICE_REFS_1> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHSLICE_REFS_1(
            $.slice($.delta(1, $.uint(2)), $.uint(5), 1).load(s),
        );
    },
    store: (b, val) => {
        b.storeInstructionPrefix(140, 8, val);
        $.slice($.delta(1, $.uint(2)), $.uint(5), 1).store(b, val.arg0);
    },
};
export const PUSHSLICE_LONG_1: $.Type<c.PUSHSLICE_LONG_1> = {
    load: (s) => {
        s.skip(8);
        return c.PUSHSLICE_LONG_1($.slice($.uint(3), $.uint(7), 6).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(144384 >> 10, 8, val);
        $.slice($.uint(3), $.uint(7), 6).store(b, val.arg0);
    },
};
export const PUSHCONT: $.Type<c.PUSHCONT> = {
    load: (s) => {
        s.skip(7);
        return c.PUSHCONT($.codeSlice($.uint(2), $.uint(7)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(71, 7, val);
        $.codeSlice($.uint(2), $.uint(7)).store(b, val.arg0);
    },
};
export const PUSHCONT_SHORT: $.Type<c.PUSHCONT_SHORT> = {
    load: (s) => {
        s.skip(4);
        return c.PUSHCONT_SHORT($.inlineCodeSlice($.uint(4)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(9, 4, val);
        $.inlineCodeSlice($.uint(4)).store(b, val.arg0);
    },
};
export const STSLICECONST: $.Type<c.STSLICECONST> = {
    load: (s) => {
        s.skip(9);
        return c.STSLICECONST($.slice($.uint(2), $.uint(3), 2).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(415, 9, val);
        $.slice($.uint(2), $.uint(3), 2).store(b, val.arg0);
    },
};
export const SETCP: $.Type<c.SETCP> = {
    load: (s) => {
        s.skip(8);
        return c.SETCP($.uint(8).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65280 >> 8, 8, val);
        $.uint(8).store(b, val.arg0);
    },
};
export const SETCP_SHORT: $.Type<c.SETCP_SHORT> = {
    load: (s) => {
        s.skip(8);
        return c.SETCP_SHORT($.delta(-256, $.uint(8)).load(s));
    },
    store: (b, val) => {
        b.storeInstructionPrefix(65521 >> 8, 8, val);
        $.delta(-256, $.uint(8)).store(b, val.arg0);
    },
};
export const DEBUGMARK: $.Type<c.DEBUGMARK> = {
    load: (s) => {
        s.skip(16);
        return c.DEBUGMARK($.uint(16).load(s));
    },
    store: (b, val) => {
        b.startDebugSection(val.arg0);
    },
};
