ton-assembly/dist/text/convert.js

TON assembler and disassembler

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ISNAN = exports.CMP = exports.GEQ = exports.NEQ = exports.GREATER = exports.LEQ = exports.EQUAL = exports.LESS = exports.SGN = exports.QABS = exports.QMINMAX = exports.QMAX = exports.QMIN = exports.QUBITSIZE = exports.QBITSIZE = exports.QUFITSX = exports.QFITSX = exports.QNOT = exports.QXOR = exports.QOR = exports.QAND = exports.QPOW2 = exports.QMUL = exports.QDEC = exports.QINC = exports.QNEGATE = exports.QSUBR = exports.QSUB = exports.QADD = exports.ABS = exports.MINMAX = exports.MAX = exports.MIN = exports.UBITSIZE = exports.BITSIZE = exports.UFITSX = exports.FITSX = exports.NOT = exports.XOR = exports.OR = exports.AND = exports.POW2 = exports.MUL = exports.DEC = exports.INC = exports.NEGATE = exports.SUBR = exports.SUB = exports.ADD = exports.PUSHNAN = void 0;
exports.BREMBITS = exports.BBITREFS = exports.BREFS = exports.BBITS = exports.BDEPTH = exports.ENDXC = exports.STBRQ = exports.STSLICERQ = exports.STBREFRQ = exports.STREFRQ = exports.STBQ = exports.STSLICEQ = exports.STBREFQ = exports.STREFQ = exports.STBR = exports.STSLICER = exports.STBREFR = exports.STREFR = exports.STB = exports.STBREF = exports.ENDCST = exports.ENDC = exports.NEWC = exports.SDCNTTRAIL1 = exports.SDCNTTRAIL0 = exports.SDCNTLEAD1 = exports.SDCNTLEAD0 = exports.SDPSFXREV = exports.SDPSFX = exports.SDSFXREV = exports.SDSFX = exports.SDPPFXREV = exports.SDPPFX = exports.SDPFXREV = exports.SDPFX = exports.SDEQ = exports.SDLEXCMP = exports.SDFIRST = exports.SREMPTY = exports.SDEMPTY = exports.SEMPTY = exports.QCMP = exports.QGEQ = exports.QNEQ = exports.QGREATER = exports.QLEQ = exports.QEQUAL = exports.QLESS = exports.QSGN = exports.CHKNAN = void 0;
exports.RET = exports.JMPX = exports.EXECUTE = exports.CDEPTHIX = exports.CHASHIX = exports.CLEVELMASK = exports.CLEVEL = exports.CDEPTH = exports.SDEPTH = exports.LDSAME = exports.LDONES = exports.LDZEROES = exports.SBITREFS = exports.SREFS = exports.SBITS = exports.PLDREFVAR = exports.SCHKBITREFSQ = exports.SCHKREFSQ = exports.SCHKBITSQ = exports.SCHKBITREFS = exports.SCHKREFS = exports.SCHKBITS = exports.XLOADQ = exports.XLOAD = exports.XCTOS = exports.SPLITQ = exports.SPLIT = exports.SUBSLICE = exports.SSKIPLAST = exports.SCUTLAST = exports.SSKIPFIRST = exports.SCUTFIRST = exports.SDSUBSTR = exports.SDSKIPLAST = exports.SDCUTLAST = exports.SDSKIPFIRST = exports.SDCUTFIRST = exports.LDREFRTOS = exports.LDREF = exports.ENDS = exports.CTOS = exports.STSAME = exports.STONES = exports.STZEROES = exports.BCHKBITREFSQ = exports.BCHKREFSQ = exports.BCHKBITREFS = exports.BCHKREFS = exports.BREMBITREFS = exports.BREMREFS = void 0;
exports.ATEXIT = exports.COMPOSBOTH = exports.BOOLOR = exports.BOOLAND = exports.SETCONTCTRMANYX = exports.SETCONTCTRX = exports.POPCTRX = exports.PUSHCTRX = exports.BLESSVARARGS = exports.BLESS = exports.SETNUMVARARGS = exports.SETCONTVARARGS = exports.RETURNVARARGS = exports.AGAINENDBRK = exports.AGAINBRK = exports.WHILEENDBRK = exports.WHILEBRK = exports.UNTILENDBRK = exports.UNTILBRK = exports.REPEATENDBRK = exports.REPEATBRK = exports.AGAINEND = exports.AGAIN = exports.WHILEEND = exports.WHILE = exports.UNTILEND = exports.UNTIL = exports.REPEATEND = exports.REPEAT = exports.IFNOTRETALT = exports.IFRETALT = exports.CONDSELCHK = exports.CONDSEL = exports.IFELSE = exports.IFNOTJMP = exports.IFJMP = exports.IFNOT = exports.IF = exports.IFNOTRET = exports.IFRET = exports.RUNVMX = exports.RETDATA = exports.CALLCCVARARGS = exports.JMPXVARARGS = exports.RETVARARGS = exports.CALLXVARARGS = exports.JMPXDATA = exports.CALLCC = exports.RETBOOL = exports.RETALT = void 0;
exports.NOW = exports.COMMIT = exports.GASCONSUMED = exports.SETGASLIMIT = exports.ACCEPT = exports.ONLYX = exports.ONLYTOPX = exports.CHKDEPTH = exports.DEPTH = exports.XCHGX = exports.TUCK = exports.DROPX = exports.REVX = exports.BLKSWX = exports.ROLLREV = exports.ROLL = exports.PICK = exports.ROTREV = exports.ROT = exports.NIP = exports.DROP = exports.OVER = exports.DUP = exports.SWAP = exports.NOP = exports.PFXDICTGETEXEC = exports.PFXDICTGETJMP = exports.PFXDICTGET = exports.PFXDICTGETQ = exports.PFXDICTDEL = exports.PFXDICTADD = exports.PFXDICTREPLACE = exports.PFXDICTSET = exports.PLDDICTQ = exports.LDDICTQ = exports.PLDDICT = exports.LDDICT = exports.PLDDICTS = exports.LDDICTS = exports.SKIPDICT = exports.STDICT = exports.TRY = exports.SAMEALTSAVE = exports.SAMEALT = exports.BOOLEVAL = exports.INVERT = exports.THENRETALT = exports.THENRET = exports.SETEXITALT = exports.ATEXITALT = void 0;
exports.RIST255_QADD = exports.RIST255_QVALIDATE = exports.RIST255_PUSHL = exports.RIST255_MULBASE = exports.RIST255_MUL = exports.RIST255_SUB = exports.RIST255_ADD = exports.RIST255_VALIDATE = exports.RIST255_FROMHASH = exports.P256_CHKSIGNS = exports.P256_CHKSIGNU = exports.SECP256K1_XONLY_PUBKEY_TWEAK_ADD = exports.ECRECOVER = exports.CHKSIGNS = exports.CHKSIGNU = exports.SHA256U = exports.HASHSU = exports.HASHCU = exports.ADDRAND = exports.SETRAND = exports.RAND = exports.RANDU256 = exports.SETGLOBVAR = exports.GETGLOBVAR = exports.GETFORWARDFEESIMPLE = exports.GETGASFEESIMPLE = exports.GETORIGINALFWDFEE = exports.GETPRECOMPILEDGAS = exports.GETFORWARDFEE = exports.GETSTORAGEFEE = exports.GETGASFEE = exports.GLOBALID = exports.PREVMCBLOCKS_100 = exports.PREVKEYBLOCK = exports.PREVMCBLOCKS = exports.CONFIGOPTPARAM = exports.CONFIGPARAM = exports.CONFIGDICT = exports.DUEPAYMENT = exports.UNPACKEDCONFIGTUPLE = exports.PREVBLOCKSINFOTUPLE = exports.STORAGEFEES = exports.INCOMINGVALUE = exports.MYCODE = exports.CONFIGROOT = exports.MYADDR = exports.BALANCE = exports.RANDSEED = exports.LTIME = exports.BLOCKLT = void 0;
exports.RAWRESERVEX = exports.RAWRESERVE = exports.SENDRAWMSG = exports.REWRITEVARADDRQ = exports.REWRITEVARADDR = exports.REWRITESTDADDRQ = exports.REWRITESTDADDR = exports.PARSEMSGADDRQ = exports.PARSEMSGADDR = exports.LDMSGADDRQ = exports.LDMSGADDR = exports.STVARINT32 = exports.STVARUINT32 = exports.LDVARINT32 = exports.LDVARUINT32 = exports.STVARINT16 = exports.STGRAMS = exports.LDVARINT16 = exports.LDGRAMS = exports.SDATASIZE = exports.SDATASIZEQ = exports.CDATASIZE = exports.CDATASIZEQ = exports.BLS_PUSHR = exports.BLS_PAIRING = exports.BLS_G2_ISZERO = exports.BLS_G2_INGROUP = exports.BLS_MAP_TO_G2 = exports.BLS_G2_ZERO = exports.BLS_G2_MULTIEXP = exports.BLS_G2_MUL = exports.BLS_G2_NEG = exports.BLS_G2_SUB = exports.BLS_G2_ADD = exports.BLS_G1_ISZERO = exports.BLS_G1_INGROUP = exports.BLS_MAP_TO_G1 = exports.BLS_G1_ZERO = exports.BLS_G1_MULTIEXP = exports.BLS_G1_MUL = exports.BLS_G1_NEG = exports.BLS_G1_SUB = exports.BLS_G1_ADD = exports.BLS_AGGREGATEVERIFY = exports.BLS_FASTAGGREGATEVERIFY = exports.BLS_AGGREGATE = exports.BLS_VERIFY = exports.RIST255_QMULBASE = exports.RIST255_QMUL = exports.RIST255_QSUB = void 0;
exports.QDIVMOD = exports.QMODC = exports.QMODR = exports.QMOD = exports.QDIVC = exports.QDIVR = exports.QDIV = exports.QADDDIVMODC = exports.QADDDIVMODR = exports.QADDDIVMOD = exports.DIVMODC = exports.DIVMODR = exports.DIVMOD = exports.MODC = exports.MODR = exports.MOD = exports.DIVC = exports.DIVR = exports.DIV = exports.ADDDIVMODC = exports.ADDDIVMODR = exports.ADDDIVMOD = exports.NULLROTRIFNOT2 = exports.NULLROTRIF2 = exports.NULLSWAPIFNOT2 = exports.NULLSWAPIF2 = exports.NULLROTRIFNOT = exports.NULLROTRIF = exports.NULLSWAPIFNOT = exports.NULLSWAPIF = exports.TPOP = exports.TPUSH = exports.LAST = exports.ISTUPLE = exports.QTLEN = exports.TLEN = exports.SETINDEXVARQ = exports.INDEXVARQ = exports.SETINDEXVAR = exports.EXPLODEVAR = exports.UNPACKFIRSTVAR = exports.UNTUPLEVAR = exports.INDEXVAR = exports.TUPLEVAR = exports.ISNULL = exports.PUSHNULL = exports.SENDMSG = exports.CHANGELIB = exports.SETLIBCODE = exports.SETCODE = void 0;
exports.MULADDRSHIFTRMOD = exports.MULADDRSHIFTMOD = exports.QMULDIVMODC = exports.QMULDIVMODR = exports.QMULDIVMOD = exports.QMULMODC = exports.QMULMODR = exports.QMULMOD = exports.QMULDIVC = exports.QMULDIVR = exports.QMULDIV = exports.QMULADDDIVMODC = exports.QMULADDDIVMODR = exports.QMULADDDIVMOD = exports.MULDIVMODC = exports.MULDIVMODR = exports.MULDIVMOD = exports.MULMODC = exports.MULMODR = exports.MULMOD = exports.MULDIVC = exports.MULDIVR = exports.MULDIV = exports.MULADDDIVMODC = exports.MULADDDIVMODR = exports.MULADDDIVMOD = exports.QRSHIFTMODC = exports.QRSHIFTMODR = exports.QRSHIFTMOD = exports.QMODPOW2C = exports.QMODPOW2R = exports.QMODPOW2 = exports.QRSHIFTC = exports.QRSHIFTR = exports.QADDRSHIFTMODC = exports.QADDRSHIFTMODR = exports.QADDRSHIFTMOD = exports.RSHIFTMODC = exports.RSHIFTMODR = exports.RSHIFTMOD = exports.MODPOW2C = exports.MODPOW2R = exports.MODPOW2 = exports.RSHIFTC = exports.RSHIFTR = exports.ADDRSHIFTMODC = exports.ADDRSHIFTMODR = exports.ADDRSHIFTMOD = exports.QDIVMODC = exports.QDIVMODR = void 0;
exports.STUXR = exports.STIXR = exports.STUX = exports.STIX = exports.QLSHIFTDIVMODC = exports.QLSHIFTDIVMODR = exports.QLSHIFTDIVMOD = exports.QLSHIFTMODC = exports.QLSHIFTMODR = exports.QLSHIFTMOD = exports.QLSHIFTDIVC = exports.QLSHIFTDIVR = exports.QLSHIFTDIV = exports.QLSHIFTADDDIVMODC = exports.QLSHIFTADDDIVMODR = exports.QLSHIFTADDDIVMOD = exports.LSHIFTDIVMODC = exports.LSHIFTDIVMODR = exports.LSHIFTDIVMOD = exports.LSHIFTMODC = exports.LSHIFTMODR = exports.LSHIFTMOD = exports.LSHIFTDIVC = exports.LSHIFTDIVR = exports.LSHIFTDIV = exports.LSHIFTADDDIVMODC = exports.LSHIFTADDDIVMODR = exports.LSHIFTADDDIVMOD = exports.QMULRSHIFTCMOD = exports.QMULRSHIFTRMOD = exports.QMULRSHIFTMOD = exports.QMULMODPOW2C = exports.QMULMODPOW2R = exports.QMULMODPOW2 = exports.QMULRSHIFTC = exports.QMULRSHIFTR = exports.QMULRSHIFT = exports.QMULADDRSHIFTCMOD = exports.QMULADDRSHIFTRMOD = exports.QMULADDRSHIFTMOD = exports.MULRSHIFTCMOD = exports.MULRSHIFTRMOD = exports.MULRSHIFTMOD = exports.MULMODPOW2C = exports.MULMODPOW2R = exports.MULMODPOW2 = exports.MULRSHIFTC = exports.MULRSHIFTR = exports.MULRSHIFT = exports.MULADDRSHIFTCMOD = void 0;
exports.DICTUGETREF = exports.DICTUGET = exports.DICTIGETREF = exports.DICTIGET = exports.DICTGETREF = exports.DICTGET = exports.DICTUGETEXECZ = exports.DICTIGETEXECZ = exports.DICTUGETJMPZ = exports.DICTIGETJMPZ = exports.DICTUGETEXEC = exports.DICTIGETEXEC = exports.DICTUGETJMP = exports.DICTIGETJMP = exports.PLDULE8Q = exports.PLDILE8Q = exports.PLDULE4Q = exports.PLDILE4Q = exports.LDULE8Q = exports.LDILE8Q = exports.LDULE4Q = exports.LDILE4Q = exports.PLDULE8 = exports.PLDILE8 = exports.PLDULE4 = exports.PLDILE4 = exports.LDULE8 = exports.LDILE8 = exports.LDULE4 = exports.LDILE4 = exports.PLDSLICEXQ = exports.LDSLICEXQ = exports.PLDSLICEX = exports.LDSLICEX = exports.PLDUXQ = exports.PLDIXQ = exports.LDUXQ = exports.LDIXQ = exports.PLDUX = exports.PLDIX = exports.LDUX = exports.LDIX = exports.STULE8 = exports.STILE8 = exports.STULE4 = exports.STILE4 = exports.STUXRQ = exports.STIXRQ = exports.STUXQ = exports.STIXQ = void 0;
exports.DICTMAXREF = exports.DICTMAX = exports.DICTUMINREF = exports.DICTUMIN = exports.DICTIMINREF = exports.DICTIMIN = exports.DICTMINREF = exports.DICTMIN = exports.DICTUDELGETREF = exports.DICTUDELGET = exports.DICTIDELGETREF = exports.DICTIDELGET = exports.DICTDELGETREF = exports.DICTDELGET = exports.DICTUADDGETREF = exports.DICTUADDGET = exports.DICTIADDGETREF = exports.DICTIADDGET = exports.DICTADDGETREF = exports.DICTADDGET = exports.DICTUADDREF = exports.DICTUADD = exports.DICTIADDREF = exports.DICTIADD = exports.DICTADDREF = exports.DICTADD = exports.DICTUREPLACEGETREF = exports.DICTUREPLACEGET = exports.DICTIREPLACEGETREF = exports.DICTIREPLACEGET = exports.DICTREPLACEGETREF = exports.DICTREPLACEGET = exports.DICTUREPLACEREF = exports.DICTUREPLACE = exports.DICTIREPLACEREF = exports.DICTIREPLACE = exports.DICTREPLACEREF = exports.DICTREPLACE = exports.DICTUSETGETREF = exports.DICTUSETGET = exports.DICTISETGETREF = exports.DICTISETGET = exports.DICTSETGETREF = exports.DICTSETGET = exports.DICTUSETREF = exports.DICTUSET = exports.DICTISETREF = exports.DICTISET = exports.DICTSETREF = exports.DICTSET = void 0;
exports.THROWANY = exports.SUBDICTURPGET = exports.SUBDICTIRPGET = exports.SUBDICTRPGET = exports.SUBDICTUGET = exports.SUBDICTIGET = exports.SUBDICTGET = exports.DICTUSETGETOPTREF = exports.DICTISETGETOPTREF = exports.DICTSETGETOPTREF = exports.DICTUGETOPTREF = exports.DICTIGETOPTREF = exports.DICTGETOPTREF = exports.DICTUDEL = exports.DICTIDEL = exports.DICTDEL = exports.DICTUADDGETB = exports.DICTIADDGETB = exports.DICTADDGETB = exports.DICTUADDB = exports.DICTIADDB = exports.DICTADDB = exports.DICTUREPLACEGETB = exports.DICTIREPLACEGETB = exports.DICTREPLACEGETB = exports.DICTUREPLACEB = exports.DICTIREPLACEB = exports.DICTREPLACEB = exports.DICTUSETGETB = exports.DICTISETGETB = exports.DICTSETGETB = exports.DICTUSETB = exports.DICTISETB = exports.DICTSETB = exports.DICTUREMMAXREF = exports.DICTUREMMAX = exports.DICTIREMMAXREF = exports.DICTIREMMAX = exports.DICTREMMAXREF = exports.DICTREMMAX = exports.DICTUREMMINREF = exports.DICTUREMMIN = exports.DICTIREMMINREF = exports.DICTIREMMIN = exports.DICTREMMINREF = exports.DICTREMMIN = exports.DICTUMAXREF = exports.DICTUMAX = exports.DICTIMAXREF = exports.DICTIMAX = void 0;
exports.INDEX = exports.TUPLE = exports.BLKDROP = exports.RETURNARGS = exports.RETARGS = exports.JMPXARGS = exports.THROWARGIFNOT = exports.THROWARGIF = exports.THROWARG = exports.PREPAREDICT = exports.JMPDICT = exports.CDEPTHI = exports.CHASHI = exports.PLDREFIDX = exports.TRYARGS = exports.CALLCCARGS = exports.SETCONTCTRMANY = exports.QUFITS = exports.QFITS = exports.UFITS = exports.FITS = exports.PUSHNEGPOW2 = exports.PUSHPOW2DEC = exports.QNEQINT = exports.QGTINT = exports.QLESSINT = exports.QEQINT = exports.NEQINT = exports.GTINT = exports.LESSINT = exports.EQINT = exports.QMULINT = exports.QADDINT = exports.MULINT = exports.ADDINT = exports.DICTUGETPREVEQ = exports.DICTUGETPREV = exports.DICTUGETNEXTEQ = exports.DICTUGETNEXT = exports.DICTIGETPREVEQ = exports.DICTIGETPREV = exports.DICTIGETNEXTEQ = exports.DICTIGETNEXT = exports.DICTGETPREVEQ = exports.DICTGETPREV = exports.DICTGETNEXTEQ = exports.DICTGETNEXT = exports.THROWARGANYIFNOT = exports.THROWANYIFNOT = exports.THROWARGANY = void 0;
exports.PUSHREFCONT = exports.PUSHREFSLICE = exports.PUSHREF = exports.GETPARAM = exports.SETGLOB = exports.GETGLOB = exports.BLKDROP2 = exports.BLKPUSH = exports.PUSHPOW2 = exports.INDEX3 = exports.INDEX2 = exports.IFNBITJMP = exports.IFBITJMP = exports.PLDSLICEQ = exports.LDSLICEQ = exports.PLDSLICE = exports.PLDUZ = exports.PLDUQ = exports.PLDIQ = exports.LDUQ = exports.LDIQ = exports.PLDU = exports.PLDI = exports.STURQ = exports.STIRQ = exports.STUQ = exports.STIQ = exports.STUR = exports.STIR = exports.BLESSARGS = exports.SETCONTARGS = exports.REVERSE = exports.BLKSWAP = exports.PU2XC = exports.PUXCPU = exports.PUXC2 = exports.XCPUXC = exports.PUXC = exports.PUSH2 = exports.XCPU = exports.XCHG2 = exports.PUSH3 = exports.XCPU2 = exports.XC2PU = exports.SETINDEXQ = exports.INDEXQ = exports.SETINDEX = exports.EXPLODE = exports.UNPACKFIRST = exports.UNTUPLE = void 0;
exports.MULADDRSHIFTC_MOD = exports.MULADDRSHIFTR_MOD = exports.MULADDRSHIFT_MOD = exports.RSHIFTC_MOD = exports.RSHIFTR_MOD = exports.RSHIFT_MOD = exports.MODPOW2C_ = exports.MODPOW2R_ = exports.MODPOW2_ = exports.RSHIFTC_ = exports.RSHIFTR_ = exports.RSHIFT_ = exports.ADDRSHIFTC_MOD = exports.ADDRSHIFTR_MOD = exports.ADDRSHIFT_MOD = exports.OVER2 = exports.DUP2 = exports.DROP2 = exports.SWAP2 = exports.RUNVM = exports.SAVEBOTHCTR = exports.SAVEALTCTR = exports.SAVECTR = exports.POPSAVE = exports.SETALTCTR = exports.SETRETCTR = exports.SETCONTCTR = exports.DEBUGSTR = exports.THROWARGANYIF = exports.THROWANYIF = exports.STREF2CONST = exports.STREFCONST = exports.SDBEGINSQ = exports.SDBEGINS = exports.SDBEGINSXQ = exports.SDBEGINSX = exports.PFXDICTSWITCH = exports.DICTPUSHCONST = exports.IFNBITJMPREF = exports.IFBITJMPREF = exports.IFREFELSEREF = exports.IFELSEREF = exports.IFREFELSE = exports.IFNOTJMPREF = exports.IFJMPREF = exports.IFNOTREF = exports.IFREF = exports.JMPREFDATA = exports.JMPREF = exports.CALLREF = void 0;
exports.RSHIFT_VAR = exports.BCHKBITSQ = exports.BCHKBITSQ_VAR = exports.BCHKBITS = exports.BCHKBITS_VAR = exports.QLSHIFT = exports.QLSHIFT_VAR = exports.LSHIFT = exports.LSHIFT_VAR = exports.LDSLICE_ALT = exports.LDSLICE = exports.LDU_ALT = exports.LDU = exports.LDI_ALT = exports.LDI = exports.STU_ALT = exports.STU = exports.STI_ALT = exports.STI = exports.XCHG3_ALT = exports.XCHG3 = exports.STSLICE_ALT = exports.STSLICE = exports.STREF_ALT = exports.STREF = exports.HASHEXTAR = exports.HASHEXTA = exports.HASHEXTR = exports.HASHEXT = exports.LSHIFT_DIVMODC = exports.LSHIFT_DIVMODR = exports.LSHIFT_DIVMOD = exports.LSHIFT_MODC = exports.LSHIFT_MODR = exports.LSHIFT_MOD = exports.LSHIFT_DIVC = exports.LSHIFT_DIVR = exports.LSHIFT_DIV = exports.LSHIFT_ADDDIVMODC = exports.LSHIFT_ADDDIVMODR = exports.LSHIFT_ADDDIVMOD = exports.MULRSHIFTC_MOD = exports.MULRSHIFTR_MOD = exports.MULRSHIFT_MOD = exports.MULMODPOW2C_ = exports.MULMODPOW2R_ = exports.MULMODPOW2_ = exports.MULRSHIFTC_ = exports.MULRSHIFTR_ = exports.MULRSHIFT_ = void 0;
exports.INMSG_SRC = exports.INMSG_BOUNCED = exports.INMSG_BOUNCE = exports.GETPARAMLONG2 = exports.INMSGPARAMS = exports.GETPARAMLONG = exports.SETCP_SHORT = exports.SETCPX = exports.SETCP = exports.STSLICECONST = exports.PUSHCONT_SHORT = exports.PUSHCONT = exports.PUSHSLICE_LONG = exports.PUSHSLICE_REFS = exports.PUSHSLICE = exports.CALLXARGS_1 = exports.CALLXARGS = exports.POP_LONG = exports.POP = exports.POPCTR = exports.PUSH_LONG = exports.PUSH = exports.PUSHCTR = exports.DEBUG_2 = exports.DUMP = exports.DEBUG_1 = exports.STRDUMP = exports.DEBUG = exports.DUMPSTK = exports.XCHG_1I = exports.XCHG_IJ = exports.XCHG_0I = exports.XCHG_0I_LONG = exports.PUSHINT_LONG = exports.PUSHINT_16 = exports.PUSHINT_8 = exports.PUSHINT_4 = exports.THROWIFNOT = exports.THROWIFNOT_SHORT = exports.THROWIF = exports.THROWIF_SHORT = exports.THROW = exports.THROW_SHORT = exports.CALLDICT_LONG = exports.CALLDICT = exports.QRSHIFT_ALT = exports.QRSHIFT = exports.QRSHIFT_VAR = exports.RSHIFT_ALT = exports.RSHIFT = void 0;
exports.convertInstruction = exports.fTHROWIFNOT = exports.fTHROWIF = exports.fTHROW = exports.fPREPAREDICT = exports.fJMPDICT = exports.fCALLDICT = exports.fCALLXARGS = exports.fSDBEGINSQ = exports.fSDBEGINS = exports.fIF = exports.fPUSHINTX = exports.fXCHG = exports.fSTSLICECONST = exports.fPUSHCONT = exports.fPUSHSLICE = exports.fPUSHINT = exports.DEBUGMARK = exports.INMSGPARAM = exports.INMSG_STATEINIT = exports.INMSG_VALUEEXTRA = exports.INMSG_VALUE = exports.INMSG_ORIGVALUE = exports.INMSG_UTIME = exports.INMSG_LT = exports.INMSG_FWDFEE = void 0;
// AUTOGENERATED, DO NOT EDIT, generated by ../generator/gen-converter.ts
const $ = __importStar(require("./util"));
const c = __importStar(require("../runtime"));
const u = __importStar(require("./convert-util"));
const util_1 = require("../runtime/util");
const util_2 = require("./util");
const PUSHNAN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PUSHNAN(loc);
};
exports.PUSHNAN = PUSHNAN;
const ADD = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ADD(loc);
};
exports.ADD = ADD;
const SUB = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SUB(loc);
};
exports.SUB = SUB;
const SUBR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SUBR(loc);
};
exports.SUBR = SUBR;
const NEGATE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.NEGATE(loc);
};
exports.NEGATE = NEGATE;
const INC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.INC(loc);
};
exports.INC = INC;
const DEC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.DEC(loc);
};
exports.DEC = DEC;
const MUL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.MUL(loc);
};
exports.MUL = MUL;
const POW2 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.POW2(loc);
};
exports.POW2 = POW2;
const AND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.AND(loc);
};
exports.AND = AND;
const OR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.OR(loc);
};
exports.OR = OR;
const XOR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.XOR(loc);
};
exports.XOR = XOR;
const NOT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.NOT(loc);
};
exports.NOT = NOT;
const FITSX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.FITSX(loc);
};
exports.FITSX = FITSX;
const UFITSX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UFITSX(loc);
};
exports.UFITSX = UFITSX;
const BITSIZE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BITSIZE(loc);
};
exports.BITSIZE = BITSIZE;
const UBITSIZE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UBITSIZE(loc);
};
exports.UBITSIZE = UBITSIZE;
const MIN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.MIN(loc);
};
exports.MIN = MIN;
const MAX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.MAX(loc);
};
exports.MAX = MAX;
const MINMAX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.MINMAX(loc);
};
exports.MINMAX = MINMAX;
const ABS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ABS(loc);
};
exports.ABS = ABS;
const QADD = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QADD(loc);
};
exports.QADD = QADD;
const QSUB = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QSUB(loc);
};
exports.QSUB = QSUB;
const QSUBR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QSUBR(loc);
};
exports.QSUBR = QSUBR;
const QNEGATE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QNEGATE(loc);
};
exports.QNEGATE = QNEGATE;
const QINC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QINC(loc);
};
exports.QINC = QINC;
const QDEC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QDEC(loc);
};
exports.QDEC = QDEC;
const QMUL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QMUL(loc);
};
exports.QMUL = QMUL;
const QPOW2 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QPOW2(loc);
};
exports.QPOW2 = QPOW2;
const QAND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QAND(loc);
};
exports.QAND = QAND;
const QOR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QOR(loc);
};
exports.QOR = QOR;
const QXOR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QXOR(loc);
};
exports.QXOR = QXOR;
const QNOT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QNOT(loc);
};
exports.QNOT = QNOT;
const QFITSX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QFITSX(loc);
};
exports.QFITSX = QFITSX;
const QUFITSX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QUFITSX(loc);
};
exports.QUFITSX = QUFITSX;
const QBITSIZE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QBITSIZE(loc);
};
exports.QBITSIZE = QBITSIZE;
const QUBITSIZE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QUBITSIZE(loc);
};
exports.QUBITSIZE = QUBITSIZE;
const QMIN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QMIN(loc);
};
exports.QMIN = QMIN;
const QMAX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QMAX(loc);
};
exports.QMAX = QMAX;
const QMINMAX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QMINMAX(loc);
};
exports.QMINMAX = QMINMAX;
const QABS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QABS(loc);
};
exports.QABS = QABS;
const SGN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SGN(loc);
};
exports.SGN = SGN;
const LESS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LESS(loc);
};
exports.LESS = LESS;
const EQUAL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.EQUAL(loc);
};
exports.EQUAL = EQUAL;
const LEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LEQ(loc);
};
exports.LEQ = LEQ;
const GREATER = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.GREATER(loc);
};
exports.GREATER = GREATER;
const NEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.NEQ(loc);
};
exports.NEQ = NEQ;
const GEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.GEQ(loc);
};
exports.GEQ = GEQ;
const CMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CMP(loc);
};
exports.CMP = CMP;
const ISNAN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ISNAN(loc);
};
exports.ISNAN = ISNAN;
const CHKNAN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CHKNAN(loc);
};
exports.CHKNAN = CHKNAN;
const QSGN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QSGN(loc);
};
exports.QSGN = QSGN;
const QLESS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QLESS(loc);
};
exports.QLESS = QLESS;
const QEQUAL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QEQUAL(loc);
};
exports.QEQUAL = QEQUAL;
const QLEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QLEQ(loc);
};
exports.QLEQ = QLEQ;
const QGREATER = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QGREATER(loc);
};
exports.QGREATER = QGREATER;
const QNEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QNEQ(loc);
};
exports.QNEQ = QNEQ;
const QGEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QGEQ(loc);
};
exports.QGEQ = QGEQ;
const QCMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.QCMP(loc);
};
exports.QCMP = QCMP;
const SEMPTY = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SEMPTY(loc);
};
exports.SEMPTY = SEMPTY;
const SDEMPTY = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDEMPTY(loc);
};
exports.SDEMPTY = SDEMPTY;
const SREMPTY = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SREMPTY(loc);
};
exports.SREMPTY = SREMPTY;
const SDFIRST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDFIRST(loc);
};
exports.SDFIRST = SDFIRST;
const SDLEXCMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDLEXCMP(loc);
};
exports.SDLEXCMP = SDLEXCMP;
const SDEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDEQ(loc);
};
exports.SDEQ = SDEQ;
const SDPFX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPFX(loc);
};
exports.SDPFX = SDPFX;
const SDPFXREV = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPFXREV(loc);
};
exports.SDPFXREV = SDPFXREV;
const SDPPFX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPPFX(loc);
};
exports.SDPPFX = SDPPFX;
const SDPPFXREV = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPPFXREV(loc);
};
exports.SDPPFXREV = SDPPFXREV;
const SDSFX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDSFX(loc);
};
exports.SDSFX = SDSFX;
const SDSFXREV = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDSFXREV(loc);
};
exports.SDSFXREV = SDSFXREV;
const SDPSFX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPSFX(loc);
};
exports.SDPSFX = SDPSFX;
const SDPSFXREV = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDPSFXREV(loc);
};
exports.SDPSFXREV = SDPSFXREV;
const SDCNTLEAD0 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCNTLEAD0(loc);
};
exports.SDCNTLEAD0 = SDCNTLEAD0;
const SDCNTLEAD1 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCNTLEAD1(loc);
};
exports.SDCNTLEAD1 = SDCNTLEAD1;
const SDCNTTRAIL0 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCNTTRAIL0(loc);
};
exports.SDCNTTRAIL0 = SDCNTTRAIL0;
const SDCNTTRAIL1 = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCNTTRAIL1(loc);
};
exports.SDCNTTRAIL1 = SDCNTTRAIL1;
const NEWC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.NEWC(loc);
};
exports.NEWC = NEWC;
const ENDC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ENDC(loc);
};
exports.ENDC = ENDC;
const ENDCST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ENDCST(loc);
};
exports.ENDCST = ENDCST;
const STBREF = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBREF(loc);
};
exports.STBREF = STBREF;
const STB = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STB(loc);
};
exports.STB = STB;
const STREFR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STREFR(loc);
};
exports.STREFR = STREFR;
const STBREFR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBREFR(loc);
};
exports.STBREFR = STBREFR;
const STSLICER = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STSLICER(loc);
};
exports.STSLICER = STSLICER;
const STBR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBR(loc);
};
exports.STBR = STBR;
const STREFQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STREFQ(loc);
};
exports.STREFQ = STREFQ;
const STBREFQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBREFQ(loc);
};
exports.STBREFQ = STBREFQ;
const STSLICEQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STSLICEQ(loc);
};
exports.STSLICEQ = STSLICEQ;
const STBQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBQ(loc);
};
exports.STBQ = STBQ;
const STREFRQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STREFRQ(loc);
};
exports.STREFRQ = STREFRQ;
const STBREFRQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBREFRQ(loc);
};
exports.STBREFRQ = STBREFRQ;
const STSLICERQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STSLICERQ(loc);
};
exports.STSLICERQ = STSLICERQ;
const STBRQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STBRQ(loc);
};
exports.STBRQ = STBRQ;
const ENDXC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ENDXC(loc);
};
exports.ENDXC = ENDXC;
const BDEPTH = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BDEPTH(loc);
};
exports.BDEPTH = BDEPTH;
const BBITS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BBITS(loc);
};
exports.BBITS = BBITS;
const BREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BREFS(loc);
};
exports.BREFS = BREFS;
const BBITREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BBITREFS(loc);
};
exports.BBITREFS = BBITREFS;
const BREMBITS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BREMBITS(loc);
};
exports.BREMBITS = BREMBITS;
const BREMREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BREMREFS(loc);
};
exports.BREMREFS = BREMREFS;
const BREMBITREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BREMBITREFS(loc);
};
exports.BREMBITREFS = BREMBITREFS;
const BCHKREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BCHKREFS(loc);
};
exports.BCHKREFS = BCHKREFS;
const BCHKBITREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BCHKBITREFS(loc);
};
exports.BCHKBITREFS = BCHKBITREFS;
const BCHKREFSQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BCHKREFSQ(loc);
};
exports.BCHKREFSQ = BCHKREFSQ;
const BCHKBITREFSQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BCHKBITREFSQ(loc);
};
exports.BCHKBITREFSQ = BCHKBITREFSQ;
const STZEROES = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STZEROES(loc);
};
exports.STZEROES = STZEROES;
const STONES = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STONES(loc);
};
exports.STONES = STONES;
const STSAME = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STSAME(loc);
};
exports.STSAME = STSAME;
const CTOS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CTOS(loc);
};
exports.CTOS = CTOS;
const ENDS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ENDS(loc);
};
exports.ENDS = ENDS;
const LDREF = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDREF(loc);
};
exports.LDREF = LDREF;
const LDREFRTOS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDREFRTOS(loc);
};
exports.LDREFRTOS = LDREFRTOS;
const SDCUTFIRST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCUTFIRST(loc);
};
exports.SDCUTFIRST = SDCUTFIRST;
const SDSKIPFIRST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDSKIPFIRST(loc);
};
exports.SDSKIPFIRST = SDSKIPFIRST;
const SDCUTLAST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDCUTLAST(loc);
};
exports.SDCUTLAST = SDCUTLAST;
const SDSKIPLAST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDSKIPLAST(loc);
};
exports.SDSKIPLAST = SDSKIPLAST;
const SDSUBSTR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDSUBSTR(loc);
};
exports.SDSUBSTR = SDSUBSTR;
const SCUTFIRST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCUTFIRST(loc);
};
exports.SCUTFIRST = SCUTFIRST;
const SSKIPFIRST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SSKIPFIRST(loc);
};
exports.SSKIPFIRST = SSKIPFIRST;
const SCUTLAST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCUTLAST(loc);
};
exports.SCUTLAST = SCUTLAST;
const SSKIPLAST = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SSKIPLAST(loc);
};
exports.SSKIPLAST = SSKIPLAST;
const SUBSLICE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SUBSLICE(loc);
};
exports.SUBSLICE = SUBSLICE;
const SPLIT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SPLIT(loc);
};
exports.SPLIT = SPLIT;
const SPLITQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SPLITQ(loc);
};
exports.SPLITQ = SPLITQ;
const XCTOS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.XCTOS(loc);
};
exports.XCTOS = XCTOS;
const XLOAD = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.XLOAD(loc);
};
exports.XLOAD = XLOAD;
const XLOADQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.XLOADQ(loc);
};
exports.XLOADQ = XLOADQ;
const SCHKBITS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKBITS(loc);
};
exports.SCHKBITS = SCHKBITS;
const SCHKREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKREFS(loc);
};
exports.SCHKREFS = SCHKREFS;
const SCHKBITREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKBITREFS(loc);
};
exports.SCHKBITREFS = SCHKBITREFS;
const SCHKBITSQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKBITSQ(loc);
};
exports.SCHKBITSQ = SCHKBITSQ;
const SCHKREFSQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKREFSQ(loc);
};
exports.SCHKREFSQ = SCHKREFSQ;
const SCHKBITREFSQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SCHKBITREFSQ(loc);
};
exports.SCHKBITREFSQ = SCHKBITREFSQ;
const PLDREFVAR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PLDREFVAR(loc);
};
exports.PLDREFVAR = PLDREFVAR;
const SBITS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SBITS(loc);
};
exports.SBITS = SBITS;
const SREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SREFS(loc);
};
exports.SREFS = SREFS;
const SBITREFS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SBITREFS(loc);
};
exports.SBITREFS = SBITREFS;
const LDZEROES = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDZEROES(loc);
};
exports.LDZEROES = LDZEROES;
const LDONES = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDONES(loc);
};
exports.LDONES = LDONES;
const LDSAME = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDSAME(loc);
};
exports.LDSAME = LDSAME;
const SDEPTH = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SDEPTH(loc);
};
exports.SDEPTH = SDEPTH;
const CDEPTH = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CDEPTH(loc);
};
exports.CDEPTH = CDEPTH;
const CLEVEL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CLEVEL(loc);
};
exports.CLEVEL = CLEVEL;
const CLEVELMASK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CLEVELMASK(loc);
};
exports.CLEVELMASK = CLEVELMASK;
const CHASHIX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CHASHIX(loc);
};
exports.CHASHIX = CHASHIX;
const CDEPTHIX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CDEPTHIX(loc);
};
exports.CDEPTHIX = CDEPTHIX;
const EXECUTE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.EXECUTE(loc);
};
exports.EXECUTE = EXECUTE;
const JMPX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.JMPX(loc);
};
exports.JMPX = JMPX;
const RET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RET(loc);
};
exports.RET = RET;
const RETALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RETALT(loc);
};
exports.RETALT = RETALT;
const RETBOOL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RETBOOL(loc);
};
exports.RETBOOL = RETBOOL;
const CALLCC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CALLCC(loc);
};
exports.CALLCC = CALLCC;
const JMPXDATA = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.JMPXDATA(loc);
};
exports.JMPXDATA = JMPXDATA;
const CALLXVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CALLXVARARGS(loc);
};
exports.CALLXVARARGS = CALLXVARARGS;
const RETVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RETVARARGS(loc);
};
exports.RETVARARGS = RETVARARGS;
const JMPXVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.JMPXVARARGS(loc);
};
exports.JMPXVARARGS = JMPXVARARGS;
const CALLCCVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CALLCCVARARGS(loc);
};
exports.CALLCCVARARGS = CALLCCVARARGS;
const RETDATA = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RETDATA(loc);
};
exports.RETDATA = RETDATA;
const RUNVMX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RUNVMX(loc);
};
exports.RUNVMX = RUNVMX;
const IFRET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFRET(loc);
};
exports.IFRET = IFRET;
const IFNOTRET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFNOTRET(loc);
};
exports.IFNOTRET = IFNOTRET;
const IF = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IF(loc);
};
exports.IF = IF;
const IFNOT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFNOT(loc);
};
exports.IFNOT = IFNOT;
const IFJMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFJMP(loc);
};
exports.IFJMP = IFJMP;
const IFNOTJMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFNOTJMP(loc);
};
exports.IFNOTJMP = IFNOTJMP;
const IFELSE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFELSE(loc);
};
exports.IFELSE = IFELSE;
const CONDSEL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CONDSEL(loc);
};
exports.CONDSEL = CONDSEL;
const CONDSELCHK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.CONDSELCHK(loc);
};
exports.CONDSELCHK = CONDSELCHK;
const IFRETALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFRETALT(loc);
};
exports.IFRETALT = IFRETALT;
const IFNOTRETALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.IFNOTRETALT(loc);
};
exports.IFNOTRETALT = IFNOTRETALT;
const REPEAT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.REPEAT(loc);
};
exports.REPEAT = REPEAT;
const REPEATEND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.REPEATEND(loc);
};
exports.REPEATEND = REPEATEND;
const UNTIL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UNTIL(loc);
};
exports.UNTIL = UNTIL;
const UNTILEND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UNTILEND(loc);
};
exports.UNTILEND = UNTILEND;
const WHILE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.WHILE(loc);
};
exports.WHILE = WHILE;
const WHILEEND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.WHILEEND(loc);
};
exports.WHILEEND = WHILEEND;
const AGAIN = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.AGAIN(loc);
};
exports.AGAIN = AGAIN;
const AGAINEND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.AGAINEND(loc);
};
exports.AGAINEND = AGAINEND;
const REPEATBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.REPEATBRK(loc);
};
exports.REPEATBRK = REPEATBRK;
const REPEATENDBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.REPEATENDBRK(loc);
};
exports.REPEATENDBRK = REPEATENDBRK;
const UNTILBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UNTILBRK(loc);
};
exports.UNTILBRK = UNTILBRK;
const UNTILENDBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.UNTILENDBRK(loc);
};
exports.UNTILENDBRK = UNTILENDBRK;
const WHILEBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.WHILEBRK(loc);
};
exports.WHILEBRK = WHILEBRK;
const WHILEENDBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.WHILEENDBRK(loc);
};
exports.WHILEENDBRK = WHILEENDBRK;
const AGAINBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.AGAINBRK(loc);
};
exports.AGAINBRK = AGAINBRK;
const AGAINENDBRK = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.AGAINENDBRK(loc);
};
exports.AGAINENDBRK = AGAINENDBRK;
const RETURNVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.RETURNVARARGS(loc);
};
exports.RETURNVARARGS = RETURNVARARGS;
const SETCONTVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SETCONTVARARGS(loc);
};
exports.SETCONTVARARGS = SETCONTVARARGS;
const SETNUMVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SETNUMVARARGS(loc);
};
exports.SETNUMVARARGS = SETNUMVARARGS;
const BLESS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BLESS(loc);
};
exports.BLESS = BLESS;
const BLESSVARARGS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BLESSVARARGS(loc);
};
exports.BLESSVARARGS = BLESSVARARGS;
const PUSHCTRX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PUSHCTRX(loc);
};
exports.PUSHCTRX = PUSHCTRX;
const POPCTRX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.POPCTRX(loc);
};
exports.POPCTRX = POPCTRX;
const SETCONTCTRX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SETCONTCTRX(loc);
};
exports.SETCONTCTRX = SETCONTCTRX;
const SETCONTCTRMANYX = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SETCONTCTRMANYX(loc);
};
exports.SETCONTCTRMANYX = SETCONTCTRMANYX;
const BOOLAND = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BOOLAND(loc);
};
exports.BOOLAND = BOOLAND;
const BOOLOR = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BOOLOR(loc);
};
exports.BOOLOR = BOOLOR;
const COMPOSBOTH = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.COMPOSBOTH(loc);
};
exports.COMPOSBOTH = COMPOSBOTH;
const ATEXIT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ATEXIT(loc);
};
exports.ATEXIT = ATEXIT;
const ATEXITALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.ATEXITALT(loc);
};
exports.ATEXITALT = ATEXITALT;
const SETEXITALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SETEXITALT(loc);
};
exports.SETEXITALT = SETEXITALT;
const THENRET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.THENRET(loc);
};
exports.THENRET = THENRET;
const THENRETALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.THENRETALT(loc);
};
exports.THENRETALT = THENRETALT;
const INVERT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.INVERT(loc);
};
exports.INVERT = INVERT;
const BOOLEVAL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.BOOLEVAL(loc);
};
exports.BOOLEVAL = BOOLEVAL;
const SAMEALT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SAMEALT(loc);
};
exports.SAMEALT = SAMEALT;
const SAMEALTSAVE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SAMEALTSAVE(loc);
};
exports.SAMEALTSAVE = SAMEALTSAVE;
const TRY = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.TRY(loc);
};
exports.TRY = TRY;
const STDICT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.STDICT(loc);
};
exports.STDICT = STDICT;
const SKIPDICT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SKIPDICT(loc);
};
exports.SKIPDICT = SKIPDICT;
const LDDICTS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDDICTS(loc);
};
exports.LDDICTS = LDDICTS;
const PLDDICTS = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PLDDICTS(loc);
};
exports.PLDDICTS = PLDDICTS;
const LDDICT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDDICT(loc);
};
exports.LDDICT = LDDICT;
const PLDDICT = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PLDDICT(loc);
};
exports.PLDDICT = PLDDICT;
const LDDICTQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.LDDICTQ(loc);
};
exports.LDDICTQ = LDDICTQ;
const PLDDICTQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PLDDICTQ(loc);
};
exports.PLDDICTQ = PLDDICTQ;
const PFXDICTSET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTSET(loc);
};
exports.PFXDICTSET = PFXDICTSET;
const PFXDICTREPLACE = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTREPLACE(loc);
};
exports.PFXDICTREPLACE = PFXDICTREPLACE;
const PFXDICTADD = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTADD(loc);
};
exports.PFXDICTADD = PFXDICTADD;
const PFXDICTDEL = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTDEL(loc);
};
exports.PFXDICTDEL = PFXDICTDEL;
const PFXDICTGETQ = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTGETQ(loc);
};
exports.PFXDICTGETQ = PFXDICTGETQ;
const PFXDICTGET = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTGET(loc);
};
exports.PFXDICTGET = PFXDICTGET;
const PFXDICTGETJMP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTGETJMP(loc);
};
exports.PFXDICTGETJMP = PFXDICTGETJMP;
const PFXDICTGETEXEC = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.PFXDICTGETEXEC(loc);
};
exports.PFXDICTGETEXEC = PFXDICTGETEXEC;
const NOP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.NOP(loc);
};
exports.NOP = NOP;
const SWAP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.SWAP(loc);
};
exports.SWAP = SWAP;
const DUP = (ctx, instr, loc) => {
    u.assertZeroArgs(instr, loc);
    return c.DUP(loc);
};
exports.DUP = DUP;
const OVER = (ctx, instr,