TVM instructions

advanced level

This information is very low-level and could be hard to understand for newcomers. So feel free to read about it later.

TVM instructions overview

Introduction

This document provides a list of TVM instructions along with their opcodes and mnemonics.

信息

TVM.pdf concept document for TON Virtual Machine (may include outdated information).
TVM Retracer

Fift is a stack-based programming language designed to manage TON smart contracts. The Fift assembler is a Fift library that converts mnemonics of TVM instructions into their binary representation.

A description of Fift, including an introduction to the Fift assembler, can be found here.

This document specifies the corresponding mnemonic for each instruction.

Note the following:

Fift is a stack-based language, therefore all the arguments of any instruction are written before it (e.g. 5 PUSHINT, s0 s4 XCHG).
Stack registers are denoted by s0, s1, ..., s15. Other stack registers (up to 255) are denoted by i s() (e.g. 100 s()).
Control registers are denoted by c0, c1, ..., c15.

Gas prices

The gas price of each instruction is specified in this document. The basic gas price of an instruction is 10 + b, where b is the instruction length in bits. Some operations have additional fees:

Parsing cells: Transforming a cell into a slice costs 100 gas units if the cell is loading for the first time and 25 for subsequent loads during the same transaction. For such instructions, two gas prices are specified (e.g. CTOS: 118/43).
Cell creation: 500 gas units.
Throwing exceptions: 50 gas units. In this document the exception fee is only specified for an instruction if its primary purpose is to throw (e.g. THROWIF, FITS). If the instruction only throws in some cases, two gas prices are specified (e.g. FITS: 26/76).
Tuple creation: 1 gas unit for every tuple element.
Implicit jumps: 10 gas units for an implicit jump, 5 gas units for an implicit back jump. This fee is not a part of any instruction.
Moving stack elements between continuations: 1 gas unit per element, however moving the first 32 elements is free.

Quick search

信息

A full machine-readable list of TVM instructions is available here.

Each section of TVM Instructions includes a built-in search component for finding opcodes specific to that section as well.

On this page, however, the search covers all existing opcodes, providing a comprehensive search option across the entire opcode range.

Feel free to use the search field below to find a specific instruction:

Opcode	Fift syntax	Stack	Description	Gas
`0i`	`s[i] XCHG0`		Interchanges `s0` with `s[i]`, `1 <= i <= 15`.	`18`
`2i`	`s[i] PUSH`		Pushes a copy of the old `s[i]` into the stack.	`18`
`D3cc`	`[cc+1] LDU`	`s - x s'`	Loads an unsigned `cc+1`-bit integer `x` from Slice `s`.	`26`
`82lxxx`	`[xxx] PUSHINT [xxx] INT`	`- xxx`	Pushes integer `xxx`. Details: 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`. The total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.	`23`
`BA`	`EQUAL`	`x y - x=y`	Returns `-1` if `x=y`, `0` otherwise.	`18`
`F2E4_n`	`[n] THROWIFNOT`	`f -`	For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.	`34/84`
`81xxxx`	`[xxxx] PUSHINT [xxxx] INT`	`- xxxx`	Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.	`34`
`3i`	`s[i] POP`		Pops the old `s0` value into the old `s[i]`.	`18`
`9xccc`	`[builder] PUSHCONT [builder] CONT`	`- c`	Pushes a continuation made from `builder`. Details: Pushes an `x`-byte continuation for `0 <= x <= 15`.	`18`
`CBcc`	`[cc+1] STU`	`x b - b'`	Stores an unsigned `cc+1`-bit integer `x` into Builder `b`. In all other respects it is similar to `STI`.	`26`
`7i`	`[x] PUSHINT [x] INT`	`- x`	Pushes integer `x` into the stack. `-5 <= x <= 10`. Here `i` equals four lower-order bits of `x` (`i=x mod 16`).	`18`
`E0`	`IFJMP`	`f c -`	Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.	`18`
`D0`	`CTOS`	`c - s`	Converts a Cell into a Slice. Notice that `c` must be either an ordinary cell, or an exotic cell which is automatically loaded to yield an ordinary cell `c'`, converted into a Slice afterwards.	`118/43`
`FA40`	`LDMSGADDR`	`s - s' s''`	Loads from Slice `s` the only prefix that is a valid `MsgAddress`, and returns both this prefix `s'` and the remainder `s''` of `s` as slices.	`26`
`C8`	`NEWC`	`- b`	Creates a new empty Builder.	`18`
`1i`	`s1 s[i] XCHG`		Interchanges `s1` with `s[i]`, `2 <= i <= 15`.	`18`
`C9`	`ENDC`	`b - c`	Converts a Builder into an ordinary Cell.	`518`
`DB3C`	`[ref] CALLREF`		Equivalent to `PUSHREFCONT` `CALLX`.	`126/51`
`F85_k`	`[k] GETGLOB`	`- x`	Returns the `k`-th global variable for `1 <= k <= 31`. Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.	`26`
`ED5i`	`c[i] POPCTR c[i] POP`	`x -`	Pops a value `x` from the stack and stores it into control register `c(i)`, if supported in the current codepage. Notice that if a control register accepts only values of a specific type, a type-checking exception may occur.	`26`
`CF16`	`STSLICER`	`b s - b'`	Equivalent to `SWAP` `STSLICE`.	`26`
`F82i`	`[i] GETPARAM`	`- x`	Returns the `i`-th parameter from the Tuple provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`. If one of these internal operations fails, throws an appropriate type checking or range checking exception.	`26`
`F87_k`	`[k] SETGLOB`	`x -`	Assigns `x` to the `k`-th global variable for `1 <= k <= 31`. Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.	`26+\|c7'\|`
`11ii`	`s0 [ii] s() XCHG`		Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.	`26`
`D4`	`LDREF`	`s - c s'`	Loads a cell reference `c` from `s`.	`18`
`F2A_n`	`[n] THROWIFNOT`	`f -`	Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.	`26/76`
`59`	`ROTREV -ROT`	`a b c - c a b`	Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.	`18`
`A4`	`INC`	`x - x+1`	Equivalent to `1 ADDCONST`.	`18`
`F26_n`	`[n] THROWIF`	`f -`	Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.	`26/76`
`F901`	`HASHSU`	`s - x`	Computes the hash of a Slice `s` and returns it as a 256-bit unsigned integer `x`. The result is the same as if an ordinary cell containing only data and references from `s` had been created and its hash computed by `HASHCU`.	`526`
`BE`	`GEQ`	`x y - x>=y`	Equivalent to `LESS` `NOT`.	`18`
`D718`	`LDSLICEX`	`s l - s'' s'`	Loads the first `0 <= l <= 1023` bits from Slice `s` into a separate Slice `s''`, returning the remainder of `s` as `s'`.	`26`
`F800`	`ACCEPT`	`-`	Sets current gas limit `g_l` to its maximal allowed value `g_m`, and resets the gas credit `g_c` to zero, decreasing the value of `g_r` by `g_c` in the process. In other words, the current smart contract agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves.	`26`
`F910`	`CHKSIGNU`	`h s k - ?`	Checks the Ed25519-signature `s` of a hash `h` (a 256-bit unsigned integer, usually computed as the hash of some data) using public key `k` (also represented by a 256-bit unsigned integer). The signature `s` must be a Slice containing at least 512 data bits; only the first 512 bits are used. The result is `-1` if the signature is valid, `0` otherwise. Notice that `CHKSIGNU` is equivalent to `ROT` `NEWC` `256 STU` `ENDC` `ROTREV` `CHKSIGNS`, i.e., to `CHKSIGNS` with the first argument `d` set to 256-bit Slice containing `h`. Therefore, if `h` is computed as the hash of some data, these data are hashed twice, the second hashing occurring inside `CHKSIGNS`.	`26`
`50ij`	`s[i] s[j] XCHG2`		Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.	`26`
`D74E_n`	`[n] PLDREFIDX`	`s - c`	Returns the `n`-th cell reference of Slice `s`, where `0 <= n <= 3`.	`26`
`FFnn`	`[nn] SETCP`	`-`	Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.	`26`
`DD`	`IFNOTRET IF:`	`f -`	Performs a `RET`, but only if integer `f` is zero.	`18`
`FA00`	`LDGRAMS LDVARUINT16`	`s - x s'`	Loads (deserializes) a `Gram` or `VarUInteger 16` amount from Slice `s`, and returns the amount as Integer `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`. The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.	`26`
`ED4i`	`c[i] PUSHCTR c[i] PUSH`	`- x`	Pushes the current value of control register `c(i)`. If the control register is not supported in the current codepage, or if it does not have a value, an exception is triggered.	`26`
`CC`	`STREF`	`c b - b'`	Stores a reference to Cell `c` into Builder `b`.	`18`
`F0nn`	`[nn] CALL [nn] CALLDICT`	`- nn`	Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument. Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.
`FA02`	`STGRAMS STVARUINT16`	`b x - b'`	Stores (serializes) an Integer `x` in the range `0...2^120-1` into Builder `b`, and returns the resulting Builder `b'`. The serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.	`26`
`10ij`	`s[i] s[j] XCHG`		Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.	`26`
`8F_rxxcccc`	`[builder] PUSHCONT [builder] CONT`	`- c`	Pushes a continuation made from `builder`. Details: Pushes the simple ordinary continuation `cccc` made from the first `0 <= r <= 3` references and the first `0 <= xx <= 127` bytes of `cc.code`.	`26`
`6Cij`	`[i] [j] BLKDROP2`		Drops `i` stack elements under the top `j` elements. `1 <= i <= 15`, `0 <= j <= 15` Equivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.	`26`
`83xx`	`[xx+1] PUSHPOW2`	`- 2^(xx+1)`	(Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`. `2^256` is a `NaN`.	`26`
`80xx`	`[xx] PUSHINT [xx] INT`	`- xx`	Pushes integer `xx`. `-128 <= xx <= 127`.	`26`
`F400`	`STDICT STOPTREF`	`D b - b'`	Stores dictionary `D` into Builder `b`, returning the resulting Builder `b'`. In other words, if `D` is a cell, performs `STONE` and `STREF`; if `D` is Null, performs `NIP` and `STZERO`; otherwise throws a type checking exception.	`26`
`C0yy`	`[yy] EQINT`	`x - x=yy`	Returns `-1` if `x=yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`5F0i`	`[i] BLKDROP`		Equivalent to `DROP` performed `i` times.	`26`
`F404`	`LDDICT LDOPTREF`	`s - D s'`	Loads (parses) a dictionary `D` from Slice `s`, and returns the remainder of `s` as `s'`. May be applied to dictionaries or to values of arbitrary `(^Y)?` types.	`26`
`58`	`ROT`	`a b c - b c a`	Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.	`18`
`D749`	`SBITS`	`s - l`	Returns the number of data bits in Slice `s`.	`26`
`52ij`	`s[i] s[j-1] PUXC`		Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.	`26`
`B0`	`AND`	`x y - x&y`	Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.	`18`
`D70Bcc`	`[cc+1] PLDU`	`s - x`	Preloads an unsigned `cc+1`-bit integer from `s`.	`34`
`E2`	`IFELSE`	`f c c' -`	If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.	`18`
`CAcc`	`[cc+1] STI`	`x b - b'`	Stores a signed `cc+1`-bit integer `x` into Builder `b` for `0 <= cc <= 255`, throws a range check exception if `x` does not fit into `cc+1` bits.	`26`
`A0`	`ADD`	`x y - x+y`		`18`
`55ij`	`[i+1] [j+1] BLKSWAP`		Permutes two blocks `s[j+i+1] ... s[j+1]` and `s[j] ... s0`. `0 <= i,j <= 15` Equivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.	`26`
`F2D4_n`	`[n] THROWIF`	`f -`	For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.	`34/84`
`E302`	`[ref] IFJMPREF`	`f -`	Equivalent to `PUSHREFCONT` `IFJMP`.	`26/126/51`
`A1`	`SUB`	`x y - x-y`		`18`
`4ijk`	`s[i] s[j] s[k] XCHG3`		Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.	`26`
`D2cc`	`[cc+1] LDI`	`s - x s'`	Loads (i.e., parses) a signed `cc+1`-bit integer `x` from Slice `s`, and returns the remainder of `s` as `s'`.	`26`
`FB00`	`SENDRAWMSG`	`c x -`	Sends a raw message contained in Cell `c`, which should contain a correctly serialized object `Message X`, with the only exception that the source address is allowed to have dummy value `addr_none` (to be automatically replaced with the current smart-contract address), and `ihr_fee`, `fwd_fee`, `created_lt` and `created_at` fields can have arbitrary values (to be rewritten with correct values during the action phase of the current transaction). Integer parameter `x` contains the flags. Currently `x=0` is used for ordinary messages; `x=128` is used for messages that are to carry all the remaining balance of the current smart contract (instead of the value originally indicated in the message); `x=64` is used for messages that carry all the remaining value of the inbound message in addition to the value initially indicated in the new message (if bit 0 is not set, the gas fees are deducted from this amount); `x'=x+1` means that the sender wants to pay transfer fees separately; `x'=x+2` means that any errors arising while processing this message during the action phase should be ignored. Finally, `x'=x+32` means that the current account must be destroyed if its resulting balance is zero. This flag is usually employed together with `+128`.	`526`
`C705`	`SDEQ`	`s s' - ?`	Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.	`26`
`53ij`	`s[i] s[j] PUSH2`		Equivalent to `s[i] PUSH` `s[j+1] PUSH`.	`26`
`D1`	`ENDS`	`s -`	Removes a Slice `s` from the stack, and throws an exception if it is not empty.	`18/68`
`57ii`	`[ii] s() POP`		Pops the old `s0` value into the old `s[ii]`. `0 <= ii <= 255`	`26`
`51ij`	`s[i] s[j] XCPU`		Equivalent to `s[i] XCHG0` `s[j] PUSH`.	`26`
`C2yy`	`[yy] GTINT [yy+1] GEQINT`	`x - x>yy`	Returns `-1` if `x>yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`C700`	`SEMPTY`	`s - ?`	Checks whether a Slice `s` is empty (i.e., contains no bits of data and no cell references).	`26`
`6F0n`	`[n] TUPLE`	`x_1 ... x_n - t`	Creates a new Tuple `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`. `0 <= n <= 15`	`26+n`
`8Drxxsssss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the subslice of `cc.code` consisting of `0 <= r <= 4` references and up to `8xx+6` bits of data, with `0 <= xx <= 127`. A completion tag is assumed.	`28`
`D721`	`SDSKIPFIRST`	`s l - s'`	Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.	`26`
`6FA1`	`NULLSWAPIFNOT`	`x - x or null x`	Pushes a Null under the topmost Integer `x`, but only if `x=0`. May be used for stack alignment after quiet primitives such as `PLDUXQ`.	`26`
`DE`	`IF`	`f c -`	Performs `EXECUTE` for `c` (i.e., executes `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.	`18`
`F900`	`HASHCU`	`c - x`	Computes the representation hash of a Cell `c` and returns it as a 256-bit unsigned integer `x`. Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.	`26`
`6D`	`NULL PUSHNULL`	`- null`	Pushes the only value of type Null.	`18`
`84xx`	`[xx+1] PUSHPOW2DEC`	`- 2^(xx+1)-1`	Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.	`26`
`545ijk`	`s[i] s[j-1] s[k-1] PUXCPU`		Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.	`34`
`A3`	`NEGATE`	`x - -x`	Equivalent to `-1 MULCONST` or to `ZERO SUBR`. Notice that it triggers an integer overflow exception if `x=-2^256`.	`18`
`A8`	`MUL`	`x y - x*y`		`18`
`F2F0`	`THROWANY`	`n - 0 n`	Throws exception `0 <= n < 2^16` with parameter zero. Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.	`76`
`541ijk`	`s[i] s[j] s[k] XC2PU`		Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.	`34`
`6E`	`ISNULL`	`x - ?`	Checks whether `x` is a Null, and returns `-1` or `0` accordingly.	`18`
`B1`	`OR`	`x y - x\|y`	Bitwise or of two integers.	`18`
`F40E`	`DICTUGET`	`i D n - x -1 or 0`	Similar to `DICTIGET`, but with unsigned (big-endian) `n`-bit Integer `i` used as a key.
`FA44`	`REWRITESTDADDR`	`s - x y`	Parses Slice `s` containing a valid `MsgAddressInt` (usually a `msg_addr_std`), applies rewriting from the `anycast` (if present) to the same-length prefix of the address, and returns both the workchain `x` and the 256-bit address `y` as integers. If the address is not 256-bit, or if `s` is not a valid serialization of `MsgAddressInt`, throws a cell deserialization exception.	`26`
`BC`	`GREATER`	`x y - x>y`		`18`
`5B`	`DROP2 2DROP`	`a b -`	Equivalent to `DROP` `DROP`.	`18`
`542ijk`	`s[i] s[j] s[k-1] XCPUXC`		Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.	`34`
`E30D`	`[ref] IFREFELSE`	`f c -`	Equivalent to `PUSHREFCONT` `SWAP` `IFELSE`, with the optimization that the cell reference is not actually loaded into a Slice and then converted into an ordinary Continuation if `f=0`. Similar remarks apply to the next two primitives: cells are converted into continuations only when necessary.	`26/126/51`
`A904`	`DIV`	`x y - q`	`q=floor(x/y)`, `r=x-y*q`	`26`
`56ii`	`[ii] s() PUSH`		Pushes a copy of the old `s[ii]` into the stack. `0 <= ii <= 255`	`26`
`8Bxsss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the (prefix) subslice of `cc.code` consisting of its first `8x+4` bits and no references (i.e., essentially a bitstring), where `0 <= x <= 15`. A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring. If the original bitstring consists only of zeroes, an empty slice will be pushed.	`22`
`B9`	`LESS`	`x y - x<y`	Returns `-1` if `x<y`, `0` otherwise.	`18`
`547ijk`	`s[i] s[j] s[k] PUSH3`		Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.	`34`
`B3`	`NOT`	`x - ~x`	Bitwise not of an integer.	`26`
`E6`	`UNTIL`	`c -`	Executes continuation `c`, then pops an integer `x` from the resulting stack. If `x` is zero, performs another iteration of this loop. The actual implementation of this primitive involves an extraordinary continuation `ec_until` with its arguments set to the body of the loop (continuation `c`) and the original current continuation `cc`. This extraordinary continuation is then saved into the savelist of `c` as `c.c0` and the modified `c` is then executed. The other loop primitives are implemented similarly with the aid of suitable extraordinary continuations.	`18`
`F2F4`	`THROWANYIFNOT`	`n f -`	Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.	`26/76`
`C1yy`	`[yy] LESSINT [yy-1] LEQINT`	`x - x<yy`	Returns `-1` if `x<yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`C3yy`	`[yy] NEQINT`	`x - x!=yy`	Returns `-1` if `x!=yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`EDFB`	`SAMEALTSAVE`	`-`	Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`. Equivalent to `c1 SAVE` `SAMEALT`.	`26`
`CF00`	`STIX`	`x b l - b'`	Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.	`26`
`BB`	`LEQ`	`x y - x<=y`		`18`
`AAcc`	`[cc+1] LSHIFT#`	`x - x*2^(cc+1)`	`0 <= cc <= 255`	`26`
`E8`	`WHILE`	`c' c -`	Executes `c'` and pops an integer `x` from the resulting stack. If `x` is zero, exists the loop and transfers control to the original `cc`. If `x` is non-zero, executes `c`, and then begins a new iteration.	`18`
`EDAi`	`c[i] SAVE c[i] SAVECTR`		Saves the current value of `c(i)` into the savelist of continuation `c0`. If an entry for `c[i]` is already present in the savelist of `c0`, nothing is done. Equivalent to `c[i] PUSHCTR` `c[i] SETRETCTR`.	`26`
`5A`	`SWAP2 2SWAP`	`a b c d - c d a b`	Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.	`18`
`D8`	`EXECUTE CALLX`	`c -`	Calls, or executes, continuation `c`.	`18`
`6F2n`	`[n] UNTUPLE`	`t - x_1 ... x_n`	Unpacks a Tuple `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`. If `t` is not a Tuple, or if `\|t\| != n`, a type check exception is thrown.	`26+n`
`A9B4tt`	`[tt+1] MULRSHIFT#`	`x y - floor(x*y/2^(tt+1))`		`34`
`FEij`	`{i*16+j} DEBUG`	`-`		`26`
`E300`	`[ref] IFREF`	`f -`	Equivalent to `PUSHREFCONT` `IF`, with the optimization that the cell reference is not actually loaded into a Slice and then converted into an ordinary Continuation if `f=0`. Gas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before. Similar remarks apply other primitives that accept a continuation as a reference.	`26/126/51`
`8A`	`[ref] PUSHREFCONT`	`- cont`	Similar to `PUSHREFSLICE`, but makes a simple ordinary Continuation out of the cell.	`118/43`
`6F1k`	`[k] INDEX`	`t - x`	Returns the `k`-th element of a Tuple `t`. `0 <= k <= 15`.	`26`
`A984`	`MULDIV`	`x y z - q`	`q=floor(x*y/z)`	`26`
`89`	`[ref] PUSHREFSLICE`	`- s`	Similar to `PUSHREF`, but converts the cell into a Slice.	`118/43`
`BD`	`NEQ`	`x y - x!=y`	Equivalent to `EQUAL` `NOT`.	`18`
`ABcc`	`[cc+1] RSHIFT#`	`x - floor(x/2^(cc+1))`	`0 <= cc <= 255`	`18`
`F417`	`DICTUSETREF`	`c i D n - D'`	Similar to `DICTISETREF`, but with `i` unsigned.
`CF01`	`STUX`	`x b l - b'`	Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.	`26`
`A6cc`	`[cc] ADDCONST [cc] ADDINT [-cc] SUBCONST [-cc] SUBINT`	`x - x+cc`	`-128 <= cc <= 127`.	`26`
`F443`	`DICTUSETB`	`b i D n - D'`
`B608`	`MIN`	`x y - x or y`	Computes the minimum of two integers `x` and `y`.	`26`
`66`	`TUCK`	`a b - b a b`	Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.	`18`
`5C`	`DUP2 2DUP`	`a b - a b a b`	Equivalent to `s1 s0 PUSH2`.	`18`
`E1`	`IFNOTJMP`	`f c -`	Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.	`18`
`F40A`	`DICTGET`	`k D n - x -1 or 0`	Looks up key `k` (represented by a Slice, the first `0 <= n <= 1023` data bits of which are used as a key) in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the value found as a Slice `x`.
`E30F`	`[ref] [ref] IFREFELSEREF`	`f -`	Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.	`126/51`
`546ijk`	`s[i] s[j-1] s[k-2] PU2XC`		Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.	`34`
`F40F`	`DICTUGETREF`	`i D n - c -1 or 0`	Similar to `DICTIGETREF`, but with an unsigned `n`-bit Integer key `i`.
`543ijk`	`s[i] s[j] s[k] XCPU2`		Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.	`34`
`6FA5`	`NULLSWAPIFNOT2`	`x - x or null null x`	Pushes two nulls under the topmost Integer `x`, but only if `x=0`. Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.	`26`
`A985`	`MULDIVR`	`x y z - q'`	`q'=round(x*y/z)`	`26`
`E30E`	`[ref] IFELSEREF`	`f c -`	Equivalent to `PUSHREFCONT` `IFELSE`.	`26/126/51`
`DC`	`IFRET IFNOT:`	`f -`	Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.	`18`
`DF`	`IFNOT`	`f c -`	Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.	`18`
`F836`	`GETGASFEE`	`gas_used is_mc - price`	Calculates gas fee
`E4`	`REPEAT`	`n c -`	Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception. Notice that a `RET` inside the code of `c` works as a `continue`, not as a `break`. One should use either alternative (experimental) loops or alternative `RETALT` (along with a `SETEXITALT` before the loop) to `break` out of a loop.	`18`
`CF31`	`BBITS`	`b - x`	Returns the number of data bits already stored in Builder `b`.	`26`
`FB02`	`RAWRESERVE`	`x y -`	Creates an output action which would reserve exactly `x` nanograms (if `y=0`), at most `x` nanograms (if `y=2`), or all but `x` nanograms (if `y=1` or `y=3`), from the remaining balance of the account. It is roughly equivalent to creating an outbound message carrying `x` nanograms (or `b-x` nanograms, where `b` is the remaining balance) to oneself, so that the subsequent output actions would not be able to spend more money than the remainder. Bit `+2` in `y` means that the external action does not fail if the specified amount cannot be reserved; instead, all remaining balance is reserved. Bit `+8` in `y` means `x:=-x` before performing any further actions. Bit `+4` in `y` means that `x` is increased by the original balance of the current account (before the compute phase), including all extra currencies, before performing any other checks and actions. Currently `x` must be a non-negative integer, and `y` must be in the range `0...15`.	`526`
`544ijk`	`s[i] s[j-1] s[k-1] PUXC2`		Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.	`34`
`ED6i`	`c[i] SETCONT c[i] SETCONTCTR`	`x c - c'`	Stores `x` into the savelist of continuation `c` as `c(i)`, and returns the resulting continuation `c'`. Almost all operations with continuations may be expressed in terms of `SETCONTCTR`, `POPCTR`, and `PUSHCTR`.	`26`
`CF17`	`STBR BCONCAT`	`b b' - b''`	Concatenates two builders. Equivalent to `SWAP` `STB`.	`26`
`D74A`	`SREFS`	`s - r`	Returns the number of references in Slice `s`.	`26`
`F416`	`DICTUSET`	`x i D n - D'`	Similar to `DICTISET`, but with `i` an unsigned `n`-bit integer.
`F80F`	`COMMIT`	`-`	Commits the current state of registers `c4` (''persistent data'') and `c5` (''actions'') so that the current execution is considered ''successful'' with the saved values even if an exception is thrown later.	`26`
`A7cc`	`[cc] MULCONST [cc] MULINT`	`x - x*cc`	`-128 <= cc <= 127`.	`26`
`F2F2`	`THROWANYIF`	`n f -`	Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.	`26/76`
`F815`	`ADDRAND RANDOMIZE`	`x -`	Mixes unsigned 256-bit Integer `x` into the random seed `r` by setting the random seed to `Sha` of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed `r`, and the second with the big-endian representation of `x`.	`26`
`88`	`[ref] PUSHREF`	`- c`	Pushes the reference `ref` into the stack. Details: Pushes the first reference of `cc.code` into the stack as a Cell (and removes this reference from the current continuation).	`18`
`F405`	`PLDDICT PLDOPTREF`	`s - D`	Preloads a dictionary `D` from Slice `s`. Approximately equivalent to `LDDICT` `DROP`.	`26`
`F833`	`CONFIGOPTPARAM`	`i - c^?`	Returns the value of the global configuration parameter with integer index `i` as a Maybe Cell `c^?`. Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.
`A5`	`DEC`	`x - x-1`	Equivalent to `-1 ADDCONST`.	`18`
`F2C4_n`	`[n] THROW`	`- 0 nn`	For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.	`84`
`6F8C`	`TPUSH COMMA`	`t x - t'`	Appends a value `x` to a Tuple `t=(x_1,...,x_n)`, but only if the resulting Tuple `t'=(x_1,...,x_n,x)` is of length at most 255. Otherwise throws a type check exception.	`26+\|t'\|`
`F838`	`GETFORWARDFEE`	`cells bits is_mc - price`	Calculates forward fee.
`5Eij`	`[i+2] [j] REVERSE`		Reverses the order of `s[j+i+1] ... s[j]`.	`26`
`F486`	`DICTUMIN`	`D n - x i -1 or 0`	Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit Integer `i`.
`6F88`	`TLEN`	`t - n`	Returns the length of a Tuple.	`26`
`F46B`	`DICTUGETOPTREF`	`i D n - c^?`	`DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns Null.
`F45B`	`DICTUDEL`	`i D n - D' ?`	Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.
`A908`	`MOD`	`x y - r`		`26`
`C701`	`SDEMPTY`	`s - ?`	Checks whether Slice `s` has no bits of data.	`26`
`A938tt`	`[tt+1] MODPOW2#`	`x - x mod 2^(tt+1)`		`34`
`F466`	`DICTUDELGET`	`i D n - D' x -1 or D 0`	`DICTDELGET`, but with `i` an unsigned `n`-bit integer.
`F811`	`RAND`	`y - z`	Generates a new pseudo-random integer `z` in the range `0...y-1` (or `y...-1`, if `y<0`). More precisely, an unsigned random value `x` is generated as in `RAND256U`; then `z:=floor(x*y/2^256)` is computed. Equivalent to `RANDU256` `256 MULRSHIFT`.	`26+\|c7\|+\|c1_1\|`
`B609`	`MAX`	`x y - x or y`	Computes the maximum of two integers `x` and `y`.	`26`
`D6cc`	`[cc+1] LDSLICE`	`s - s'' s'`	Cuts the next `cc+1` bits of `s` into a separate Slice `s''`.	`26`
`F401`	`SKIPDICT SKIPOPTREF`	`s - s'`	Equivalent to `LDDICT` `NIP`.	`26`
`F810`	`RANDU256`	`- x`	Generates a new pseudo-random unsigned 256-bit Integer `x`. The algorithm is as follows: if `r` is the old value of the random seed, considered as a 32-byte array (by constructing the big-endian representation of an unsigned 256-bit integer), then its `sha512(r)` is computed; the first 32 bytes of this hash are stored as the new value `r'` of the random seed, and the remaining 32 bytes are returned as the next random value `x`.	`26+\|c7\|+\|c1_1\|`
`EDF1`	`COMPOSALT BOOLOR`	`c c' - c''`	Computes the alternative composition `compose1(c, c')`, which has the meaning of ''perform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.	`26`
`F2FF`	`TRY`	`c c' -`	Sets `c2` to `c'`, first saving the old value of `c2` both into the savelist of `c'` and into the savelist of the current continuation, which is stored into `c.c0` and `c'.c0`. Then runs `c` similarly to `EXECUTE`. If `c` does not throw any exceptions, the original value of `c2` is automatically restored on return from `c`. If an exception occurs, the execution is transferred to `c'`, but the original value of `c2` is restored in the process, so that `c'` can re-throw the exception by `THROWANY` if it cannot handle it by itself.	`26`
`F22_n`	`[n] THROW`	`- 0 n`	Throws exception `0 <= n <= 63` with parameter zero. In other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.	`76`
`D70Acc`	`[cc+1] PLDI`	`s - x`	Preloads a signed `cc+1`-bit integer from Slice `s`.	`34`
`F441`	`DICTSETB`	`b k D n - D'`
`F902`	`SHA256U`	`s - x`	Computes `Sha` of the data bits of Slice `s`. If the bit length of `s` is not divisible by eight, throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.	`26`
`5D`	`OVER2 2OVER`	`a b c d - a b c d a b`	Equivalent to `s3 s2 PUSH2`.	`18`
`FA03`	`STVARINT16`	`b x - b'`	Similar to `STVARUINT16`, but serializes a signed Integer `x` in the range `-2^119...2^119-1`.	`26`
`AE`	`POW2`	`y - 2^y`	`0 <= y <= 1023` Equivalent to `ONE` `SWAP` `LSHIFT`.	`18`
`F47C`	`DICTUGETNEXT`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian unsigned `n`-bit integers, and computes the minimal key `i'` that is larger than Integer `i` (which does not necessarily fit into `n` bits, and is not necessarily non-negative).
`ED11`	`SETCONTVARARGS`	`x_1 x_2...x_r c r n - c'`	Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.	`26+s''`
`FB04`	`SETCODE`	`c -`	Creates an output action that would change this smart contract code to that given by Cell `c`. Notice that this change will take effect only after the successful termination of the current run of the smart contract.	`526`
`F83A`	`GETORIGINALFWDFEE`	`fwd_fee is_mc - orig_fwd_fee`	Calculate `fwd_fee * 2^16 / first_frac`. Can be used to get the original `fwd_fee` of the message.
`C702`	`SREMPTY`	`s - ?`	Checks whether Slice `s` has no references.	`26`
`DB0p`	`[p] -1 CALLXARGS`	`c -`	Calls continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.	`26`
`E303`	`[ref] IFNOTJMPREF`	`f -`	Equivalent to `PUSHREFCONT` `IFNOTJMP`.	`26/126/51`
`D719`	`PLDSLICEX`	`s l - s''`	Returns the first `0 <= l <= 1023` bits of `s` as `s''`.	`26`
`F801`	`SETGASLIMIT`	`g -`	Sets current gas limit `g_l` to the minimum of `g` and `g_m`, and resets the gas credit `g_c` to zero. If the gas consumed so far (including the present instruction) exceeds the resulting value of `g_l`, an (unhandled) out of gas exception is thrown before setting new gas limits. Notice that `SETGASLIMIT` with an argument `g >= 2^63-1` is equivalent to `ACCEPT`.	`26`
`6F81`	`INDEXVAR`	`t k - x`	Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.	`26`
`CF40`	`STZEROES`	`b n - b'`	Stores `n` binary zeroes into Builder `b`.	`26`
`D701`	`LDUX`	`s l - x s'`	Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.	`26`
`A906`	`DIVC`	`x y - q''`	`q''=ceil(x/y)`, `r''=x-y*q''`	`26`
`CE`	`STSLICE`	`s b - b'`	Stores Slice `s` into Builder `b`.	`18`
`F12_n`	`[n] CALL [n] CALLDICT`	`- n`	For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.
`D736`	`SPLIT`	`s l r - s' s''`	Splits the first `0 <= l <= 1023` data bits and first `0 <= r <= 4` references from `s` into `s'`, returning the remainder of `s` as `s''`.	`26`
`FA46`	`REWRITEVARADDR`	`s - x s'`	A variant of `REWRITESTDADDR` that returns the (rewritten) address as a Slice `s`, even if it is not exactly 256 bit long (represented by a `msg_addr_var`).	`26`
`F911`	`CHKSIGNS`	`d s k - ?`	Checks whether `s` is a valid Ed25519-signature of the data portion of Slice `d` using public key `k`, similarly to `CHKSIGNU`. If the bit length of Slice `d` is not divisible by eight, throws a cell underflow exception. The verification of Ed25519 signatures is the standard one, with `Sha` used to reduce `d` to the 256-bit number that is actually signed.	`26`
`F941`	`CDATASIZE`	`c n - x y z`	A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.
`B60B`	`ABS`	`x - \|x\|`	Computes the absolute value of an integer `x`.	`26`
`FA01`	`LDVARINT16`	`s - x s'`	Similar to `LDVARUINT16`, but loads a signed Integer `x`. Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.	`26`
`D700`	`LDIX`	`s l - x s'`	Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from Slice `s`, and returns the remainder of `s` as `s'`.	`26`
`A986`	`MULDIVC`	`x y z - q'`	`q'=ceil(x*y/z)`	`26`
`F48E`	`DICTUMAX`	`D n - x i -1 or 0`	Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit Integer `i`.
`F93010`	`BLS_G1_ADD`	`x y - x+y`	Addition on G1.	`3934`
`F93013`	`BLS_G1_MUL`	`x s - x*s`	Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.	`5234`
`F48F`	`DICTUMAXREF`	`D n - c i -1 or 0`	Similar to `DICTUMAX`, but returns the only reference in the value.
`C70B`	`SDPPFXREV`	`s s' - ?`	Checks whether `s'` is a proper prefix of `s`.	`26`
`F837`	`GETSTORAGEFEE`	`cells bits seconds is_mc - price`	Calculates storage fees (only current StoragePrices entry is used).
`D723`	`SDSKIPLAST`	`s l - s'`	Returns all but the last `0 <= l <= 1023` bits of `s`.	`26`
`F90403`	`HASHEXT_KECCAK256`	`s_1 ... s_n n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/11 gas per byte`
`D722`	`SDCUTLAST`	`s l - s'`	Returns the last `0 <= l <= 1023` bits of `s`.	`26`
`A90C`	`DIVMOD`	`x y - q r`		`26`
`F453`	`DICTUADDB`	`b i D n - D' -1 or D 0`
`F4A6_n`	`[ref] [n] DICTPUSHCONST`	`- D n`	Pushes a non-empty constant dictionary `D` (as a `Cell^?`) along with its key length `0 <= n <= 1023`, stored as a part of the instruction. The dictionary itself is created from the first of remaining references of the current continuation. In this way, the complete `DICTPUSHCONST` instruction can be obtained by first serializing `xF4A4_`, then the non-empty dictionary itself (one `1` bit and a cell reference), and then the unsigned 10-bit integer `n` (as if by a `STU 10` instruction). An empty dictionary can be pushed by a `NEWDICT` primitive instead.	`34`
`ED1E`	`BLESS`	`s - c`	Transforms a Slice `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.	`26`
`F940`	`CDATASIZEQ`	`c n - x y z -1 or 0`	Recursively computes the count of distinct cells `x`, data bits `y`, and cell references `z` in the dag rooted at Cell `c`, effectively returning the total storage used by this dag taking into account the identification of equal cells. The values of `x`, `y`, and `z` are computed by a depth-first traversal of this dag, with a hash table of visited cell hashes used to prevent visits of already-visited cells. The total count of visited cells `x` cannot exceed non-negative Integer `n`; otherwise the computation is aborted before visiting the `(n+1)`-st cell and a zero is returned to indicate failure. If `c` is Null, returns `x=y=z=0`.
`D74B`	`SBITREFS`	`s - l r`	Returns both the number of data bits and the number of references in `s`.	`26`
`D5`	`LDREFRTOS`	`s - s' s''`	Equivalent to `LDREF` `SWAP` `CTOS`.	`118/43`
`F839`	`GETPRECOMPILEDGAS`	`- x`	Returns gas usage for the current contract if it is precompiled, `null` otherwise.
`D724`	`SDSUBSTR`	`s l l' - s'`	Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.	`26`
`CF13`	`STB`	`b' b - b''`	Appends all data from Builder `b'` to Builder `b`.	`26`
`F487`	`DICTUMINREF`	`D n - c i -1 or 0`	Similar to `DICTUMIN`, but returns the only reference in the value.
`F83C`	`GETFORWARDFEESIMPLE`	`cells bits is_mc - price`	Same as `GETFORWARDFEE`, but without lump price (just (`bitsbit_price + cellscell_price) / 2^16`).
`F4A1`	`DICTUGETJMP`	`i D n -`	Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.
`D739`	`XCTOS`	`c - s ?`	Transforms an ordinary or exotic cell into a Slice, as if it were an ordinary cell. A flag is returned indicating whether `c` is exotic. If that be the case, its type can later be deserialized from the first eight bits of `s`.
`F40D`	`DICTIGETREF`	`i D n - c -1 or 0`	Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit Integer `i` as a key and returns a Cell instead of a Slice on success.
`F807`	`GASCONSUMED`	`- g_c`	Returns gas consumed by VM so far (including this instruction).	`26`
`DApr`	`[p] [r] CALLXARGS`	`c -`	Calls continuation `c` with `p` parameters and expecting `r` return values `0 <= p <= 15`, `0 <= r <= 15`	`26`
`F40C`	`DICTIGET`	`i D n - x -1 or 0`	Similar to `DICTGET`, but with a signed (big-endian) `n`-bit Integer `i` as a key. If `i` does not fit into `n` bits, returns `0`. If `i` is a `NaN`, throws an integer overflow exception.
`F4A8`	`PFXDICTGETQ`	`s D n - s' x s'' -1 or s 0`	Looks up the unique prefix of Slice `s` present in the prefix code dictionary represented by `Cell^?` `D` and `0 <= n <= 1023`. If found, the prefix of `s` is returned as `s'`, and the corresponding value (also a Slice) as `x`. The remainder of `s` is returned as a Slice `s''`. If no prefix of `s` is a key in prefix code dictionary `D`, returns the unchanged `s` and a zero flag to indicate failure.
`F814`	`SETRAND`	`x -`	Sets the random seed to unsigned 256-bit Integer `x`.	`26+\|c7\|+\|c1_1\|`
`F47F`	`DICTUGETPREVEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.
`B2`	`XOR`	`x y - x xor y`	Bitwise xor of two integers.	`18`
`F912`	`ECRECOVER`	`hash v r s - 0 or h x1 x2 -1`	Recovers the public key from a secp256k1 signature, identical to Bitcoin/Ethereum operations. Takes a 32-byte hash as `uint256 hash` and a 65-byte signature as `uint8 v`, `uint256 r`, and `uint256 s`. In TON, the `v` value is strictly 0 or 1; no extra flags or extended values are supported. If the public key cannot be recovered, the instruction returns `0`. On success, it returns the recovered 65-byte public key as `uint8 h`, `uint256 x1`, and `uint256 x2`, followed by `-1`.	`1526`
`E301`	`[ref] IFNOTREF`	`f -`	Equivalent to `PUSHREFCONT` `IFNOT`.	`26/126/51`
`F46A`	`DICTIGETOPTREF`	`i D n - c^?`	`DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns Null.
`F482`	`DICTMIN`	`D n - x k -1 or 0`	Computes the minimal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
`F40B`	`DICTGETREF`	`k D n - c -1 or 0`	Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success. This operation is useful for dictionaries of type `HashmapE(n,^Y)`.
`F470`	`PFXDICTSET`	`x k D n - D' -1 or D 0`
`A98C`	`MULDIVMOD`	`x y z - q r`	`q=floor(xy/z)`, `r=xy-z*q`	`26`
`D703`	`PLDUX`	`s l - x`	Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.	`26`
`6F8D`	`TPOP`	`t - t' x`	Detaches the last element `x=x_n` from a non-empty Tuple `t=(x_1,...,x_n)`, and returns both the resulting Tuple `t'=(x_1,...,x_{n-1})` and the original last element `x`.	`26+\|t'\|`
`F93012`	`BLS_G1_NEG`	`x - -x`	Negation on G1.	`784`
`F93030`	`BLS_PAIRING`	`x_1 y_1 ... x_n y_n n - bool`	Given G1 points `x_i` and G2 points `y_i`, calculates and multiply pairings of `x_i,y_i`. Returns true if the result is the multiplicative identity in FP12, false otherwise. Returns false if `n=0`.	`20034+n*11800`
`B603`	`UBITSIZE`	`x - c`	Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.	`26`
`D9`	`JMPX`	`c -`	Jumps, or transfers control, to continuation `c`. The remainder of the previous current continuation `cc` is discarded.	`18`
`F4A0`	`DICTIGETJMP`	`i D n -`	Similar to `DICTIGET`, but with `x` `BLESS`ed into a continuation with a subsequent `JMPX` to it on success. On failure, does nothing. This is useful for implementing `switch`/`case` constructions.
`F44B`	`DICTUREPLACEB`	`b i D n - D' -1 or D 0`
`F1A_n`	`[n] PREPARE [n] PREPAREDICT`	`- n c`	Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`. In this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`. One might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.
`F415`	`DICTISETREF`	`c i D n - D'`	Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.
`C704`	`SDLEXCMP`	`s s' - x`	Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.	`26`
`F90400`	`HASHEXT_SHA256`	`s_1 ... s_n n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/33 gas per byte`
`F496`	`DICTUREMMIN`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit Integer `i`.
`F41E`	`DICTUSETGET`	`x i D n - D' y -1 or D' 0`	`DICTISETGET`, but with `i` an unsigned `n`-bit integer.
`F497`	`DICTUREMMINREF`	`D n - D' c i -1 or D 0`	Similar to `DICTUREMMIN`, but returns the only reference in the value.
`FA42`	`PARSEMSGADDR`	`s - t`	Decomposes Slice `s` containing a valid `MsgAddress` into a Tuple `t` with separate fields of this `MsgAddress`. If `s` is not a valid `MsgAddress`, a cell deserialization exception is thrown.	`26`
`6F85`	`SETINDEXVAR`	`t x k - t'`	Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.	`26+\|t'\|`
`00`	`NOP`	`-`	Does nothing.	`18`
`6F84`	`EXPLODEVAR`	`t n - x_1 ... x_m m`	Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.	`26+m`
`D765`	`CDEPTH`	`c - x`	Returns the depth of Cell `c`. If `c` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `c`. If `c` is a Null instead of a Cell, returns zero.	`26`
`FA41`	`LDMSGADDRQ`	`s - s' s'' -1 or s 0`	A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.	`26`
`B601`	`UFITSX`	`x c - x`	Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.	`26/76`
`AC`	`LSHIFT`	`x y - x*2^y`	`0 <= y <= 1023`	`18`
`F943`	`SDATASIZE`	`s n - x y z`	A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.
`A935tt`	`[tt+1] RSHIFTR#`	`x - round(x/2^(tt+1))`		`34`
`CFC0_xysss`	`[slice] STSLICECONST`	`b - b'`	Stores a constant subslice `sss`. Details: `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed. Note that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.	`24`
`FB06`	`SETLIBCODE`	`c x -`	Creates an output action that would modify the collection of this smart contract libraries by adding or removing library with code given in Cell `c`. If `x=0`, the library is actually removed if it was previously present in the collection (if not, this action does nothing). If `x=1`, the library is added as a private library, and if `x=2`, the library is added as a public library (and becomes available to all smart contracts if the current smart contract resides in the masterchain); if the library was present in the collection before, its public/private status is changed according to `x`. Values of `x` other than `0...2` are invalid.	`526`
`C4`	`ISNAN`	`x - x=NaN`	Checks whether `x` is a `NaN`.	`18`
`AD`	`RSHIFT`	`x y - floor(x/2^y)`	`0 <= y <= 1023`	`18`
`F83400`	`PREVMCBLOCKS`	`- t`	Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).
`83FF`	`PUSHNAN`	`- NaN`	Pushes a `NaN`.	`26`
`6F5k`	`[k] SETINDEX`	`t x - t'`	Computes Tuple `t'` that differs from `t` only at position `t'_{k+1}`, which is set to `x`. `0 <= k <= 15` If `k >= \|t\|`, throws a range check exception.	`26+\|t\|`
`F47E`	`DICTUGETPREV`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.
`F484`	`DICTIMIN`	`D n - x i -1 or 0`	Similar to `DICTMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMIN` and `DICTUMIN`.
`6F89`	`QTLEN`	`t - n or -1`	Similar to `TLEN`, but returns `-1` if `t` is not a Tuple.	`26`
`FB08`	`SENDMSG`	`c x - fee`	Creates an output action and returns a fee for creating a message. Mode has the same effect as in the case of `SENDRAWMSG`. Additionally `+1024` means - do not create an action, only estimate fee. Other modes affect the fee calculation as follows: `+64` substitutes the entire balance of the incoming message as an outcoming value (slightly inaccurate, gas expenses that cannot be estimated before the computation is completed are not taken into account), `+128` substitutes the value of the entire balance of the contract before the start of the computation phase (slightly inaccurate, since gas expenses that cannot be estimated before the completion of the computation phase are not taken into account).	`526`
`F436`	`DICTUADD`	`x i D n - D' -1 or D 0`	`DICTADD`, but with `i` an unsigned `n`-bit integer.
`E308`	`IFRETALT`	`f -`	Performs `RETALT` if integer `f!=0`.	`26`
`F83401`	`PREVKEYBLOCK`	`- t`	Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).
`A9B5tt`	`[tt+1] MULRSHIFTR#`	`x y - round(x*y/2^(tt+1))`		`34`
`F414`	`DICTISET`	`x i D n - D'`	Similar to `DICTSET`, but with the key represented by a (big-endian) signed `n`-bit integer `i`. If `i` does not fit into `n` bits, a range check exception is generated.
`F469`	`DICTGETOPTREF`	`k D n - c^?`	A variant of `DICTGETREF` that returns Null instead of the value `c^?` if the key `k` is absent from dictionary `D`.
`BF`	`CMP`	`x y - sgn(x-y)`	Computes the sign of `x-y`: `-1` if `x<y`, `0` if `x=y`, `1` if `x>y`. No integer overflow can occur here unless `x` or `y` is a `NaN`.	`18`
`F924`	`RIST255_MUL`	`x n - x*n`	Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.	`2026`
`D720`	`SDCUTFIRST`	`s l - s'`	Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.	`26`
`D764`	`SDEPTH`	`s - x`	Returns the depth of Slice `s`. If `s` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `s`.	`26`
`CF41`	`STONES`	`b n - b'`	Stores `n` binary ones into Builder `b`.	`26`
`F90600`	`HASHEXTA_SHA256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/33 gas per byte`
`F925`	`RIST255_MULBASE`	`n - g*n`	Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.	`776`
`F840`	`GETGLOBVAR`	`k - x`	Returns the `k`-th global variable for `0 <= k < 255`. Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.	`26`
`F45A`	`DICTIDEL`	`i D n - D' ?`	A version of `DICTDEL` with the key represented by a signed `n`-bit Integer `i`. If `i` does not fit into `n` bits, simply returns `D` `0` (''key not found, dictionary unmodified'').
`D72E_xsss`	`[slice] SDBEGINSQ`	`s - s'' -1 or s 0`	A quiet version of `SDBEGINS`.	`31`
`D732`	`SCUTLAST`	`s l r - s'`	Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.	`26`
`F467`	`DICTUDELGETREF`	`i D n - D' c -1 or D 0`	`DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.
`F407`	`PLDDICTQ`	`s - D -1 or 0`	A quiet version of `PLDDICT`.	`26`
`F462`	`DICTDELGET`	`k D n - D' x -1 or D 0`	Deletes `n`-bit key, represented by a Slice `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'`, the original value `x` associated with the key `k` (represented by a Slice), and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
`F83B`	`GETGASFEESIMPLE`	`gas_used is_mc - price`	Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.
`A936tt`	`[tt+1] RSHIFTC#`	`x - ceil(x/2^(tt+1))`		`34`
`C709`	`SDPFXREV`	`s s' - ?`	Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.	`26`
`B7A8`	`QMUL`	`x y - x*y`		`26`
`B7A98C`	`QMULDIVMOD`	`x y z - q r`		`34`
`F478`	`DICTIGETNEXT`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian signed `n`-bit integers, and computes the minimal key `i'` that is larger than Integer `i` (which does not necessarily fit into `n` bits).
`F412`	`DICTSET`	`x k D n - D'`	Sets the value associated with `n`-bit key `k` (represented by a Slice as in `DICTGET`) in dictionary `D` (also represented by a Slice) to value `x` (again a Slice), and returns the resulting dictionary as `D'`.
`D751`	`LDULE4`	`s - x s'`	Loads a little-endian unsigned 32-bit integer.	`26`
`F413`	`DICTSETREF`	`c k D n - D'`	Similar to `DICTSET`, but with the value set to a reference to Cell `c`.
`F437`	`DICTUADDREF`	`c i D n - D' -1 or D 0`	`DICTADDREF`, but with `i` an unsigned `n`-bit integer.
`F835`	`GLOBALID`	`- i`	Retrieves `global_id` from 19 network config.
`C713`	`SDCNTTRAIL1`	`s - n`	Returns the number of trailing ones in `s`.	`26`
`CF11`	`STBREF`	`b' b - b''`	Equivalent to `SWAP` `STBREFR`.	`526`
`DB35`	`JMPXDATA`	`c -`	Similar to `CALLCC`, but the remainder of the current continuation (the old value of `cc`) is converted into a Slice before pushing it into the stack of `c`.	`26`
`CF23`	`ENDXC`	`b x - c`	If `x!=0`, creates a special or exotic cell from Builder `b`. The type of the exotic cell must be stored in the first 8 bits of `b`. If `x=0`, it is equivalent to `ENDC`. Otherwise some validity checks on the data and references of `b` are performed before creating the exotic cell.	`526`
`A9D6tt`	`[tt+1] LSHIFT#DIVC`	`x y - ceil(2^(tt+1)*x/y)`		`26`
`F90401`	`HASHEXT_SHA512`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/16 gas per byte`
`F920`	`RIST255_FROMHASH`	`h1 h2 - x`	Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).	`626`
`F926`	`RIST255_PUSHL`	`- l`	Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.	`26`
`F923`	`RIST255_SUB`	`x y - x-y`	Subtraction of two points on curve.	`626`
`F485`	`DICTIMINREF`	`D n - c i -1 or 0`	Similar to `DICTIMIN`, but returns the only reference in the value.
`D714_c`	`[32(c+1)] PLDUZ`	`s - s x`	Preloads the first `32(c+1)` bits of Slice `s` into an unsigned integer `x`, for `0 <= c <= 7`. If `s` is shorter than necessary, missing bits are assumed to be zero. This operation is intended to be used along with `IFBITJMP` and similar instructions.	`26`
`F4BC`	`DICTIGETJMPZ`	`i D n - i or nothing`	A variant of `DICTIGETJMP` that returns index `i` on failure.
`F2CC_n`	`[n] THROWARG`	`x - x nn`	Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.	`84`
`F435`	`DICTIADDREF`	`c i D n - D' -1 or D 0`	`DICTADDREF`, but with `i` a signed `n`-bit integer.
`8Crxxssss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the (prefix) subslice of `cc.code` consisting of its first `1 <= r+1 <= 4` references and up to first `8xx+1` bits of data, with `0 <= xx <= 31`. A completion tag is also assumed.	`25`
`F47B`	`DICTIGETPREVEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.
`D71Dcc`	`[cc+1] PLDSLICE`	`s - s''`	Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.	`34`
`F451`	`DICTADDB`	`b k D n - D' -1 or D 0`
`A9D5tt`	`[tt+1] LSHIFT#DIVR`	`x y - round(2^(tt+1)*x/y)`		`34`
`DB4fff`	`flags RUNVM`	`x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]`	Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
`A9BD`	`MULRSHIFTR#MOD`	`x y - q=round(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9CD`	`LSHIFTDIVMODR`	`x y z - q=round(2^zx/y) r=2^zx-q*y`		`26`
`A925`	`RSHIFTR`	`x y - round(x/2^y)`		`26`
`B5cc`	`[cc+1] UFITS`	`x - x`	Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).	`26/76`
`A905`	`DIVR`	`x y - q'`	`q'=round(x/y)`, `r'=x-y*q'`	`26`
`B8`	`SGN`	`x - sgn(x)`	Computes the sign of an integer `x`: `-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.	`18`
`CF0Bcc`	`[cc+1] STUR`	`b x - b'`	Equivalent to `SWAP` `[cc+1] STU`.	`34`
`D72A_xsss`	`[slice] SDBEGINS`	`s - s''`	Checks whether `s` begins with constant bitstring `sss` of length `8x+3` (with continuation bit assumed), where `0 <= x <= 127`, and removes `sss` from `s` on success.	`31`
`C703`	`SDFIRST`	`s - ?`	Checks whether the first bit of Slice `s` is a one.	`26`
`F921`	`RIST255_VALIDATE`	`x -`	Checks that integer `x` is a valid representation of some curve point. Throws range_chk on error.	`226`
`CF3D`	`BCHKBITSQ`	`b x - ?`	Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.	`26`
`F475`	`DICTGETNEXTEQ`	`k D n - x' k' -1 or 0`	Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.
`CF29`	`STULE4`	`x b - b'`	Stores a little-endian unsigned 32-bit integer.	`26`
`F459`	`DICTDEL`	`k D n - D' -1 or D 0`	Deletes `n`-bit key, represented by a Slice `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'` and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
`F47D`	`DICTUGETNEXTEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.
`E309`	`IFNOTRETALT`	`f -`	Performs `RETALT` if integer `f=0`.	`26`
`D705`	`LDUXQ`	`s l - x s' -1 or s 0`	Quiet version of `LDUX`.	`26`
`F48A`	`DICTMAX`	`D n - x k -1 or 0`	Computes the maximal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
`CF0Acc`	`[cc+1] STIR`	`b x - b'`	Equivalent to `SWAP` `[cc+1] STI`.	`34`
`C710`	`SDCNTLEAD0`	`s - n`	Returns the number of leading zeroes in `s`.	`26`
`EB`	`AGAINEND AGAIN:`	`-`	Similar to `AGAIN`, but performed with respect to the current continuation `cc`.	`18`
`F442`	`DICTISETB`	`b i D n - D'`
`F424`	`DICTIREPLACE`	`x i D n - D' -1 or D 0`	`DICTREPLACE`, but with `i` a signed `n`-bit integer.
`85xx`	`[xx+1] PUSHNEGPOW2`	`- -2^(xx+1)`	Pushes `-2^(xx+1)` for `0 <= xx <= 255`.	`26`
`CF14`	`STREFR`	`b c - b'`	Equivalent to `SWAP` `STREF`.	`26`
`F93014`	`BLS_G1_MULTIEXP`	`x_1 s_1 ... x_n s_n n - x_1s_1+...+x_ns_n`	Calculates `x_1s_1+...+x_ns_n` for G1 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.	`11409+n630+n/floor(max(log2(n),4))8820`
`FA45`	`REWRITESTDADDRQ`	`s - x y -1 or 0`	A quiet version of primitive `REWRITESTDADDR`.	`26`
`F914`	`P256_CHKSIGNU`	`h sig k - ?`	Checks seck256r1-signature `sig` of a number `h` (a 256-bit unsigned integer, usually computed as the hash of some data) and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).	`3526`
`ECrn`	`[r] [n] SETCONTARGS`	`x_1 x_2...x_r c - c'`	Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. When `n` is 15 (-1 in Fift notation), does nothing with `c.nargs`. For `0 <= n <= 14`, sets `c.nargs` to the final size of the stack of `c'` plus `n`. In other words, transforms `c` into a closure or a partially applied function, with `0 <= n <= 14` arguments missing.	`26+s''`
`63`	`BLKSWX`		Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.	`18`
`6F6k`	`[k] INDEXQ`	`t - x`	Returns the `k`-th element of a Tuple `t`, where `0 <= k <= 15`. In other words, returns `x_{k+1}` if `t=(x_1,...,x_n)`. If `k>=n`, or if `t` is Null, returns a Null instead of `x`.	`26`
`D73A`	`XLOAD`	`c - c'`	Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, throws an exception.
`60`	`PICK PUSHX`		Pops integer `i` from the stack, then performs `s[i] PUSH`.	`18`
`61`	`ROLLX`		Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.	`18`
`62`	`-ROLLX ROLLREVX`		Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.	`18`
`5Fij`	`[i] [j] BLKPUSH`		Equivalent to `PUSH s(j)` performed `i` times. `1 <= i <= 15`, `0 <= j <= 15`.	`26`
`64`	`REVX`		Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.	`18`
`65`	`DROPX`		Pops integer `i` from the stack, then performs `[i] BLKDROP`.	`18`
`67`	`XCHGX`		Pops integer `i` from the stack, then performs `s[i] XCHG`.	`18`
`68`	`DEPTH`	`- depth`	Pushes the current depth of the stack.	`18`
`69`	`CHKDEPTH`	`i -`	Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.	`18/58`
`6A`	`ONLYTOPX`		Pops integer `i` from the stack, then removes all but the top `i` elements.	`18`
`6B`	`ONLYX`		Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.	`18`
`EA`	`AGAIN`	`c -`	Similar to `REPEAT`, but executes `c` infinitely many times. A `RET` only begins a new iteration of the infinite loop, which can be exited only by an exception, or a `RETALT` (or an explicit `JMPX`).	`18`
`E31A`	`AGAINBRK`	`c -`	Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E31B`	`AGAINENDBRK AGAINBRK:`	`-`	Equivalent to `SAMEALTSAVE` `AGAINEND`.	`26`
`A900`	`ADDDIVMOD`	`x w z - q=floor((x+w)/z) r=(x+w)-zq`		`26`
`A901`	`ADDDIVMODR`	`x w z - q=round((x+w)/z) r=(x+w)-zq`		`26`
`A902`	`ADDDIVMODC`	`x w y - q=ceil((x+w)/z) r=(x+w)-zq`		`26`
`A930tt`	`[tt+1] ADDRSHIFT#MOD`	`x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`A921`	`ADDRSHIFTMODR`	`x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z`		`26`
`A922`	`ADDRSHIFTMODC`	`x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z`		`26`
`A90D`	`DIVMODR`	`x y - q' r'`		`26`
`A90E`	`DIVMODC`	`x y - q'' r''`		`26`
`6FBij`	`[i] [j] INDEX2`	`t - x`	Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`. Equivalent to `[i] INDEX` `[j] INDEX`.	`26`
`6FE_ijk`	`[i] [j] [k] INDEX3`	`t - x`	Recovers `x=t_{i+1}_{j+1}_{k+1}`. `0 <= i,j,k <= 3` Equivalent to `[i] [j] INDEX2` `[k] INDEX`.	`26`
`6F8A`	`ISTUPLE`	`t - ?`	Returns `-1` or `0` depending on whether `t` is a Tuple.	`26`
`540ijk`	`s[i] s[j] s[k] XCHG3_l`		Long form of `XCHG3`.	`34`
`6F3k`	`[k] UNPACKFIRST`	`t - x_1 ... x_k`	Unpacks first `0 <= k <= 15` elements of a Tuple `t`. If `\|t\|<k`, throws a type check exception.	`26+k`
`6F4n`	`[n] EXPLODE`	`t - x_1 ... x_m m`	Unpacks a Tuple `t=(x_1,...,x_m)` and returns its length `m`, but only if `m <= n <= 15`. Otherwise throws a type check exception.	`26+m`
`6F7k`	`[k] SETINDEXQ`	`t x - t'`	Sets the `k`-th component of Tuple `t` to `x`, where `0 <= k < 16`, and returns the resulting Tuple `t'`. If `\|t\| <= k`, first extends the original Tuple to length `n'=k+1` by setting all new components to Null. If the original value of `t` is Null, treats it as an empty Tuple. If `t` is not Null or Tuple, throws an exception. If `x` is Null and either `\|t\| <= k` or `t` is Null, then always returns `t'=t` (and does not consume tuple creation gas).	`26+\|t'\|`
`6F80`	`TUPLEVAR`	`x_1 ... x_n n - t`	Creates a new Tuple `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F82`	`UNTUPLEVAR`	`t n - x_1 ... x_n`	Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F83`	`UNPACKFIRSTVAR`	`t n - x_1 ... x_n`	Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F86`	`INDEXVARQ`	`t k - x`	Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.	`26`
`6F87`	`SETINDEXVARQ`	`t x k - t'`	Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.	`26+\|t'\|`
`6F8B`	`LAST`	`t - x`	Returns the last element of a non-empty Tuple `t`.	`26`
`6FA0`	`NULLSWAPIF`	`x - x or null x`	Pushes a Null under the topmost Integer `x`, but only if `x!=0`.	`26`
`6FA2`	`NULLROTRIF`	`x y - x y or null x y`	Pushes a Null under the second stack entry from the top, but only if the topmost Integer `y` is non-zero.	`26`
`6FA3`	`NULLROTRIFNOT`	`x y - x y or null x y`	Pushes a Null under the second stack entry from the top, but only if the topmost Integer `y` is zero. May be used for stack alignment after quiet primitives such as `LDUXQ`.	`26`
`6FA4`	`NULLSWAPIF2`	`x - x or null null x`	Pushes two nulls under the topmost Integer `x`, but only if `x!=0`. Equivalent to `NULLSWAPIF` `NULLSWAPIF`.	`26`
`6FA6`	`NULLROTRIF2`	`x y - x y or null null x y`	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer `y` is non-zero. Equivalent to `NULLROTRIF` `NULLROTRIF`.	`26`
`6FA7`	`NULLROTRIFNOT2`	`x y - x y or null null x y`	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer `y` is zero. Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.	`26`
`A2`	`SUBR`	`x y - y-x`	Equivalent to `SWAP` `SUB`.	`18`
`A909`	`MODR`	`x y - r`		`26`
`A90A`	`MODC`	`x y - r`		`26`
`A926`	`RSHIFTC`	`x y - ceil(x/2^y)`		`26`
`A928`	`MODPOW2`	`x y - x mod 2^y`		`26`
`A929`	`MODPOW2R`	`x y - x mod 2^y`		`26`
`A92A`	`MODPOW2C`	`x y - x mod 2^y`		`26`
`A92C`	`RSHIFTMOD`	`x y - q=floor(x/2^y) r=x-q*2^y`		`26`
`A92D`	`RSHIFTMODR`	`x y - q=round(x/2^y) r=x-q*2^y`		`26`
`A92E`	`RSHIFTMODC`	`x y - q=ceil(x/2^y) r=x-q*2^y`		`26`
`A931tt`	`[tt+1] ADDRSHIFTR#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`A932tt`	`[tt+1] ADDRSHIFTC#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`EDF3`	`ATEXIT`	`c -`	Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.	`26`
`EDF4`	`ATEXITALT`	`c -`	Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.	`26`
`CF33`	`BBITREFS`	`b - x y`	Returns the numbers of both data bits and cell references in `b`.	`26`
`CF3B`	`BCHKBITREFS`	`b x y -`	Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.	`26/76`
`CF3F`	`BCHKBITREFSQ`	`b x y - ?`	Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.	`26`
`CF38cc`	`[cc+1] BCHKBITS#`	`b -`	Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.	`34/84`
`CF3Ccc`	`[cc+1] BCHKBITSQ#`	`b - ?`	Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.	`34`
`CF39`	`BCHKBITS`	`b x -`	Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`. If there is no space for `x` more bits in `b`, or if `x` is not within the range `0...1023`, throws an exception.	`26/76`
`CF3A`	`BCHKREFS`	`b y -`	Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.	`26/76`
`CF3E`	`BCHKREFSQ`	`b y - ?`	Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.	`26`
`CF30`	`BDEPTH`	`b - x`	Returns the depth of Builder `b`. If no cell references are stored in `b`, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `b`.	`26`
`B602`	`BITSIZE`	`x - c`	Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).	`26`
`EErn`	`[r] [n] BLESSARGS`	`x_1...x_r s - c`	`0 <= r <= 15`, `-1 <= n <= 14` Equivalent to `BLESS` `[r] [n] SETCONTARGS`. The value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.	`26`
`ED1F`	`BLESSVARARGS`	`x_1...x_r s r n - c`	Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.	`26+s''`
`F93001`	`BLS_AGGREGATE`	`sig_1 ... sig_n n - sig`	Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.	`n*4350-2616`
`F93003`	`BLS_AGGREGATEVERIFY`	`pk_1 msg_1 ... pk_n msg_n n sgn - bool`	Checks aggregated BLS signature for key-message pairs `pk_1 msg_1...pk_n msg_n`. Return true on success, false otherwise. Return false if `n=0`.	`38534+n*22500`
`F93002`	`BLS_FASTAGGREGATEVERIFY`	`pk_1 ... pk_n n msg sig - bool`	Checks aggregated BLS signature for keys `pk_1...pk_n` and message `msg`. Return true on success, false otherwise. Return false if `n=0`.	`58034+n*3000`
`F93017`	`BLS_G1_INGROUP`	`x - bool`	Checks that slice `x` represents a valid element of G1.	`2984`
`F93018`	`BLS_G1_ISZERO`	`x - bool`	Checks that G1 point `x` is equal to zero.	`34`
`F93011`	`BLS_G1_SUB`	`x y - x-y`	Subtraction on G1.	`3934`
`F93015`	`BLS_G1_ZERO`	`- zero`	Pushes zero point in G1.	`34`
`F93020`	`BLS_G2_ADD`	`x y - x+y`	Addition on G2.	`6134`
`F93027`	`BLS_G2_INGROUP`	`x - bool`	Checks that slice `x` represents a valid element of G2.	`4284`
`F93028`	`BLS_G2_ISZERO`	`x - bool`	Checks that G2 point `x` is equal to zero.	`34`
`F93023`	`BLS_G2_MUL`	`x s - x*s`	Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.	`10584`
`F93024`	`BLS_G2_MULTIEXP`	`x_1 s_1 ... x_n s_n n - x_1s_1+...+x_ns_n`	Calculates `x_1s_1+...+x_ns_n` for G2 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.	`30422+n1280+n/floor(max(log2(n),4))22840`
`F93022`	`BLS_G2_NEG`	`x - -x`	Negation on G2.	`1584`
`F93021`	`BLS_G2_SUB`	`x y - x-y`	Subtraction on G2.	`6134`
`F93025`	`BLS_G2_ZERO`	`- zero`	Pushes zero point in G2.	`34`
`F93016`	`BLS_MAP_TO_G1`	`f - x`	Converts FP element `f` to a G1 point.	`2384`
`F93026`	`BLS_MAP_TO_G2`	`f - x`	Converts FP2 element `f` to a G2 point.	`7984`
`F93031`	`BLS_PUSHR`	`- r`	Pushes the order of G1 and G2 (approx. `2^255`).	`34`
`F93000`	`BLS_VERIFY`	`pk msg sgn - bool`	Checks BLS signature, return true on success, false otherwise.	`61034`
`EDF9`	`BOOLEVAL`	`c - ?`	Performs `cc:=compose1(compose0(c, compose0(-1 PUSHINT, cc)), compose0(0 PUSHINT, cc))`. If `c` represents a boolean circuit, the net effect is to evaluate it and push either `-1` or `0` into the stack before continuing.	`26`
`DB32`	`BRANCH RETBOOL`	`f -`	Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.	`26`
`CF32`	`BREFS`	`b - y`	Returns the number of cell references already stored in `b`.	`26`
`CF37`	`BREMBITREFS`	`b - x' y'`	Returns the numbers of both data bits and references that can still be stored in `b`.	`26`
`CF35`	`BREMBITS`	`b - x'`	Returns the number of data bits that can still be stored in `b`.	`26`
`CF36`	`BREMREFS`	`b - y'`	Returns the number of references that can still be stored in `b`.	`26`
`DB34`	`CALLCC`	`c -`	Call with current continuation, transfers control to `c`, pushing the old value of `cc` into `c`'s stack (instead of discarding it or writing it into new `c0`).	`26`
`DB36pr`	`[p] [r] CALLCCARGS`	`c -`	Similar to `CALLXARGS`, but pushes the old value of `cc` (along with the top `0 <= p <= 15` values from the original stack) into the stack of newly-invoked continuation `c`, setting `cc.nargs` to `-1 <= r <= 14`.	`34`
`DB3B`	`CALLCCVARARGS`	`c p r -`	Similar to `CALLCCARGS`.	`26`
`DB38`	`CALLXVARARGS`	`c p r -`	Similar to `CALLXARGS`, but takes `-1 <= p,r <= 254` from the stack. The next three operations also take `p` and `r` from the stack, both in the range `-1...254`.	`26`
`D76E_`	`[i] CDEPTHI`	`cell - depth`	Returns `i`th depth of the cell.	`26`
`D771`	`CDEPTHIX`	`cell i - depth`	Returns `i`th depth of the cell.	`26`
`FB07`	`CHANGELIB`	`h x -`	Creates an output action similarly to `SETLIBCODE`, but instead of the library code accepts its hash as an unsigned 256-bit integer `h`. If `x!=0` and the library with hash `h` is absent from the library collection of this smart contract, this output action will fail.	`526`
`D76A_`	`[i] CHASHI`	`cell - hash`	Returns `i`th hash of the cell.	`26`
`D770`	`CHASHIX`	`cell i - hash`	Returns `i`th hash of the cell.	`26`
`C5`	`CHKNAN`	`x - x`	Throws an arithmetic overflow exception if `x` is a `NaN`.	`18/68`
`D766`	`CLEVEL`	`cell - level`	Returns level of the cell.	`26`
`D767`	`CLEVELMASK`	`cell - level_mask`	Returns level mask of the cell.	`26`
`EDF0`	`COMPOS BOOLAND`	`c c' - c''`	Computes the composition `compose0(c, c')`, which has the meaning of ''perform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply ''perform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.	`26`
`EDF2`	`COMPOSBOTH`	`c c' - c''`	Computes composition `compose1(compose0(c, c'), c')`, which has the meaning of ''compute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.	`26`
`E304`	`CONDSEL`	`f x y - x or y`	If integer `f` is non-zero, returns `x`, otherwise returns `y`. Notice that no type checks are performed on `x` and `y`; as such, it is more like a conditional stack operation. Roughly equivalent to `ROT` `ISZERO` `INC` `ROLLX` `NIP`.	`26`
`E305`	`CONDSELCHK`	`f x y - x or y`	Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.	`26`
`F830`	`CONFIGDICT`	`- D 32`	Returns the global configuration dictionary along with its key length (32). Equivalent to `CONFIGROOT` `32 PUSHINT`.	`26`
`F832`	`CONFIGPARAM`	`i - c -1 or 0`	Returns the value of the global configuration parameter with integer index `i` as a Cell `c`, and a flag to indicate success. Equivalent to `CONFIGDICT` `DICTIGETREF`.
`FEFnssss`	`{string} DEBUGSTR {string} {x} DEBUGSTRI`	`-`	`0 <= n < 16`. Length of `ssss` is `n+1` bytes. `{string}` is a string literal. `DEBUGSTR`: `ssss` is the given string. `DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.	`26`
`F432`	`DICTADD`	`x k D n - D' -1 or D 0`	An Add counterpart of `DICTSET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if it is not already present in `D`.
`F43A`	`DICTADDGET`	`x k D n - D' -1 or D y 0`	An Add counterpart of `DICTSETGET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if key `k` is not already present in `D`. Otherwise, just returns the old value `y` without changing the dictionary.
`F455`	`DICTADDGETB`	`b k D n - D' -1 or D y 0`
`F43B`	`DICTADDGETREF`	`c k D n - D' -1 or D c' 0`	An Add counterpart of `DICTSETGETREF`.
`F433`	`DICTADDREF`	`c k D n - D' -1 or D 0`	An Add counterpart of `DICTSETREF`.
`F463`	`DICTDELGETREF`	`k D n - D' c -1 or D 0`	Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a Cell.
`F474`	`DICTGETNEXT`	`k D n - x' k' -1 or 0`	Computes the minimal key `k'` in dictionary `D` that is lexicographically greater than `k`, and returns `k'` (represented by a Slice) along with associated value `x'` (also represented by a Slice).
`F476`	`DICTGETPREV`	`k D n - x' k' -1 or 0`	Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.
`F477`	`DICTGETPREVEQ`	`k D n - x' k' -1 or 0`	Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.
`F434`	`DICTIADD`	`x i D n - D' -1 or D 0`	`DICTADD`, but with `i` a signed `n`-bit integer.
`F452`	`DICTIADDB`	`b i D n - D' -1 or D 0`
`F43C`	`DICTIADDGET`	`x i D n - D' -1 or D y 0`	`DICTADDGET`, but with `i` a signed `n`-bit integer.
`F456`	`DICTIADDGETB`	`b i D n - D' -1 or D y 0`
`F43D`	`DICTIADDGETREF`	`c i D n - D' -1 or D c' 0`	`DICTADDGETREF`, but with `i` a signed `n`-bit integer.
`F464`	`DICTIDELGET`	`i D n - D' x -1 or D 0`	`DICTDELGET`, but with `i` a signed `n`-bit integer.
`F465`	`DICTIDELGETREF`	`i D n - D' c -1 or D 0`	`DICTDELGETREF`, but with `i` a signed `n`-bit integer.
`F4A2`	`DICTIGETEXEC`	`i D n -`	Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.
`F4BE`	`DICTIGETEXECZ`	`i D n - i or nothing`	A variant of `DICTIGETEXEC` that returns index `i` on failure.
`F479`	`DICTIGETNEXTEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.
`F48C`	`DICTIMAX`	`D n - x i -1 or 0`	Similar to `DICTMAX`, but computes the maximal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMAX` and `DICTUMAX`.
`F48D`	`DICTIMAXREF`	`D n - c i -1 or 0`	Similar to `DICTIMAX`, but returns the only reference in the value.
`F49C`	`DICTIREMMAX`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMAX`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMAX` and `DICTUREMMAX`.
`F49D`	`DICTIREMMAXREF`	`D n - D' c i -1 or D 0`	Similar to `DICTIREMMAX`, but returns the only reference in the value.
`F494`	`DICTIREMMIN`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMIN` and `DICTUREMMIN`.
`F495`	`DICTIREMMINREF`	`D n - D' c i -1 or D 0`	Similar to `DICTIREMMIN`, but returns the only reference in the value.
`F44A`	`DICTIREPLACEB`	`b i D n - D' -1 or D 0`
`F42C`	`DICTIREPLACEGET`	`x i D n - D' y -1 or D 0`	`DICTREPLACEGET`, but with `i` a signed `n`-bit integer.
`F44E`	`DICTIREPLACEGETB`	`b i D n - D' y -1 or D 0`
`F42D`	`DICTIREPLACEGETREF`	`c i D n - D' c' -1 or D 0`	`DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.
`F425`	`DICTIREPLACEREF`	`c i D n - D' -1 or D 0`	`DICTREPLACEREF`, but with `i` a signed `n`-bit integer.
`F41C`	`DICTISETGET`	`x i D n - D' y -1 or D' 0`	`DICTISETGET`, but with `i` a signed `n`-bit integer.
`F446`	`DICTISETGETB`	`b i D n - D' y -1 or D' 0`
`F46E`	`DICTISETGETOPTREF`	`c^? i D n - D' ~c^?`	Similar to primitive `DICTSETGETOPTREF`, but using signed `n`-bit Integer `i` as a key. If `i` does not fit into `n` bits, throws a range checking exception.
`F41D`	`DICTISETGETREF`	`c i D n - D' c' -1 or D' 0`	`DICTISETGETREF`, but with `i` a signed `n`-bit integer.
`F48B`	`DICTMAXREF`	`D n - c k -1 or 0`	Similar to `DICTMAX`, but returns the only reference in the value.
`F483`	`DICTMINREF`	`D n - c k -1 or 0`	Similar to `DICTMIN`, but returns the only reference in the value as a Cell `c`.
`F49A`	`DICTREMMAX`	`D n - D' x k -1 or D 0`	Computes the maximal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
`F49B`	`DICTREMMAXREF`	`D n - D' c k -1 or D 0`	Similar to `DICTREMMAX`, but returns the only reference in the value as a Cell `c`.
`F492`	`DICTREMMIN`	`D n - D' x k -1 or D 0`	Computes the minimal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
`F493`	`DICTREMMINREF`	`D n - D' c k -1 or D 0`	Similar to `DICTREMMIN`, but returns the only reference in the value as a Cell `c`.
`F422`	`DICTREPLACE`	`x k D n - D' -1 or D 0`	A Replace operation, which is similar to `DICTSET`, but sets the value of key `k` in dictionary `D` to `x` only if the key `k` was already present in `D`.
`F449`	`DICTREPLACEB`	`b k D n - D' -1 or D 0`
`F42A`	`DICTREPLACEGET`	`x k D n - D' y -1 or D 0`	A Replace counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.
`F44D`	`DICTREPLACEGETB`	`b k D n - D' y -1 or D 0`
`F42B`	`DICTREPLACEGETREF`	`c k D n - D' c' -1 or D 0`	A Replace counterpart of `DICTSETGETREF`.
`F423`	`DICTREPLACEREF`	`c k D n - D' -1 or D 0`	A Replace counterpart of `DICTSETREF`.
`F41A`	`DICTSETGET`	`x k D n - D' y -1 or D' 0`	Combines `DICTSET` with `DICTGET`: it sets the value corresponding to key `k` to `x`, but also returns the old value `y` associated with the key in question, if present.
`F445`	`DICTSETGETB`	`b k D n - D' y -1 or D' 0`
`F46D`	`DICTSETGETOPTREF`	`c^? k D n - D' ~c^?`	A variant of both `DICTGETOPTREF` and `DICTSETGETREF` that sets the value corresponding to key `k` in dictionary `D` to `c^?` (if `c^?` is Null, then the key is deleted instead), and returns the old value `~c^?` (if the key `k` was absent before, returns Null instead).
`F41B`	`DICTSETGETREF`	`c k D n - D' c' -1 or D' 0`	Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.
`F43E`	`DICTUADDGET`	`x i D n - D' -1 or D y 0`	`DICTADDGET`, but with `i` an unsigned `n`-bit integer.
`F457`	`DICTUADDGETB`	`b i D n - D' -1 or D y 0`
`F43F`	`DICTUADDGETREF`	`c i D n - D' -1 or D c' 0`	`DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.
`F4A3`	`DICTUGETEXEC`	`i D n -`	Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.
`F4BF`	`DICTUGETEXECZ`	`i D n - i or nothing`	A variant of `DICTUGETEXEC` that returns index `i` on failure.
`F4BD`	`DICTUGETJMPZ`	`i D n - i or nothing`	A variant of `DICTUGETJMP` that returns index `i` on failure.
`F49E`	`DICTUREMMAX`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit Integer `i`.
`F49F`	`DICTUREMMAXREF`	`D n - D' c i -1 or D 0`	Similar to `DICTUREMMAX`, but returns the only reference in the value.
`F426`	`DICTUREPLACE`	`x i D n - D' -1 or D 0`	`DICTREPLACE`, but with `i` an unsigned `n`-bit integer.
`F42E`	`DICTUREPLACEGET`	`x i D n - D' y -1 or D 0`	`DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.
`F44F`	`DICTUREPLACEGETB`	`b i D n - D' y -1 or D 0`
`F42F`	`DICTUREPLACEGETREF`	`c i D n - D' c' -1 or D 0`	`DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.
`F427`	`DICTUREPLACEREF`	`c i D n - D' -1 or D 0`	`DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.
`F447`	`DICTUSETGETB`	`b i D n - D' y -1 or D' 0`
`F46F`	`DICTUSETGETOPTREF`	`c^? i D n - D' ~c^?`	Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit Integer `i` as a key.
`F41F`	`DICTUSETGETREF`	`c i D n - D' c' -1 or D' 0`	`DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.
`B4cc`	`[cc+1] FITS`	`x - x`	Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`). If not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).	`26/76`
`B600`	`FITSX`	`x c - x`	Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.	`26/76`
`F90702`	`HASHEXTAR_BLAKE2B`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/19 gas per byte`
`F90703`	`HASHEXTAR_KECCAK256`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/11 gas per byte`
`F90704`	`HASHEXTAR_KECCAK512`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/6 gas per byte`
`F90700`	`HASHEXTAR_SHA256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/33 gas per byte`
`F90701`	`HASHEXTAR_SHA512`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/16 gas per byte`
`F90602`	`HASHEXTA_BLAKE2B`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/19 gas per byte`
`F90603`	`HASHEXTA_KECCAK256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/11 gas per byte`
`F90604`	`HASHEXTA_KECCAK512`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/6 gas per byte`
`F90601`	`HASHEXTA_SHA512`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/16 gas per byte`
`F90502`	`HASHEXTR_BLAKE2B`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90503`	`HASHEXTR_KECCAK256`	`s_n ... s_1 n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/11 gas per byte`
`F90504`	`HASHEXTR_KECCAK512`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90500`	`HASHEXTR_SHA256`	`s_n ... s_1 n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/33 gas per byte`
`F90501`	`HASHEXTR_SHA512`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/16 gas per byte`
`F90402`	`HASHEXT_BLAKE2B`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90404`	`HASHEXT_KECCAK512`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`E39_n`	`[n] IFBITJMP`	`x c - x`	Checks whether bit `0 <= n <= 31` is set in integer `x`, and if so, performs `JMPX` to continuation `c`. Value `x` is left in the stack.	`26`
`E3D_n`	`[ref] [n] IFBITJMPREF`	`x - x`	Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.	`126/51`
`E3B_n`	`[n] IFNBITJMP`	`x c - x`	Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.	`26`
`E3F_n`	`[ref] [n] IFNBITJMPREF`	`x - x`	Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.	`126/51`
`EDF8`	`INVERT`	`-`	Interchanges `c0` and `c1`.	`26`
`F16_n`	`[n] JMP`	`- n`	Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument. Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.
`DB3D`	`[ref] JMPREF`		Equivalent to `PUSHREFCONT` `JMPX`.	`126/51`
`DB3E`	`[ref] JMPREFDATA`		Equivalent to `PUSHREFCONT` `JMPXDATA`.	`126/51`
`DB1p`	`[p] JMPXARGS`	`c -`	Jumps to continuation `c`, passing only the top `0 <= p <= 15` values from the current stack to it (the remainder of the current stack is discarded).	`26`
`DB3A`	`JMPXVARARGS`	`c p r -`	Similar to `JMPXARGS`.	`26`
`F406`	`LDDICTQ`	`s - D s' -1 or s 0`	A quiet version of `LDDICT`.	`26`
`F402`	`LDDICTS`	`s - s' s''`	Loads (parses) a (Slice-represented) dictionary `s'` from Slice `s`, and returns the remainder of `s` as `s''`. This is a ''split function'' for all `HashmapE(n,X)` dictionary types.	`26`
`D750`	`LDILE4`	`s - x s'`	Loads a little-endian signed 32-bit integer.	`26`
`D758`	`LDILE4Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian signed 32-bit integer.	`26`
`D752`	`LDILE8`	`s - x s'`	Loads a little-endian signed 64-bit integer.	`26`
`D75A`	`LDILE8Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian signed 64-bit integer.	`26`
`D70Ccc`	`[cc+1] LDIQ`	`s - x s' -1 or s 0`	A quiet version of `LDI`.	`34`
`D704`	`LDIXQ`	`s l - x s' -1 or s 0`	Quiet version of `LDIX`: loads a signed `l`-bit integer from `s` similarly to `LDIX`, but returns a success flag, equal to `-1` on success or to `0` on failure (if `s` does not have `l` bits), instead of throwing a cell underflow exception.	`26`
`D708cc`	`[cc+1] LDI_l`	`s - x s'`	A longer encoding for `LDI`.	`34`
`D761`	`LDONES`	`s - n s'`	Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.	`26`
`D762`	`LDSAME`	`s x - n s'`	Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.	`26`
`D71Ecc`	`[cc+1] LDSLICEQ`	`s - s'' s' -1 or s 0`	A quiet version of `LDSLICE`.	`34`
`D71A`	`LDSLICEXQ`	`s l - s'' s' -1 or s 0`	A quiet version of `LDSLICEX`.	`26`
`D71Ccc`	`[cc+1] LDSLICE_l`	`s - s'' s'`	A longer encoding for `LDSLICE`.	`34`
`D759`	`LDULE4Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian unsigned 32-bit integer.	`26`
`D753`	`LDULE8`	`s - x s'`	Loads a little-endian unsigned 64-bit integer.	`26`
`D75B`	`LDULE8Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian unsigned 64-bit integer.	`26`
`D70Dcc`	`[cc+1] LDUQ`	`s - x s' -1 or s 0`	A quiet version of `LDU`.	`34`
`D709cc`	`[cc+1] LDU_l`	`s - x s'`	A longer encoding for `LDU`.	`34`
`FA05`	`LDVARINT32`	`s - x s'`	Similar to `LDVARUINT32`, but loads a signed Integer `x`. Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.	`26`
`FA04`	`LDVARUINT32`	`s - x s'`	Loads (deserializes) a `VarUInteger 32` amount from Slice `s`, and returns the amount as Integer `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`. The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.	`26`
`D760`	`LDZEROES`	`s - n s'`	Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.	`26`
`A9D0tt`	`[tt+1] LSHIFT#ADDDIVMOD`	`x w z - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9D2tt`	`[tt+1] LSHIFT#ADDDIVMODC`	`x w z - q=ceil((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9C2`	`LSHIFTADDDIVMODC`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9D1tt`	`[tt+1] LSHIFT#ADDDIVMODR`	`x w z - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9C1`	`LSHIFTADDDIVMODR`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9C0`	`LSHIFTADDDIVMOD`	`x w z y - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9D4tt`	`[tt+1] LSHIFT#DIV`	`x y - floor(2^(tt+1)*x/y)`		`34`
`A9C6`	`LSHIFTDIVC`	`x y z - ceil(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9DCtt`	`[tt+1] LSHIFT#DIVMOD`	`x y - q=floor(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9DEtt`	`[tt+1] LSHIFT#DIVMODC`	`x y - q=ceil(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9CE`	`LSHIFTDIVMODC`	`x y z - q=ceil(2^zx/y) r=2^zx-q*y`		`26`
`A9DDtt`	`[tt+1] LSHIFT#DIVMODR`	`x y - q=round(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9CC`	`LSHIFTDIVMOD`	`x y z - q=floor(2^zx/y) r=2^zx-q*y`		`26`
`A9C5`	`LSHIFTDIVR`	`x y z - round(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9C4`	`LSHIFTDIV`	`x y z - floor(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9D8tt`	`[tt+1] LSHIFT#MOD`	`x y - 2^(tt+1)*x mod y`		`34`
`A9DAtt`	`[tt+1] LSHIFT#MODC`	`x y - 2^(tt+1)*x mod y`		`34`
`A9CA`	`LSHIFTMODC`	`x y z - 2^z*x mod y`		`26`
`A9D9tt`	`[tt+1] LSHIFT#MODR`	`x y - 2^(tt+1)*x mod y`		`34`
`A9C9`	`LSHIFTMODR`	`x y z - 2^z*x mod y`		`26`
`A9C8`	`LSHIFTMOD`	`x y z - 2^z*x mod y`		`26`
`B60A`	`MINMAX INTSORT2`	`x y - x y or y x`	Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.	`26`
`A93Att`	`[tt+1] MODPOW2C#`	`x - x mod 2^(tt+1)`		`34`
`A939tt`	`[tt+1] MODPOW2R#`	`x - x mod 2^(tt+1)`		`34`
`A980`	`MULADDDIVMOD`	`x y w z - q=floor((xy+w)/z) r=(xy+w)-zq`		`26`
`A982`	`MULADDDIVMODC`	`x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq`		`26`
`A981`	`MULADDDIVMODR`	`x y w z - q=round((xy+w)/z) r=(xy+w)-zq`		`26`
`A9B2tt`	`[tt+1] MULADDRSHIFTC#MOD`	`x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A9B0tt`	`[tt+1] MULADDRSHIFT#MOD`	`x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A9B1tt`	`[tt+1] MULADDRSHIFTR#MOD`	`x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A98E`	`MULDIVMODC`	`x y z - q r`	`q=ceil(xy/z)`, `r=xy-z*q`	`26`
`A98D`	`MULDIVMODR`	`x y z - q r`	`q=round(xy/z)`, `r=xy-z*q`	`26`
`A988`	`MULMOD`	`x y z - x*y mod z`		`26`
`A98A`	`MULMODC`	`x y z - x*y mod z`		`26`
`A9B8tt`	`[tt+1] MULMODPOW2#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9BAtt`	`[tt+1] MULMODPOW2C#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9AA`	`MULMODPOW2C_VAR`	`x y z - x*y mod 2^z`		`26`
`A9B9tt`	`[tt+1] MULMODPOW2R#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9A9`	`MULMODPOW2R_VAR`	`x y z - x*y mod 2^z`		`26`
`A9A8`	`MULMODPOW2_VAR`	`x y z - x*y mod 2^z`		`26`
`A989`	`MULMODR`	`x y z - x*y mod z`		`26`
`A9B6tt`	`[tt+1] MULRSHIFTC#`	`x y - ceil(x*y/2^(tt+1))`		`34`
`A9BE`	`MULRSHIFTC#MOD`	`x y - q=ceil(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9AE`	`MULRSHIFTCMOD_VAR`	`x y z - q=ceil(xy/2^z) r=xy-q2^z`		`26`
`A9A6`	`MULRSHIFTC`	`x y z - ceil(x*y/2^z)`	`0 <= z <= 256`	`26`
`A9BC`	`MULRSHIFT#MOD`	`x y - q=floor(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9AC`	`MULRSHIFTMOD_VAR`	`x y z - q=floor(xy/2^z) r=xy-q2^z`		`26`
`A9AD`	`MULRSHIFTRMOD_VAR`	`x y z - q=round(xy/2^z) r=xy-q2^z`		`26`
`A9A5`	`MULRSHIFTR`	`x y z - round(x*y/2^z)`	`0 <= z <= 256`	`26`
`A9A4`	`MULRSHIFT`	`x y z - floor(x*y/2^z)`	`0 <= z <= 256`	`26`
`F915`	`P256_CHKSIGNS`	`d sig k - ?`	Checks seck256r1-signature `sig` of data portion of slice `d` and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).	`3526`
`FA43`	`PARSEMSGADDRQ`	`s - t -1 or 0`	A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.	`26`
`F472`	`PFXDICTADD`	`x k D n - D' -1 or D 0`
`F4AE_n`	`[ref] [n] PFXDICTCONSTGETJMP [ref] [n] PFXDICTSWITCH`	`s - s' s'' or s`	Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.
`F473`	`PFXDICTDEL`	`k D n - D' -1 or D 0`
`F4A9`	`PFXDICTGET`	`s D n - s' x s''`	Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.
`F4AB`	`PFXDICTGETEXEC`	`s D n - s' s''`	Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.
`F4AA`	`PFXDICTGETJMP`	`s D n - s' s'' or s`	Similar to `PFXDICTGETQ`, but on success `BLESS`es the value `x` into a Continuation and transfers control to it as if by a `JMPX`. On failure, returns `s` unchanged and continues execution.
`F471`	`PFXDICTREPLACE`	`x k D n - D' -1 or D 0`
`F403`	`PLDDICTS`	`s - s'`	Preloads a (Slice-represented) dictionary `s'` from Slice `s`. Approximately equivalent to `LDDICTS` `DROP`.	`26`
`D754`	`PLDILE4`	`s - x`	Preloads a little-endian signed 32-bit integer.	`26`
`D75C`	`PLDILE4Q`	`s - x -1 or 0`	Quietly preloads a little-endian signed 32-bit integer.	`26`
`D756`	`PLDILE8`	`s - x`	Preloads a little-endian signed 64-bit integer.	`26`
`D75E`	`PLDILE8Q`	`s - x -1 or 0`	Quietly preloads a little-endian signed 64-bit integer.	`26`
`D70Ecc`	`[cc+1] PLDIQ`	`s - x -1 or 0`	A quiet version of `PLDI`.	`34`
`D702`	`PLDIX`	`s l - x`	Preloads a signed `l`-bit integer from Slice `s`, for `0 <= l <= 257`.	`26`
`D706`	`PLDIXQ`	`s l - x -1 or 0`	Quiet version of `PLDIX`.	`26`
`D748`	`PLDREFVAR`	`s n - c`	Returns the `n`-th cell reference of Slice `s` for `0 <= n <= 3`.	`26`
`D71Fcc`	`[cc+1] PLDSLICEQ`	`s - s'' -1 or 0`	A quiet version of `PLDSLICE`.	`34`
`D71B`	`PLDSLICEXQ`	`s l - s' -1 or 0`	A quiet version of `LDSLICEXQ`.	`26`
`D755`	`PLDULE4`	`s - x`	Preloads a little-endian unsigned 32-bit integer.	`26`
`D75D`	`PLDULE4Q`	`s - x -1 or 0`	Quietly preloads a little-endian unsigned 32-bit integer.	`26`
`D757`	`PLDULE8`	`s - x`	Preloads a little-endian unsigned 64-bit integer.	`26`
`D75F`	`PLDULE8Q`	`s - x -1 or 0`	Quietly preloads a little-endian unsigned 64-bit integer.	`26`
`D70Fcc`	`[cc+1] PLDUQ`	`s - x -1 or 0`	A quiet version of `PLDU`.	`34`
`D707`	`PLDUXQ`	`s l - x -1 or 0`	Quiet version of `PLDUX`.	`26`
`EDE1`	`POPCTRX`	`x i -`	Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.	`26`
`ED9i`	`c[i] POPSAVE c[i] POPCTRSAVE`	`x -`	Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`. Equivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.	`26`
`EDE0`	`PUSHCTRX`	`i - x`	Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack. Notice that this primitive is one of the few ''exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of `x` depends on `i`.	`26`
`B7A0`	`QADD`	`x y - x+y`		`26`
`B7A900`	`QADDDIVMOD`	`x w z - q=floor((x+w)/z) r=(x+w)-zq`		`34`
`B7A902`	`QADDDIVMODC`	`x w y - q=ceil((x+w)/z) r=(x+w)-zq`		`34`
`B7A901`	`QADDDIVMODR`	`x w z - q=round((x+w)/z) r=(x+w)-zq`		`34`
`B7A932tt`	`[tt+1] QADDRSHIFTC#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`B7A930tt`	`[tt+1] QADDRSHIFT#MOD`	`x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`B7A922`	`QADDRSHIFTMODC`	`x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z`		`34`
`B7A921`	`QADDRSHIFTMODR`	`x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z`		`34`
`B7A931tt`	`[tt+1] QADDRSHIFTR#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`F47A`	`DICTIGETPREV`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.
`B7B0`	`QAND`	`x y - x&y`		`26`
`B7A5`	`QDEC`	`x - x-1`		`26`
`B7A904`	`QDIV`	`x y - q`	Division returns `NaN` if `y=0`.	`34`
`B7A906`	`QDIVC`	`x y - q''`		`34`
`B7A90C`	`QDIVMOD`	`x y - q r`		`34`
`B7A90E`	`QDIVMODC`	`x y - q'' r''`		`34`
`B7A90D`	`QDIVMODR`	`x y - q' r'`		`34`
`B7A905`	`QDIVR`	`x y - q'`		`34`
`B7B4cc`	`[cc+1] QFITS`	`x - x`	Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.	`34`
`B7B600`	`QFITSX`	`x c - x`	Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.	`34`
`B7A4`	`QINC`	`x - x+1`		`26`
`B7AAcc`	`[cc+1] QLSHIFT#`	`x - x*2^(cc+1)`	`0 <= cc <= 255`	`34`
`B7A9D0tt`	`[tt+1] QLSHIFT#ADDDIVMOD`	`x w z - q=floor((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9D2tt`	`[tt+1] QLSHIFT#ADDDIVMODC`	`x w z - q=ceil((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9C2`	`QLSHIFTADDDIVMODC`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9D1tt`	`[tt+1] QLSHIFT#ADDDIVMODR`	`x w z - q=round((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9C1`	`QLSHIFTADDDIVMODR`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9C0`	`QLSHIFTADDDIVMOD`	`x w z y - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9D4tt`	`[tt+1] QLSHIFT#DIV`	`x y - floor(2^(tt+1)*x/y)`		`42`
`B7A9D6tt`	`[tt+1] QLSHIFT#DIVC`	`x y - ceil(2^(tt+1)*x/y)`		`34`
`B7A9C6`	`QLSHIFTDIVC`	`x y z - ceil(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9DCtt`	`[tt+1] QLSHIFT#DIVMOD`	`x y - q=floor(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9DEtt`	`[tt+1] QLSHIFT#DIVMODC`	`x y - q=ceil(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9CE`	`QLSHIFTDIVMODC`	`x y z - q=ceil(2^zx/y) r=2^zx-q*y`		`34`
`B7A9DDtt`	`[tt+1] QLSHIFT#DIVMODR`	`x y - q=round(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9CD`	`QLSHIFTDIVMODR`	`x y z - q=round(2^zx/y) r=2^zx-q*y`		`34`
`B7A9CC`	`QLSHIFTDIVMOD`	`x y z - q=floor(2^zx/y) r=2^zx-q*y`		`34`
`B7A9D5tt`	`[tt+1] QLSHIFT#DIVR`	`x y - round(2^(tt+1)*x/y)`		`42`
`B7A9C5`	`QLSHIFTDIVR`	`x y z - round(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9C4`	`QLSHIFTDIV`	`x y z - floor(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9D8tt`	`[tt+1] QLSHIFT#MOD`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9DAtt`	`[tt+1] QLSHIFT#MODC`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9CA`	`QLSHIFTMODC`	`x y z - 2^z*x mod y`		`34`
`B7A9D9tt`	`[tt+1] LSHIFT#MODR`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9C9`	`QLSHIFTMODR`	`x y z - 2^z*x mod y`		`34`
`B7A9C8`	`QLSHIFTMOD`	`x y z - 2^z*x mod y`		`34`
`B7AC`	`QLSHIFT`	`x y - x*2^y`		`26`
`B7A908`	`QMOD`	`x y - r`		`34`
`B7A90A`	`QMODC`	`x y - r`		`34`
`B7A938tt`	`[tt+1] QMODPOW2#`	`x - x mod 2^(tt+1)`		`42`
`B7A93Att`	`[tt+1] QMODPOW2C#`	`x - x mod 2^(tt+1)`		`42`
`B7A92A`	`QMODPOW2C`	`x y - x mod 2^y`		`34`
`B7A939tt`	`[tt+1] QMODPOW2R#`	`x - x mod 2^(tt+1)`		`42`
`B7A929`	`QMODPOW2R`	`x y - x mod 2^y`		`34`
`B7A928`	`QMODPOW2`	`x y - x mod 2^y`		`34`
`B7A909`	`QMODR`	`x y - r`		`34`
`B7A980`	`QMULADDDIVMOD`	`x y w z - q=floor((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A982`	`QMULADDDIVMODC`	`x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A981`	`QMULADDDIVMODR`	`x y w z - q=round((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A9B2tt`	`[tt+1] QMULADDRSHIFTC#MOD`	`x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A9B0tt`	`[tt+1] QMULADDRSHIFT#MOD`	`x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A9B1tt`	`[tt+1] QMULADDRSHIFTR#MOD`	`x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A984`	`QMULDIV`	`x y z - q`	`q=floor(x*y/z)`	`34`
`B7A986`	`QMULDIVC`	`x y z - q'`	`q'=ceil(x*y/z)`	`34`
`B7A98E`	`QMULDIVMODC`	`x y z - q r`	`q=ceil(xy/z)`, `r=xy-z*q`	`34`
`B7A98D`	`QMULDIVMODR`	`x y z - q r`	`q=round(xy/z)`, `r=xy-z*q`	`34`
`B7A985`	`QMULDIVR`	`x y z - q'`		`34`
`B7A988`	`QMULMOD`	`x y z - x*y mod z`		`34`
`B7A98A`	`QMULMODC`	`x y z - x*y mod z`		`34`
`B7A9B8tt`	`[tt+1] QMULMODPOW2#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9BAtt`	`[tt+1] QMULMODPOW2C#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9AA`	`QMULMODPOW2C_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A9B9tt`	`[tt+1] QMULMODPOW2R#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9A9`	`QMULMODPOW2R_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A9A8`	`QMULMODPOW2_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A989`	`QMULMODR`	`x y z - x*y mod z`		`34`
`B7A9B4tt`	`[tt+1] QMULRSHIFT#`	`x y - floor(x*y/2^(tt+1))`		`42`
`B7A9B6tt`	`[tt+1] QMULRSHIFTC#`	`x y - ceil(x*y/2^(tt+1))`		`42`
`B7A9BE`	`QMULRSHIFTC#MOD`	`x y - q=ceil(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AE`	`QMULRSHIFTCMOD_VAR`	`x y z - q=ceil(xy/2^z) r=xy-q2^z`		`34`
`B7A9A6`	`QMULRSHIFTC`	`x y z - ceil(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A9BC`	`QMULRSHIFT#MOD`	`x y - q=floor(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AC`	`QMULRSHIFTMOD_VAR`	`x y z - q=floor(xy/2^z) r=xy-q2^z`		`34`
`B7A9B5tt`	`[tt+1] QMULRSHIFTR#`	`x y - round(x*y/2^(tt+1))`		`42`
`B7A9BD`	`QMULRSHIFTR#MOD`	`x y - q=round(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AD`	`QMULRSHIFTRMOD_VAR`	`x y z - q=round(xy/2^z) r=xy-q2^z`		`34`
`B7A9A5`	`QMULRSHIFTR`	`x y z - round(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A9A4`	`QMULRSHIFT`	`x y z - floor(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A3`	`QNEGATE`	`x - -x`		`26`
`B7B3`	`QNOT`	`x - ~x`		`26`
`B7B1`	`QOR`	`x y - x\|y`		`26`
`B7AE`	`QPOW2`	`y - 2^y`		`26`
`B7ABcc`	`[cc+1] RSHIFT#`	`x - floor(x/2^(cc+1))`	`0 <= cc <= 255`	`26`
`B7A936tt`	`[tt+1] QRSHIFTC#`	`x - ceil(x/2^(tt+1))`		`42`
`B7A93Ett`	`[tt+1] QRSHIFTC#MOD`	`x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A926`	`QRSHIFTC`	`x y - ceil(x/2^y)`		`34`
`A93Ctt`	`[tt+1] QRSHIFT#MOD`	`x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A92E`	`QRSHIFTMODC`	`x y - q=ceil(x/2^y) r=x-q*2^y`		`34`
`B7A92D`	`QRSHIFTMODR`	`x y - q=round(x/2^y) r=x-q*2^y`		`34`
`B7A92C`	`QRSHIFTMOD`	`x y - q=floor(x/2^y) r=x-q*2^y`		`34`
`B7A935tt`	`[tt+1] QRSHIFTR#`	`x - round(x/2^(tt+1))`		`42`
`A93Dtt`	`[tt+1] QRSHIFTR#MOD`	`x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A925`	`QRSHIFTR`	`x y - round(x/2^y)`		`34`
`B7AD`	`QRSHIFT`	`x y - floor(x/2^y)`		`26`
`B7A1`	`QSUB`	`x y - x-y`		`26`
`B7A2`	`QSUBR`	`x y - y-x`		`26`
`B7B5cc`	`[cc+1] QUFITS`	`x - x`	Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.	`34`
`B7B601`	`QUFITSX`	`x c - x`	Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.	`34`
`B7B2`	`QXOR`	`x y - x xor y`		`26`
`FB03`	`RAWRESERVEX`	`x D y -`	Similar to `RAWRESERVE`, but also accepts a dictionary `D` (represented by a Cell or Null) with extra currencies. In this way currencies other than Grams can be reserved.	`526`
`E314`	`REPEATBRK`	`n c -`	Similar to `REPEAT`, but also sets `c1` to the original `cc` after saving the old value of `c1` into the savelist of the original `cc`. In this way `RETALT` could be used to break out of the loop body.	`26`
`E5`	`REPEATEND REPEAT:`	`n -`	Similar to `REPEAT`, but it is applied to the current continuation `cc`.	`18`
`E315`	`REPEATENDBRK`	`n -`	Similar to `REPEATEND`, but also sets `c1` to the original `c0` after saving the old value of `c1` into the savelist of the original `c0`. Equivalent to `SAMEALTSAVE` `REPEATEND`.	`26`
`DB30`	`RET RETTRUE`		Returns to the continuation at `c0`. The remainder of the current continuation `cc` is discarded. Approximately equivalent to `c0 PUSHCTR` `JMPX`.	`26`
`DB31`	`RETALT RETFALSE`		Returns to the continuation at `c1`. Approximately equivalent to `c1 PUSHCTR` `JMPX`.	`26`
`DB2r`	`[r] RETARGS`		Returns to `c0`, with `0 <= r <= 15` return values taken from the current stack.	`26`
`DB3F`	`RETDATA`		Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a Slice and returned to the caller.	`26`
`ED0p`	`[p] RETURNARGS`	`-`	Leaves only the top `0 <= p <= 15` values in the current stack (somewhat similarly to `ONLYTOPX`), with all the unused bottom values not discarded, but saved into continuation `c0` in the same way as `SETCONTARGS` does.	`26+s''`
`ED10`	`RETURNVARARGS`	`p -`	Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.	`26+s''`
`DB39`	`RETVARARGS`	`p r -`	Similar to `RETARGS`.	`26`
`FA47`	`REWRITEVARADDRQ`	`s - x s' -1 or 0`	A quiet version of primitive `REWRITEVARADDR`.	`26`
`F922`	`RIST255_ADD`	`x y - x+y`	Addition of two points on a curve.	`626`
`B7F922`	`RIST255_QADD`	`x y - 0 or x+y -1`	Addition of two points on a curve. Returns -1 on success and 0 on failure.	`634`
`B7F924`	`RIST255_QMUL`	`x n - 0 or x*n -1`	Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.	`2034`
`B7F925`	`RIST255_QMULBASE`	`n - 0 or g*n -1`	Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.	`784`
`B7F923`	`RIST255_QSUB`	`x y - 0 or x-y -1`	Subtraction of two points on curve. Returns -1 on success and 0 on failure.	`634`
`B7F921`	`RIST255_QVALIDATE`	`x - 0 or -1`	Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.	`234`
`A93Ett`	`[tt+1] RSHIFTC#MOD`	`x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`
`A93Ctt`	`[tt+1] RSHIFT#MOD`	`x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`
`A93Dtt`	`[tt+1] RSHIFTR#MOD`	`x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`
`DB50`	`RUNVMX`	`x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] flags - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]`	Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
`EDFA`	`SAMEALT`	`-`	Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.	`26`
`EDBi`	`c[i] SAVEALT c[i] SAVEALTCTR`		Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.	`26`
`EDCi`	`c[i] SAVEBOTH c[i] SAVEBOTHCTR`		Equivalent to `c[i] SAVE` `c[i] SAVEALT`.	`26`
`D743`	`SCHKBITREFS`	`s l r -`	Checks whether there are at least `l` data bits and `r` references in Slice `s`.	`26/76`
`D747`	`SCHKBITREFSQ`	`s l r - ?`	Checks whether there are at least `l` data bits and `r` references in Slice `s`.	`26`
`D741`	`SCHKBITS`	`s l -`	Checks whether there are at least `l` data bits in Slice `s`. If this is not the case, throws a cell deserialisation (i.e., cell underflow) exception.	`26/76`
`D745`	`SCHKBITSQ`	`s l - ?`	Checks whether there are at least `l` data bits in Slice `s`.	`26`
`D742`	`SCHKREFS`	`s r -`	Checks whether there are at least `r` references in Slice `s`.	`26/76`
`D746`	`SCHKREFSQ`	`s r - ?`	Checks whether there are at least `r` references in Slice `s`.	`26`
`D730`	`SCUTFIRST`	`s l r - s'`	Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.	`26`
`F942`	`SDATASIZEQ`	`s n - x y z -1 or 0`	Similar to `CDATASIZEQ`, but accepting a Slice `s` instead of a Cell. The returned value of `x` does not take into account the cell that contains the slice `s` itself; however, the data bits and the cell references of `s` are accounted for in `y` and `z`.
`D726`	`SDBEGINSX`	`s s' - s''`	Checks whether `s` begins with (the data bits of) `s'`, and removes `s'` from `s` on success. On failure throws a cell deserialization exception. Primitive `SDPFXREV` can be considered a quiet version of `SDBEGINSX`.	`26`
`D727`	`SDBEGINSXQ`	`s s' - s'' -1 or s 0`	A quiet version of `SDBEGINSX`.	`26`
`C711`	`SDCNTLEAD1`	`s - n`	Returns the number of leading ones in `s`.	`26`
`C712`	`SDCNTTRAIL0`	`s - n`	Returns the number of trailing zeroes in `s`.	`26`
`C708`	`SDPFX`	`s s' - ?`	Checks whether `s` is a prefix of `s'`.	`26`
`C70A`	`SDPPFX`	`s s' - ?`	Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).	`26`
`C70E`	`SDPSFX`	`s s' - ?`	Checks whether `s` is a proper suffix of `s'`.	`26`
`C70F`	`SDPSFXREV`	`s s' - ?`	Checks whether `s'` is a proper suffix of `s`.	`26`
`C70C`	`SDSFX`	`s s' - ?`	Checks whether `s` is a suffix of `s'`.	`26`
`C70D`	`SDSFXREV`	`s s' - ?`	Checks whether `s'` is a suffix of `s`.	`26`
`ED8i`	`c[i] SETALTCTR`	`x -`	Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.	`26`
`EDE2`	`SETCONTCTRX`	`x c i - c'`	Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.	`26`
`FFF0`	`SETCPX`	`c -`	Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.	`26`
`FFFz`	`[z-16] SETCP`	`-`	Selects TVM codepage `z-16` for `1 <= z <= 15`. Negative codepages `-13...-1` are reserved for restricted versions of TVM needed to validate runs of TVM in other codepages. Negative codepage `-14` is reserved for experimental codepages, not necessarily compatible between different TVM implementations, and should be disabled in the production versions of TVM.	`26`
`EDF5`	`SETEXITALT`	`c -`	Sets `c1` to `compose1(compose0(c, c0), c1)`, In this way, a subsequent `RETALT` will first execute `c`, then transfer control to the original `c0`. This can be used, for instance, to exit from nested loops.	`26`
`F860`	`SETGLOBVAR`	`x k -`	Assigns `x` to the `k`-th global variable for `0 <= k < 255`. Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.	`26+\|c7'\|`
`ED12`	`SETNUMVARARGS`	`c n - c'`	`-1 <= n <= 255` If `n=-1`, this operation does nothing (`c'=c`). Otherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.	`26`
`ED7i`	`c[i] SETRETCTR`	`x -`	Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.	`26`
`D737`	`SPLITQ`	`s l r - s' s'' -1 or s 0`	A quiet version of `SPLIT`.	`26`
`D731`	`SSKIPFIRST`	`s l r - s'`	Returns all but the first `l` bits of `s` and `r` references of `s`.	`26`
`D733`	`SSKIPLAST`	`s l r - s'`	Returns all but the last `l` bits of `s` and `r` references of `s`.	`26`
`CF1B`	`STBQ`	`b' b - b' b -1 or b'' 0`	Quiet version of `STB`.	`26`
`CF19`	`STBREFQ`	`b' b - b' b -1 or b'' 0`	Quiet version of `STBREF`.	`526`
`CD`	`STBREFR ENDCST`	`b b'' - b`	Equivalent to `ENDC` `SWAP` `STREF`.	`518`
`CF1D`	`STBREFRQ`	`b b' - b b' -1 or b'' 0`	Quiet version of `STBREFR`.	`526`
`CF15`	`STBREFR_l`	`b b' - b''`	A longer encoding of `STBREFR`.	`526`
`CF1F`	`STBRQ BCONCATQ`	`b b' - b b' -1 or b'' 0`	Quiet version of `STBR`.	`26`
`CF28`	`STILE4`	`x b - b'`	Stores a little-endian signed 32-bit integer.	`26`
`CF2A`	`STILE8`	`x b - b'`	Stores a little-endian signed 64-bit integer.	`26`
`CF0Ccc`	`[cc+1] STIQ`	`x b - x b f or b' 0`	A quiet version of `STI`.	`34`
`CF0Ecc`	`[cc+1] STIRQ`	`b x - b x f or b' 0`	A quiet version of `STIR`.	`34`
`CF04`	`STIXQ`	`x b l - x b f or b' 0`	A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`. If `x` does not fit into `l` bits, sets `b'=b` and `f=1`. If the operation succeeds, `b'` is the new Builder and `f=0`. However, `0 <= l <= 257`, with a range check exception if this is not so.	`26`
`CF02`	`STIXR`	`b x l - b'`	Similar to `STIX`, but with arguments in a different order.	`26`
`CF06`	`STIXRQ`	`b x l - b x f or b' 0`	A quiet version of `STIXR`.	`26`
`CF08cc`	`[cc+1] STI_l`	`x b - b'`	A longer version of `[cc+1] STI`.	`34`
`CF21`	`[ref] [ref] STREF2CONST`	`b - b'`	Equivalent to `STREFCONST` `STREFCONST`.	`26`
`CF20`	`[ref] STREFCONST`	`b - b'`	Equivalent to `PUSHREF` `STREFR`.	`26`
`CF18`	`STREFQ`	`c b - c b -1 or b' 0`	Quiet version of `STREF`.	`26`
`CF1C`	`STREFRQ`	`b c - b c -1 or b' 0`	Quiet version of `STREFR`.	`26`
`CF10`	`STREF_l`	`c b - b'`	A longer version of `STREF`.	`26`
`CF42`	`STSAME`	`b n x - b'`	Stores `n` binary `x`es (`0 <= x <= 1`) into Builder `b`.	`26`
`CF1A`	`STSLICEQ`	`s b - s b -1 or b' 0`	Quiet version of `STSLICE`.	`26`
`CF1E`	`STSLICERQ`	`b s - b s -1 or b'' 0`	Quiet version of `STSLICER`.	`26`
`CF12`	`STSLICE_l`	`s b - b'`	A longer version of `STSLICE`.	`26`
`CF2B`	`STULE8`	`x b - b'`	Stores a little-endian unsigned 64-bit integer.	`26`
`CF0Dcc`	`[cc+1] STUQ`	`x b - x b f or b' 0`	A quiet version of `STU`.	`34`
`CF0Fcc`	`[cc+1] STURQ`	`b x - b x f or b' 0`	A quiet version of `STUR`.	`34`
`CF05`	`STUXQ`	`x b l - x b f or b' 0`	A quiet version of `STUX`.	`26`
`CF03`	`STUXR`	`b x l - b'`	Similar to `STUX`, but with arguments in a different order.	`26`
`CF07`	`STUXRQ`	`b x l - b x f or b' 0`	A quiet version of `STUXR`.	`26`
`CF09cc`	`[cc+1] STU_l`	`x b - b'`	A longer version of `[cc+1] STU`.	`34`
`FA07`	`STVARINT32`	`b x - b'`	Similar to `STVARUINT32`, but serializes a signed Integer `x` in the range `-2^247...2^247-1`.	`26`
`FA06`	`STVARUINT32`	`b x - b'`	Stores (serializes) an Integer `x` in the range `0...2^248-1` into Builder `b`, and returns the resulting Builder `b'`. The serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.	`26`
`F4B1`	`SUBDICTGET`	`k l D n - D'`	Constructs a subdictionary consisting of all keys beginning with prefix `k` (represented by a Slice, the first `0 <= l <= n <= 1023` data bits of which are used as a key) of length `l` in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the new subdictionary of the same type `HashmapE(n,X)` as a Slice `D'`.
`F4B2`	`SUBDICTIGET`	`x l D n - D'`	Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit Integer `x`, where necessarily `l <= 257`.
`F4B6`	`SUBDICTIRPGET`	`x l D n - D'`	Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit Integer `x`, where necessarily `l <= 257`.
`F4B5`	`SUBDICTRPGET`	`k l D n - D'`	Similar to `SUBDICTGET`, but removes the common prefix `k` from all keys of the new dictionary `D'`, which becomes of type `HashmapE(n-l,X)`.
`F4B3`	`SUBDICTUGET`	`x l D n - D'`	Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit Integer `x`, where necessarily `l <= 256`.
`F4B7`	`SUBDICTURPGET`	`x l D n - D'`	Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit Integer `x`, where necessarily `l <= 256`.
`D734`	`SUBSLICE`	`s l r l' r' - s'`	Returns `0 <= l' <= 1023` bits and `0 <= r' <= 4` references from Slice `s`, after skipping the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references.	`26`
`EDF6`	`THENRET`	`c - c'`	Computes `compose0(c, c0)`.	`26`
`EDF7`	`THENRETALT`	`c - c'`	Computes `compose0(c, c1)`	`26`
`F2F1`	`THROWARGANY`	`x n - x n`	Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`. Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.	`76`
`F2F3`	`THROWARGANYIF`	`x n f -`	Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.	`26/76`
`F2F5`	`THROWARGANYIFNOT`	`x n f -`	Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.	`26/76`
`F2DC_n`	`[n] THROWARGIF`	`x f -`	Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.	`34/84`
`F2EC_n`	`[n] THROWARGIFNOT`	`x f -`	Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.	`34/84`
`F3pr`	`[p] [r] TRYARGS`	`c c' -`	Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`. In this way, all but the top `0 <= p <= 15` stack elements will be saved into current continuation's stack, and then restored upon return from either `c` or `c'`, with the top `0 <= r <= 15` values of the resulting stack of `c` or `c'` copied as return values.	`26`
`E316`	`UNTILBRK`	`c -`	Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E7`	`UNTILEND UNTIL:`	`-`	Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.	`18`
`E317`	`UNTILENDBRK UNTILBRK:`	`-`	Equivalent to `SAMEALTSAVE` `UNTILEND`.	`26`
`E318`	`WHILEBRK`	`c' c -`	Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E9`	`WHILEEND`	`c' -`	Similar to `WHILE`, but uses the current continuation `cc` as the loop body.	`18`
`E319`	`WHILEENDBRK`	`c -`	Equivalent to `SAMEALTSAVE` `WHILEEND`.	`26`
`D73B`	`XLOADQ`	`c - c' -1 or c 0`	Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, returns 0.

Opcode	Fift syntax	Stack	Description	Gas
`0i`	`s[i] XCHG0`		Interchanges `s0` with `s[i]`, `1 <= i <= 15`.	`18`
`2i`	`s[i] PUSH`		Pushes a copy of the old `s[i]` into the stack.	`18`
`3i`	`s[i] POP`		Pops the old `s0` value into the old `s[i]`.	`18`
`1i`	`s1 s[i] XCHG`		Interchanges `s1` with `s[i]`, `2 <= i <= 15`.	`18`
`11ii`	`s0 [ii] s() XCHG`		Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.	`26`
`59`	`ROTREV -ROT`	`a b c - c a b`	Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.	`18`
`50ij`	`s[i] s[j] XCHG2`		Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.	`26`
`10ij`	`s[i] s[j] XCHG`		Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.	`26`
`6Cij`	`[i] [j] BLKDROP2`		Drops `i` stack elements under the top `j` elements. `1 <= i <= 15`, `0 <= j <= 15` Equivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.	`26`
`5F0i`	`[i] BLKDROP`		Equivalent to `DROP` performed `i` times.	`26`
`58`	`ROT`	`a b c - b c a`	Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.	`18`
`52ij`	`s[i] s[j-1] PUXC`		Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.	`26`
`55ij`	`[i+1] [j+1] BLKSWAP`		Permutes two blocks `s[j+i+1] ... s[j+1]` and `s[j] ... s0`. `0 <= i,j <= 15` Equivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.	`26`
`4ijk`	`s[i] s[j] s[k] XCHG3`		Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.	`26`
`53ij`	`s[i] s[j] PUSH2`		Equivalent to `s[i] PUSH` `s[j+1] PUSH`.	`26`
`57ii`	`[ii] s() POP`		Pops the old `s0` value into the old `s[ii]`. `0 <= ii <= 255`	`26`
`51ij`	`s[i] s[j] XCPU`		Equivalent to `s[i] XCHG0` `s[j] PUSH`.	`26`
`545ijk`	`s[i] s[j-1] s[k-1] PUXCPU`		Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.	`34`
`541ijk`	`s[i] s[j] s[k] XC2PU`		Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.	`34`
`5B`	`DROP2 2DROP`	`a b -`	Equivalent to `DROP` `DROP`.	`18`
`542ijk`	`s[i] s[j] s[k-1] XCPUXC`		Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.	`34`
`56ii`	`[ii] s() PUSH`		Pushes a copy of the old `s[ii]` into the stack. `0 <= ii <= 255`	`26`
`547ijk`	`s[i] s[j] s[k] PUSH3`		Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.	`34`
`5A`	`SWAP2 2SWAP`	`a b c d - c d a b`	Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.	`18`
`66`	`TUCK`	`a b - b a b`	Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.	`18`
`5C`	`DUP2 2DUP`	`a b - a b a b`	Equivalent to `s1 s0 PUSH2`.	`18`
`546ijk`	`s[i] s[j-1] s[k-2] PU2XC`		Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.	`34`
`543ijk`	`s[i] s[j] s[k] XCPU2`		Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.	`34`
`544ijk`	`s[i] s[j-1] s[k-1] PUXC2`		Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.	`34`
`5Eij`	`[i+2] [j] REVERSE`		Reverses the order of `s[j+i+1] ... s[j]`.	`26`
`5D`	`OVER2 2OVER`	`a b c d - a b c d a b`	Equivalent to `s3 s2 PUSH2`.	`18`
`00`	`NOP`	`-`	Does nothing.	`18`
`63`	`BLKSWX`		Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.	`18`
`60`	`PICK PUSHX`		Pops integer `i` from the stack, then performs `s[i] PUSH`.	`18`
`61`	`ROLLX`		Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.	`18`
`62`	`-ROLLX ROLLREVX`		Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.	`18`
`5Fij`	`[i] [j] BLKPUSH`		Equivalent to `PUSH s(j)` performed `i` times. `1 <= i <= 15`, `0 <= j <= 15`.	`26`
`64`	`REVX`		Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.	`18`
`65`	`DROPX`		Pops integer `i` from the stack, then performs `[i] BLKDROP`.	`18`
`67`	`XCHGX`		Pops integer `i` from the stack, then performs `s[i] XCHG`.	`18`
`68`	`DEPTH`	`- depth`	Pushes the current depth of the stack.	`18`
`69`	`CHKDEPTH`	`i -`	Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.	`18/58`
`6A`	`ONLYTOPX`		Pops integer `i` from the stack, then removes all but the top `i` elements.	`18`
`6B`	`ONLYX`		Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.	`18`
`540ijk`	`s[i] s[j] s[k] XCHG3_l`		Long form of `XCHG3`.	`34`

Opcode	Fift syntax	Stack	Description	Gas
`6F0n`	`[n] TUPLE`	`x_1 ... x_n - t`	Creates a new Tuple `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`. `0 <= n <= 15`	`26+n`
`6FA1`	`NULLSWAPIFNOT`	`x - x or null x`	Pushes a Null under the topmost Integer `x`, but only if `x=0`. May be used for stack alignment after quiet primitives such as `PLDUXQ`.	`26`
`6D`	`NULL PUSHNULL`	`- null`	Pushes the only value of type Null.	`18`
`6E`	`ISNULL`	`x - ?`	Checks whether `x` is a Null, and returns `-1` or `0` accordingly.	`18`
`6F2n`	`[n] UNTUPLE`	`t - x_1 ... x_n`	Unpacks a Tuple `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`. If `t` is not a Tuple, or if `\|t\| != n`, a type check exception is thrown.	`26+n`
`6F1k`	`[k] INDEX`	`t - x`	Returns the `k`-th element of a Tuple `t`. `0 <= k <= 15`.	`26`
`6FA5`	`NULLSWAPIFNOT2`	`x - x or null null x`	Pushes two nulls under the topmost Integer `x`, but only if `x=0`. Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.	`26`
`6F8C`	`TPUSH COMMA`	`t x - t'`	Appends a value `x` to a Tuple `t=(x_1,...,x_n)`, but only if the resulting Tuple `t'=(x_1,...,x_n,x)` is of length at most 255. Otherwise throws a type check exception.	`26+\|t'\|`
`6F88`	`TLEN`	`t - n`	Returns the length of a Tuple.	`26`
`6F81`	`INDEXVAR`	`t k - x`	Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.	`26`
`6F8D`	`TPOP`	`t - t' x`	Detaches the last element `x=x_n` from a non-empty Tuple `t=(x_1,...,x_n)`, and returns both the resulting Tuple `t'=(x_1,...,x_{n-1})` and the original last element `x`.	`26+\|t'\|`
`6F85`	`SETINDEXVAR`	`t x k - t'`	Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.	`26+\|t'\|`
`6F84`	`EXPLODEVAR`	`t n - x_1 ... x_m m`	Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.	`26+m`
`6F5k`	`[k] SETINDEX`	`t x - t'`	Computes Tuple `t'` that differs from `t` only at position `t'_{k+1}`, which is set to `x`. `0 <= k <= 15` If `k >= \|t\|`, throws a range check exception.	`26+\|t\|`
`6F89`	`QTLEN`	`t - n or -1`	Similar to `TLEN`, but returns `-1` if `t` is not a Tuple.	`26`
`6F6k`	`[k] INDEXQ`	`t - x`	Returns the `k`-th element of a Tuple `t`, where `0 <= k <= 15`. In other words, returns `x_{k+1}` if `t=(x_1,...,x_n)`. If `k>=n`, or if `t` is Null, returns a Null instead of `x`.	`26`
`6FBij`	`[i] [j] INDEX2`	`t - x`	Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`. Equivalent to `[i] INDEX` `[j] INDEX`.	`26`
`6FE_ijk`	`[i] [j] [k] INDEX3`	`t - x`	Recovers `x=t_{i+1}_{j+1}_{k+1}`. `0 <= i,j,k <= 3` Equivalent to `[i] [j] INDEX2` `[k] INDEX`.	`26`
`6F8A`	`ISTUPLE`	`t - ?`	Returns `-1` or `0` depending on whether `t` is a Tuple.	`26`
`6F3k`	`[k] UNPACKFIRST`	`t - x_1 ... x_k`	Unpacks first `0 <= k <= 15` elements of a Tuple `t`. If `\|t\|<k`, throws a type check exception.	`26+k`
`6F4n`	`[n] EXPLODE`	`t - x_1 ... x_m m`	Unpacks a Tuple `t=(x_1,...,x_m)` and returns its length `m`, but only if `m <= n <= 15`. Otherwise throws a type check exception.	`26+m`
`6F7k`	`[k] SETINDEXQ`	`t x - t'`	Sets the `k`-th component of Tuple `t` to `x`, where `0 <= k < 16`, and returns the resulting Tuple `t'`. If `\|t\| <= k`, first extends the original Tuple to length `n'=k+1` by setting all new components to Null. If the original value of `t` is Null, treats it as an empty Tuple. If `t` is not Null or Tuple, throws an exception. If `x` is Null and either `\|t\| <= k` or `t` is Null, then always returns `t'=t` (and does not consume tuple creation gas).	`26+\|t'\|`
`6F80`	`TUPLEVAR`	`x_1 ... x_n n - t`	Creates a new Tuple `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F82`	`UNTUPLEVAR`	`t n - x_1 ... x_n`	Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F83`	`UNPACKFIRSTVAR`	`t n - x_1 ... x_n`	Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.	`26+n`
`6F86`	`INDEXVARQ`	`t k - x`	Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.	`26`
`6F87`	`SETINDEXVARQ`	`t x k - t'`	Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.	`26+\|t'\|`
`6F8B`	`LAST`	`t - x`	Returns the last element of a non-empty Tuple `t`.	`26`
`6FA0`	`NULLSWAPIF`	`x - x or null x`	Pushes a Null under the topmost Integer `x`, but only if `x!=0`.	`26`
`6FA2`	`NULLROTRIF`	`x y - x y or null x y`	Pushes a Null under the second stack entry from the top, but only if the topmost Integer `y` is non-zero.	`26`
`6FA3`	`NULLROTRIFNOT`	`x y - x y or null x y`	Pushes a Null under the second stack entry from the top, but only if the topmost Integer `y` is zero. May be used for stack alignment after quiet primitives such as `LDUXQ`.	`26`
`6FA4`	`NULLSWAPIF2`	`x - x or null null x`	Pushes two nulls under the topmost Integer `x`, but only if `x!=0`. Equivalent to `NULLSWAPIF` `NULLSWAPIF`.	`26`
`6FA6`	`NULLROTRIF2`	`x y - x y or null null x y`	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer `y` is non-zero. Equivalent to `NULLROTRIF` `NULLROTRIF`.	`26`
`6FA7`	`NULLROTRIFNOT2`	`x y - x y or null null x y`	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer `y` is zero. Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`82lxxx`	`[xxx] PUSHINT [xxx] INT`	`- xxx`	Pushes integer `xxx`. Details: 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`. The total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.	`23`
`81xxxx`	`[xxxx] PUSHINT [xxxx] INT`	`- xxxx`	Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.	`34`
`9xccc`	`[builder] PUSHCONT [builder] CONT`	`- c`	Pushes a continuation made from `builder`. Details: Pushes an `x`-byte continuation for `0 <= x <= 15`.	`18`
`7i`	`[x] PUSHINT [x] INT`	`- x`	Pushes integer `x` into the stack. `-5 <= x <= 10`. Here `i` equals four lower-order bits of `x` (`i=x mod 16`).	`18`
`8F_rxxcccc`	`[builder] PUSHCONT [builder] CONT`	`- c`	Pushes a continuation made from `builder`. Details: Pushes the simple ordinary continuation `cccc` made from the first `0 <= r <= 3` references and the first `0 <= xx <= 127` bytes of `cc.code`.	`26`
`83xx`	`[xx+1] PUSHPOW2`	`- 2^(xx+1)`	(Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`. `2^256` is a `NaN`.	`26`
`80xx`	`[xx] PUSHINT [xx] INT`	`- xx`	Pushes integer `xx`. `-128 <= xx <= 127`.	`26`
`8Drxxsssss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the subslice of `cc.code` consisting of `0 <= r <= 4` references and up to `8xx+6` bits of data, with `0 <= xx <= 127`. A completion tag is assumed.	`28`
`84xx`	`[xx+1] PUSHPOW2DEC`	`- 2^(xx+1)-1`	Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.	`26`
`8Bxsss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the (prefix) subslice of `cc.code` consisting of its first `8x+4` bits and no references (i.e., essentially a bitstring), where `0 <= x <= 15`. A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring. If the original bitstring consists only of zeroes, an empty slice will be pushed.	`22`
`8A`	`[ref] PUSHREFCONT`	`- cont`	Similar to `PUSHREFSLICE`, but makes a simple ordinary Continuation out of the cell.	`118/43`
`89`	`[ref] PUSHREFSLICE`	`- s`	Similar to `PUSHREF`, but converts the cell into a Slice.	`118/43`
`88`	`[ref] PUSHREF`	`- c`	Pushes the reference `ref` into the stack. Details: Pushes the first reference of `cc.code` into the stack as a Cell (and removes this reference from the current continuation).	`18`
`83FF`	`PUSHNAN`	`- NaN`	Pushes a `NaN`.	`26`
`8Crxxssss`	`[slice] PUSHSLICE [slice] SLICE`	`- s`	Pushes the slice `slice` into the stack. Details: Pushes the (prefix) subslice of `cc.code` consisting of its first `1 <= r+1 <= 4` references and up to first `8xx+1` bits of data, with `0 <= xx <= 31`. A completion tag is also assumed.	`25`
`85xx`	`[xx+1] PUSHNEGPOW2`	`- -2^(xx+1)`	Pushes `-2^(xx+1)` for `0 <= xx <= 255`.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`A4`	`INC`	`x - x+1`	Equivalent to `1 ADDCONST`.	`18`
`B0`	`AND`	`x y - x&y`	Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.	`18`
`A0`	`ADD`	`x y - x+y`		`18`
`A1`	`SUB`	`x y - x-y`		`18`
`A3`	`NEGATE`	`x - -x`	Equivalent to `-1 MULCONST` or to `ZERO SUBR`. Notice that it triggers an integer overflow exception if `x=-2^256`.	`18`
`A8`	`MUL`	`x y - x*y`		`18`
`B1`	`OR`	`x y - x\|y`	Bitwise or of two integers.	`18`
`A904`	`DIV`	`x y - q`	`q=floor(x/y)`, `r=x-y*q`	`26`
`B3`	`NOT`	`x - ~x`	Bitwise not of an integer.	`26`
`AAcc`	`[cc+1] LSHIFT#`	`x - x*2^(cc+1)`	`0 <= cc <= 255`	`26`
`A9B4tt`	`[tt+1] MULRSHIFT#`	`x y - floor(x*y/2^(tt+1))`		`34`
`A984`	`MULDIV`	`x y z - q`	`q=floor(x*y/z)`	`26`
`ABcc`	`[cc+1] RSHIFT#`	`x - floor(x/2^(cc+1))`	`0 <= cc <= 255`	`18`
`A6cc`	`[cc] ADDCONST [cc] ADDINT [-cc] SUBCONST [-cc] SUBINT`	`x - x+cc`	`-128 <= cc <= 127`.	`26`
`B608`	`MIN`	`x y - x or y`	Computes the minimum of two integers `x` and `y`.	`26`
`A985`	`MULDIVR`	`x y z - q'`	`q'=round(x*y/z)`	`26`
`A7cc`	`[cc] MULCONST [cc] MULINT`	`x - x*cc`	`-128 <= cc <= 127`.	`26`
`A5`	`DEC`	`x - x-1`	Equivalent to `-1 ADDCONST`.	`18`
`A908`	`MOD`	`x y - r`		`26`
`A938tt`	`[tt+1] MODPOW2#`	`x - x mod 2^(tt+1)`		`34`
`B609`	`MAX`	`x y - x or y`	Computes the maximum of two integers `x` and `y`.	`26`
`AE`	`POW2`	`y - 2^y`	`0 <= y <= 1023` Equivalent to `ONE` `SWAP` `LSHIFT`.	`18`
`A906`	`DIVC`	`x y - q''`	`q''=ceil(x/y)`, `r''=x-y*q''`	`26`
`B60B`	`ABS`	`x - \|x\|`	Computes the absolute value of an integer `x`.	`26`
`A986`	`MULDIVC`	`x y z - q'`	`q'=ceil(x*y/z)`	`26`
`A90C`	`DIVMOD`	`x y - q r`		`26`
`B2`	`XOR`	`x y - x xor y`	Bitwise xor of two integers.	`18`
`A98C`	`MULDIVMOD`	`x y z - q r`	`q=floor(xy/z)`, `r=xy-z*q`	`26`
`B603`	`UBITSIZE`	`x - c`	Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.	`26`
`B601`	`UFITSX`	`x c - x`	Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.	`26/76`
`AC`	`LSHIFT`	`x y - x*2^y`	`0 <= y <= 1023`	`18`
`A935tt`	`[tt+1] RSHIFTR#`	`x - round(x/2^(tt+1))`		`34`
`AD`	`RSHIFT`	`x y - floor(x/2^y)`	`0 <= y <= 1023`	`18`
`A9B5tt`	`[tt+1] MULRSHIFTR#`	`x y - round(x*y/2^(tt+1))`		`34`
`A936tt`	`[tt+1] RSHIFTC#`	`x - ceil(x/2^(tt+1))`		`34`
`B7A8`	`QMUL`	`x y - x*y`		`26`
`B7A98C`	`QMULDIVMOD`	`x y z - q r`		`34`
`A9D6tt`	`[tt+1] LSHIFT#DIVC`	`x y - ceil(2^(tt+1)*x/y)`		`26`
`A9D5tt`	`[tt+1] LSHIFT#DIVR`	`x y - round(2^(tt+1)*x/y)`		`34`
`A9BD`	`MULRSHIFTR#MOD`	`x y - q=round(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9CD`	`LSHIFTDIVMODR`	`x y z - q=round(2^zx/y) r=2^zx-q*y`		`26`
`A925`	`RSHIFTR`	`x y - round(x/2^y)`		`26`
`B5cc`	`[cc+1] UFITS`	`x - x`	Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).	`26/76`
`A905`	`DIVR`	`x y - q'`	`q'=round(x/y)`, `r'=x-y*q'`	`26`
`A900`	`ADDDIVMOD`	`x w z - q=floor((x+w)/z) r=(x+w)-zq`		`26`
`A901`	`ADDDIVMODR`	`x w z - q=round((x+w)/z) r=(x+w)-zq`		`26`
`A902`	`ADDDIVMODC`	`x w y - q=ceil((x+w)/z) r=(x+w)-zq`		`26`
`A930tt`	`[tt+1] ADDRSHIFT#MOD`	`x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`A921`	`ADDRSHIFTMODR`	`x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z`		`26`
`A922`	`ADDRSHIFTMODC`	`x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z`		`26`
`A90D`	`DIVMODR`	`x y - q' r'`		`26`
`A90E`	`DIVMODC`	`x y - q'' r''`		`26`
`A2`	`SUBR`	`x y - y-x`	Equivalent to `SWAP` `SUB`.	`18`
`A909`	`MODR`	`x y - r`		`26`
`A90A`	`MODC`	`x y - r`		`26`
`A926`	`RSHIFTC`	`x y - ceil(x/2^y)`		`26`
`A928`	`MODPOW2`	`x y - x mod 2^y`		`26`
`A929`	`MODPOW2R`	`x y - x mod 2^y`		`26`
`A92A`	`MODPOW2C`	`x y - x mod 2^y`		`26`
`A92C`	`RSHIFTMOD`	`x y - q=floor(x/2^y) r=x-q*2^y`		`26`
`A92D`	`RSHIFTMODR`	`x y - q=round(x/2^y) r=x-q*2^y`		`26`
`A92E`	`RSHIFTMODC`	`x y - q=ceil(x/2^y) r=x-q*2^y`		`26`
`A931tt`	`[tt+1] ADDRSHIFTR#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`A932tt`	`[tt+1] ADDRSHIFTC#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`34`
`B602`	`BITSIZE`	`x - c`	Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).	`26`
`B4cc`	`[cc+1] FITS`	`x - x`	Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`). If not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).	`26/76`
`B600`	`FITSX`	`x c - x`	Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.	`26/76`
`A9D0tt`	`[tt+1] LSHIFT#ADDDIVMOD`	`x w z - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9D2tt`	`[tt+1] LSHIFT#ADDDIVMODC`	`x w z - q=ceil((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9C2`	`LSHIFTADDDIVMODC`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9D1tt`	`[tt+1] LSHIFT#ADDDIVMODR`	`x w z - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`A9C1`	`LSHIFTADDDIVMODR`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9C0`	`LSHIFTADDDIVMOD`	`x w z y - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`26`
`A9D4tt`	`[tt+1] LSHIFT#DIV`	`x y - floor(2^(tt+1)*x/y)`		`34`
`A9C6`	`LSHIFTDIVC`	`x y z - ceil(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9DCtt`	`[tt+1] LSHIFT#DIVMOD`	`x y - q=floor(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9DEtt`	`[tt+1] LSHIFT#DIVMODC`	`x y - q=ceil(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9CE`	`LSHIFTDIVMODC`	`x y z - q=ceil(2^zx/y) r=2^zx-q*y`		`26`
`A9DDtt`	`[tt+1] LSHIFT#DIVMODR`	`x y - q=round(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`34`
`A9CC`	`LSHIFTDIVMOD`	`x y z - q=floor(2^zx/y) r=2^zx-q*y`		`26`
`A9C5`	`LSHIFTDIVR`	`x y z - round(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9C4`	`LSHIFTDIV`	`x y z - floor(2^z*x/y)`	`0 <= z <= 256`	`26`
`A9D8tt`	`[tt+1] LSHIFT#MOD`	`x y - 2^(tt+1)*x mod y`		`34`
`A9DAtt`	`[tt+1] LSHIFT#MODC`	`x y - 2^(tt+1)*x mod y`		`34`
`A9CA`	`LSHIFTMODC`	`x y z - 2^z*x mod y`		`26`
`A9D9tt`	`[tt+1] LSHIFT#MODR`	`x y - 2^(tt+1)*x mod y`		`34`
`A9C9`	`LSHIFTMODR`	`x y z - 2^z*x mod y`		`26`
`A9C8`	`LSHIFTMOD`	`x y z - 2^z*x mod y`		`26`
`B60A`	`MINMAX INTSORT2`	`x y - x y or y x`	Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.	`26`
`A93Att`	`[tt+1] MODPOW2C#`	`x - x mod 2^(tt+1)`		`34`
`A939tt`	`[tt+1] MODPOW2R#`	`x - x mod 2^(tt+1)`		`34`
`A980`	`MULADDDIVMOD`	`x y w z - q=floor((xy+w)/z) r=(xy+w)-zq`		`26`
`A982`	`MULADDDIVMODC`	`x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq`		`26`
`A981`	`MULADDDIVMODR`	`x y w z - q=round((xy+w)/z) r=(xy+w)-zq`		`26`
`A9B2tt`	`[tt+1] MULADDRSHIFTC#MOD`	`x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A9B0tt`	`[tt+1] MULADDRSHIFT#MOD`	`x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A9B1tt`	`[tt+1] MULADDRSHIFTR#MOD`	`x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z`		`34`
`A98E`	`MULDIVMODC`	`x y z - q r`	`q=ceil(xy/z)`, `r=xy-z*q`	`26`
`A98D`	`MULDIVMODR`	`x y z - q r`	`q=round(xy/z)`, `r=xy-z*q`	`26`
`A988`	`MULMOD`	`x y z - x*y mod z`		`26`
`A98A`	`MULMODC`	`x y z - x*y mod z`		`26`
`A9B8tt`	`[tt+1] MULMODPOW2#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9BAtt`	`[tt+1] MULMODPOW2C#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9AA`	`MULMODPOW2C_VAR`	`x y z - x*y mod 2^z`		`26`
`A9B9tt`	`[tt+1] MULMODPOW2R#`	`x y - x*y mod 2^(tt+1)`		`34`
`A9A9`	`MULMODPOW2R_VAR`	`x y z - x*y mod 2^z`		`26`
`A9A8`	`MULMODPOW2_VAR`	`x y z - x*y mod 2^z`		`26`
`A989`	`MULMODR`	`x y z - x*y mod z`		`26`
`A9B6tt`	`[tt+1] MULRSHIFTC#`	`x y - ceil(x*y/2^(tt+1))`		`34`
`A9BE`	`MULRSHIFTC#MOD`	`x y - q=ceil(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9AE`	`MULRSHIFTCMOD_VAR`	`x y z - q=ceil(xy/2^z) r=xy-q2^z`		`26`
`A9A6`	`MULRSHIFTC`	`x y z - ceil(x*y/2^z)`	`0 <= z <= 256`	`26`
`A9BC`	`MULRSHIFT#MOD`	`x y - q=floor(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`34`
`A9AC`	`MULRSHIFTMOD_VAR`	`x y z - q=floor(xy/2^z) r=xy-q2^z`		`26`
`A9AD`	`MULRSHIFTRMOD_VAR`	`x y z - q=round(xy/2^z) r=xy-q2^z`		`26`
`A9A5`	`MULRSHIFTR`	`x y z - round(x*y/2^z)`	`0 <= z <= 256`	`26`
`A9A4`	`MULRSHIFT`	`x y z - floor(x*y/2^z)`	`0 <= z <= 256`	`26`
`B7A0`	`QADD`	`x y - x+y`		`26`
`B7A900`	`QADDDIVMOD`	`x w z - q=floor((x+w)/z) r=(x+w)-zq`		`34`
`B7A902`	`QADDDIVMODC`	`x w y - q=ceil((x+w)/z) r=(x+w)-zq`		`34`
`B7A901`	`QADDDIVMODR`	`x w z - q=round((x+w)/z) r=(x+w)-zq`		`34`
`B7A932tt`	`[tt+1] QADDRSHIFTC#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`B7A930tt`	`[tt+1] QADDRSHIFT#MOD`	`x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`B7A922`	`QADDRSHIFTMODC`	`x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z`		`34`
`B7A921`	`QADDRSHIFTMODR`	`x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z`		`34`
`B7A931tt`	`[tt+1] QADDRSHIFTR#MOD`	`x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)`		`42`
`B7B0`	`QAND`	`x y - x&y`		`26`
`B7A5`	`QDEC`	`x - x-1`		`26`
`B7A904`	`QDIV`	`x y - q`	Division returns `NaN` if `y=0`.	`34`
`B7A906`	`QDIVC`	`x y - q''`		`34`
`B7A90C`	`QDIVMOD`	`x y - q r`		`34`
`B7A90E`	`QDIVMODC`	`x y - q'' r''`		`34`
`B7A90D`	`QDIVMODR`	`x y - q' r'`		`34`
`B7A905`	`QDIVR`	`x y - q'`		`34`
`B7B4cc`	`[cc+1] QFITS`	`x - x`	Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.	`34`
`B7B600`	`QFITSX`	`x c - x`	Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.	`34`
`B7A4`	`QINC`	`x - x+1`		`26`
`B7AAcc`	`[cc+1] QLSHIFT#`	`x - x*2^(cc+1)`	`0 <= cc <= 255`	`34`
`B7A9D0tt`	`[tt+1] QLSHIFT#ADDDIVMOD`	`x w z - q=floor((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9D2tt`	`[tt+1] QLSHIFT#ADDDIVMODC`	`x w z - q=ceil((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9C2`	`QLSHIFTADDDIVMODC`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9D1tt`	`[tt+1] QLSHIFT#ADDDIVMODR`	`x w z - q=round((x2^(tt+1)+w)/z) r=(x2^(tt+1)+w)-zq`		`42`
`B7A9C1`	`QLSHIFTADDDIVMODR`	`x w z y - q=round((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9C0`	`QLSHIFTADDDIVMOD`	`x w z y - q=floor((x2^y+w)/z) r=(x2^y+w)-zq`		`34`
`B7A9D4tt`	`[tt+1] QLSHIFT#DIV`	`x y - floor(2^(tt+1)*x/y)`		`42`
`B7A9D6tt`	`[tt+1] QLSHIFT#DIVC`	`x y - ceil(2^(tt+1)*x/y)`		`34`
`B7A9C6`	`QLSHIFTDIVC`	`x y z - ceil(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9DCtt`	`[tt+1] QLSHIFT#DIVMOD`	`x y - q=floor(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9DEtt`	`[tt+1] QLSHIFT#DIVMODC`	`x y - q=ceil(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9CE`	`QLSHIFTDIVMODC`	`x y z - q=ceil(2^zx/y) r=2^zx-q*y`		`34`
`B7A9DDtt`	`[tt+1] QLSHIFT#DIVMODR`	`x y - q=round(2^(tt+1)x/y) r=2^(tt+1)x-q*y`		`42`
`B7A9CD`	`QLSHIFTDIVMODR`	`x y z - q=round(2^zx/y) r=2^zx-q*y`		`34`
`B7A9CC`	`QLSHIFTDIVMOD`	`x y z - q=floor(2^zx/y) r=2^zx-q*y`		`34`
`B7A9D5tt`	`[tt+1] QLSHIFT#DIVR`	`x y - round(2^(tt+1)*x/y)`		`42`
`B7A9C5`	`QLSHIFTDIVR`	`x y z - round(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9C4`	`QLSHIFTDIV`	`x y z - floor(2^z*x/y)`	`0 <= z <= 256`	`34`
`B7A9D8tt`	`[tt+1] QLSHIFT#MOD`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9DAtt`	`[tt+1] QLSHIFT#MODC`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9CA`	`QLSHIFTMODC`	`x y z - 2^z*x mod y`		`34`
`B7A9D9tt`	`[tt+1] LSHIFT#MODR`	`x y - 2^(tt+1)*x mod y`		`42`
`B7A9C9`	`QLSHIFTMODR`	`x y z - 2^z*x mod y`		`34`
`B7A9C8`	`QLSHIFTMOD`	`x y z - 2^z*x mod y`		`34`
`B7AC`	`QLSHIFT`	`x y - x*2^y`		`26`
`B7A908`	`QMOD`	`x y - r`		`34`
`B7A90A`	`QMODC`	`x y - r`		`34`
`B7A938tt`	`[tt+1] QMODPOW2#`	`x - x mod 2^(tt+1)`		`42`
`B7A93Att`	`[tt+1] QMODPOW2C#`	`x - x mod 2^(tt+1)`		`42`
`B7A92A`	`QMODPOW2C`	`x y - x mod 2^y`		`34`
`B7A939tt`	`[tt+1] QMODPOW2R#`	`x - x mod 2^(tt+1)`		`42`
`B7A929`	`QMODPOW2R`	`x y - x mod 2^y`		`34`
`B7A928`	`QMODPOW2`	`x y - x mod 2^y`		`34`
`B7A909`	`QMODR`	`x y - r`		`34`
`B7A980`	`QMULADDDIVMOD`	`x y w z - q=floor((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A982`	`QMULADDDIVMODC`	`x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A981`	`QMULADDDIVMODR`	`x y w z - q=round((xy+w)/z) r=(xy+w)-zq`		`34`
`B7A9B2tt`	`[tt+1] QMULADDRSHIFTC#MOD`	`x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A9B0tt`	`[tt+1] QMULADDRSHIFT#MOD`	`x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A9B1tt`	`[tt+1] QMULADDRSHIFTR#MOD`	`x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z`		`42`
`B7A984`	`QMULDIV`	`x y z - q`	`q=floor(x*y/z)`	`34`
`B7A986`	`QMULDIVC`	`x y z - q'`	`q'=ceil(x*y/z)`	`34`
`B7A98E`	`QMULDIVMODC`	`x y z - q r`	`q=ceil(xy/z)`, `r=xy-z*q`	`34`
`B7A98D`	`QMULDIVMODR`	`x y z - q r`	`q=round(xy/z)`, `r=xy-z*q`	`34`
`B7A985`	`QMULDIVR`	`x y z - q'`		`34`
`B7A988`	`QMULMOD`	`x y z - x*y mod z`		`34`
`B7A98A`	`QMULMODC`	`x y z - x*y mod z`		`34`
`B7A9B8tt`	`[tt+1] QMULMODPOW2#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9BAtt`	`[tt+1] QMULMODPOW2C#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9AA`	`QMULMODPOW2C_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A9B9tt`	`[tt+1] QMULMODPOW2R#`	`x y - x*y mod 2^(tt+1)`		`42`
`B7A9A9`	`QMULMODPOW2R_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A9A8`	`QMULMODPOW2_VAR`	`x y z - x*y mod 2^z`		`34`
`B7A989`	`QMULMODR`	`x y z - x*y mod z`		`34`
`B7A9B4tt`	`[tt+1] QMULRSHIFT#`	`x y - floor(x*y/2^(tt+1))`		`42`
`B7A9B6tt`	`[tt+1] QMULRSHIFTC#`	`x y - ceil(x*y/2^(tt+1))`		`42`
`B7A9BE`	`QMULRSHIFTC#MOD`	`x y - q=ceil(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AE`	`QMULRSHIFTCMOD_VAR`	`x y z - q=ceil(xy/2^z) r=xy-q2^z`		`34`
`B7A9A6`	`QMULRSHIFTC`	`x y z - ceil(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A9BC`	`QMULRSHIFT#MOD`	`x y - q=floor(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AC`	`QMULRSHIFTMOD_VAR`	`x y z - q=floor(xy/2^z) r=xy-q2^z`		`34`
`B7A9B5tt`	`[tt+1] QMULRSHIFTR#`	`x y - round(x*y/2^(tt+1))`		`42`
`B7A9BD`	`QMULRSHIFTR#MOD`	`x y - q=round(xy/2^(tt+1)) r=xy-q2^(tt+1)`		`42`
`B7A9AD`	`QMULRSHIFTRMOD_VAR`	`x y z - q=round(xy/2^z) r=xy-q2^z`		`34`
`B7A9A5`	`QMULRSHIFTR`	`x y z - round(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A9A4`	`QMULRSHIFT`	`x y z - floor(x*y/2^z)`	`0 <= z <= 256`	`34`
`B7A3`	`QNEGATE`	`x - -x`		`26`
`B7B3`	`QNOT`	`x - ~x`		`26`
`B7B1`	`QOR`	`x y - x\|y`		`26`
`B7AE`	`QPOW2`	`y - 2^y`		`26`
`B7ABcc`	`[cc+1] RSHIFT#`	`x - floor(x/2^(cc+1))`	`0 <= cc <= 255`	`26`
`B7A936tt`	`[tt+1] QRSHIFTC#`	`x - ceil(x/2^(tt+1))`		`42`
`B7A93Ett`	`[tt+1] QRSHIFTC#MOD`	`x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A926`	`QRSHIFTC`	`x y - ceil(x/2^y)`		`34`
`A93Ctt`	`[tt+1] QRSHIFT#MOD`	`x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A92E`	`QRSHIFTMODC`	`x y - q=ceil(x/2^y) r=x-q*2^y`		`34`
`B7A92D`	`QRSHIFTMODR`	`x y - q=round(x/2^y) r=x-q*2^y`		`34`
`B7A92C`	`QRSHIFTMOD`	`x y - q=floor(x/2^y) r=x-q*2^y`		`34`
`B7A935tt`	`[tt+1] QRSHIFTR#`	`x - round(x/2^(tt+1))`		`42`
`A93Dtt`	`[tt+1] QRSHIFTR#MOD`	`x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)`		`42`
`B7A925`	`QRSHIFTR`	`x y - round(x/2^y)`		`34`
`B7AD`	`QRSHIFT`	`x y - floor(x/2^y)`		`26`
`B7A1`	`QSUB`	`x y - x-y`		`26`
`B7A2`	`QSUBR`	`x y - y-x`		`26`
`B7B5cc`	`[cc+1] QUFITS`	`x - x`	Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.	`34`
`B7B601`	`QUFITSX`	`x c - x`	Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.	`34`
`B7B2`	`QXOR`	`x y - x xor y`		`26`
`A93Ett`	`[tt+1] RSHIFTC#MOD`	`x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`
`A93Ctt`	`[tt+1] RSHIFT#MOD`	`x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`
`A93Dtt`	`[tt+1] RSHIFTR#MOD`	`x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)`		`34`

Opcode	Fift syntax	Stack	Description	Gas
`BA`	`EQUAL`	`x y - x=y`	Returns `-1` if `x=y`, `0` otherwise.	`18`
`BE`	`GEQ`	`x y - x>=y`	Equivalent to `LESS` `NOT`.	`18`
`C0yy`	`[yy] EQINT`	`x - x=yy`	Returns `-1` if `x=yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`C705`	`SDEQ`	`s s' - ?`	Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.	`26`
`C2yy`	`[yy] GTINT [yy+1] GEQINT`	`x - x>yy`	Returns `-1` if `x>yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`C700`	`SEMPTY`	`s - ?`	Checks whether a Slice `s` is empty (i.e., contains no bits of data and no cell references).	`26`
`BC`	`GREATER`	`x y - x>y`		`18`
`B9`	`LESS`	`x y - x<y`	Returns `-1` if `x<y`, `0` otherwise.	`18`
`C1yy`	`[yy] LESSINT [yy-1] LEQINT`	`x - x<yy`	Returns `-1` if `x<yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`C3yy`	`[yy] NEQINT`	`x - x!=yy`	Returns `-1` if `x!=yy`, `0` otherwise. `-2^7 <= yy < 2^7`.	`26`
`BB`	`LEQ`	`x y - x<=y`		`18`
`BD`	`NEQ`	`x y - x!=y`	Equivalent to `EQUAL` `NOT`.	`18`
`C701`	`SDEMPTY`	`s - ?`	Checks whether Slice `s` has no bits of data.	`26`
`C702`	`SREMPTY`	`s - ?`	Checks whether Slice `s` has no references.	`26`
`C70B`	`SDPPFXREV`	`s s' - ?`	Checks whether `s'` is a proper prefix of `s`.	`26`
`C704`	`SDLEXCMP`	`s s' - x`	Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.	`26`
`C4`	`ISNAN`	`x - x=NaN`	Checks whether `x` is a `NaN`.	`18`
`BF`	`CMP`	`x y - sgn(x-y)`	Computes the sign of `x-y`: `-1` if `x<y`, `0` if `x=y`, `1` if `x>y`. No integer overflow can occur here unless `x` or `y` is a `NaN`.	`18`
`C709`	`SDPFXREV`	`s s' - ?`	Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.	`26`
`C713`	`SDCNTTRAIL1`	`s - n`	Returns the number of trailing ones in `s`.	`26`
`B8`	`SGN`	`x - sgn(x)`	Computes the sign of an integer `x`: `-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.	`18`
`C703`	`SDFIRST`	`s - ?`	Checks whether the first bit of Slice `s` is a one.	`26`
`C710`	`SDCNTLEAD0`	`s - n`	Returns the number of leading zeroes in `s`.	`26`
`C5`	`CHKNAN`	`x - x`	Throws an arithmetic overflow exception if `x` is a `NaN`.	`18/68`
`C711`	`SDCNTLEAD1`	`s - n`	Returns the number of leading ones in `s`.	`26`
`C712`	`SDCNTTRAIL0`	`s - n`	Returns the number of trailing zeroes in `s`.	`26`
`C708`	`SDPFX`	`s s' - ?`	Checks whether `s` is a prefix of `s'`.	`26`
`C70A`	`SDPPFX`	`s s' - ?`	Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).	`26`
`C70E`	`SDPSFX`	`s s' - ?`	Checks whether `s` is a proper suffix of `s'`.	`26`
`C70F`	`SDPSFXREV`	`s s' - ?`	Checks whether `s'` is a proper suffix of `s`.	`26`
`C70C`	`SDSFX`	`s s' - ?`	Checks whether `s` is a suffix of `s'`.	`26`
`C70D`	`SDSFXREV`	`s s' - ?`	Checks whether `s'` is a suffix of `s`.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`D3cc`	`[cc+1] LDU`	`s - x s'`	Loads an unsigned `cc+1`-bit integer `x` from Slice `s`.	`26`
`CBcc`	`[cc+1] STU`	`x b - b'`	Stores an unsigned `cc+1`-bit integer `x` into Builder `b`. In all other respects it is similar to `STI`.	`26`
`D0`	`CTOS`	`c - s`	Converts a Cell into a Slice. Notice that `c` must be either an ordinary cell, or an exotic cell which is automatically loaded to yield an ordinary cell `c'`, converted into a Slice afterwards.	`118/43`
`C8`	`NEWC`	`- b`	Creates a new empty Builder.	`18`
`C9`	`ENDC`	`b - c`	Converts a Builder into an ordinary Cell.	`518`
`CF16`	`STSLICER`	`b s - b'`	Equivalent to `SWAP` `STSLICE`.	`26`
`D4`	`LDREF`	`s - c s'`	Loads a cell reference `c` from `s`.	`18`
`D718`	`LDSLICEX`	`s l - s'' s'`	Loads the first `0 <= l <= 1023` bits from Slice `s` into a separate Slice `s''`, returning the remainder of `s` as `s'`.	`26`
`D74E_n`	`[n] PLDREFIDX`	`s - c`	Returns the `n`-th cell reference of Slice `s`, where `0 <= n <= 3`.	`26`
`CC`	`STREF`	`c b - b'`	Stores a reference to Cell `c` into Builder `b`.	`18`
`D749`	`SBITS`	`s - l`	Returns the number of data bits in Slice `s`.	`26`
`D70Bcc`	`[cc+1] PLDU`	`s - x`	Preloads an unsigned `cc+1`-bit integer from `s`.	`34`
`CAcc`	`[cc+1] STI`	`x b - b'`	Stores a signed `cc+1`-bit integer `x` into Builder `b` for `0 <= cc <= 255`, throws a range check exception if `x` does not fit into `cc+1` bits.	`26`
`D2cc`	`[cc+1] LDI`	`s - x s'`	Loads (i.e., parses) a signed `cc+1`-bit integer `x` from Slice `s`, and returns the remainder of `s` as `s'`.	`26`
`D1`	`ENDS`	`s -`	Removes a Slice `s` from the stack, and throws an exception if it is not empty.	`18/68`
`D721`	`SDSKIPFIRST`	`s l - s'`	Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.	`26`
`CF00`	`STIX`	`x b l - b'`	Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.	`26`
`CF01`	`STUX`	`x b l - b'`	Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.	`26`
`CF31`	`BBITS`	`b - x`	Returns the number of data bits already stored in Builder `b`.	`26`
`CF17`	`STBR BCONCAT`	`b b' - b''`	Concatenates two builders. Equivalent to `SWAP` `STB`.	`26`
`D74A`	`SREFS`	`s - r`	Returns the number of references in Slice `s`.	`26`
`D6cc`	`[cc+1] LDSLICE`	`s - s'' s'`	Cuts the next `cc+1` bits of `s` into a separate Slice `s''`.	`26`
`D70Acc`	`[cc+1] PLDI`	`s - x`	Preloads a signed `cc+1`-bit integer from Slice `s`.	`34`
`D719`	`PLDSLICEX`	`s l - s''`	Returns the first `0 <= l <= 1023` bits of `s` as `s''`.	`26`
`CF40`	`STZEROES`	`b n - b'`	Stores `n` binary zeroes into Builder `b`.	`26`
`D701`	`LDUX`	`s l - x s'`	Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.	`26`
`CE`	`STSLICE`	`s b - b'`	Stores Slice `s` into Builder `b`.	`18`
`D736`	`SPLIT`	`s l r - s' s''`	Splits the first `0 <= l <= 1023` data bits and first `0 <= r <= 4` references from `s` into `s'`, returning the remainder of `s` as `s''`.	`26`
`D700`	`LDIX`	`s l - x s'`	Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from Slice `s`, and returns the remainder of `s` as `s'`.	`26`
`D723`	`SDSKIPLAST`	`s l - s'`	Returns all but the last `0 <= l <= 1023` bits of `s`.	`26`
`D722`	`SDCUTLAST`	`s l - s'`	Returns the last `0 <= l <= 1023` bits of `s`.	`26`
`D74B`	`SBITREFS`	`s - l r`	Returns both the number of data bits and the number of references in `s`.	`26`
`D5`	`LDREFRTOS`	`s - s' s''`	Equivalent to `LDREF` `SWAP` `CTOS`.	`118/43`
`D724`	`SDSUBSTR`	`s l l' - s'`	Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.	`26`
`CF13`	`STB`	`b' b - b''`	Appends all data from Builder `b'` to Builder `b`.	`26`
`D739`	`XCTOS`	`c - s ?`	Transforms an ordinary or exotic cell into a Slice, as if it were an ordinary cell. A flag is returned indicating whether `c` is exotic. If that be the case, its type can later be deserialized from the first eight bits of `s`.
`D703`	`PLDUX`	`s l - x`	Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.	`26`
`D765`	`CDEPTH`	`c - x`	Returns the depth of Cell `c`. If `c` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `c`. If `c` is a Null instead of a Cell, returns zero.	`26`
`CFC0_xysss`	`[slice] STSLICECONST`	`b - b'`	Stores a constant subslice `sss`. Details: `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed. Note that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.	`24`
`D720`	`SDCUTFIRST`	`s l - s'`	Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.	`26`
`D764`	`SDEPTH`	`s - x`	Returns the depth of Slice `s`. If `s` has no references, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `s`.	`26`
`CF41`	`STONES`	`b n - b'`	Stores `n` binary ones into Builder `b`.	`26`
`D72E_xsss`	`[slice] SDBEGINSQ`	`s - s'' -1 or s 0`	A quiet version of `SDBEGINS`.	`31`
`D732`	`SCUTLAST`	`s l r - s'`	Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.	`26`
`D751`	`LDULE4`	`s - x s'`	Loads a little-endian unsigned 32-bit integer.	`26`
`CF11`	`STBREF`	`b' b - b''`	Equivalent to `SWAP` `STBREFR`.	`526`
`CF23`	`ENDXC`	`b x - c`	If `x!=0`, creates a special or exotic cell from Builder `b`. The type of the exotic cell must be stored in the first 8 bits of `b`. If `x=0`, it is equivalent to `ENDC`. Otherwise some validity checks on the data and references of `b` are performed before creating the exotic cell.	`526`
`D714_c`	`[32(c+1)] PLDUZ`	`s - s x`	Preloads the first `32(c+1)` bits of Slice `s` into an unsigned integer `x`, for `0 <= c <= 7`. If `s` is shorter than necessary, missing bits are assumed to be zero. This operation is intended to be used along with `IFBITJMP` and similar instructions.	`26`
`D71Dcc`	`[cc+1] PLDSLICE`	`s - s''`	Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.	`34`
`CF0Bcc`	`[cc+1] STUR`	`b x - b'`	Equivalent to `SWAP` `[cc+1] STU`.	`34`
`D72A_xsss`	`[slice] SDBEGINS`	`s - s''`	Checks whether `s` begins with constant bitstring `sss` of length `8x+3` (with continuation bit assumed), where `0 <= x <= 127`, and removes `sss` from `s` on success.	`31`
`CF3D`	`BCHKBITSQ`	`b x - ?`	Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.	`26`
`CF29`	`STULE4`	`x b - b'`	Stores a little-endian unsigned 32-bit integer.	`26`
`D705`	`LDUXQ`	`s l - x s' -1 or s 0`	Quiet version of `LDUX`.	`26`
`CF0Acc`	`[cc+1] STIR`	`b x - b'`	Equivalent to `SWAP` `[cc+1] STI`.	`34`
`CF14`	`STREFR`	`b c - b'`	Equivalent to `SWAP` `STREF`.	`26`
`D73A`	`XLOAD`	`c - c'`	Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, throws an exception.
`CF33`	`BBITREFS`	`b - x y`	Returns the numbers of both data bits and cell references in `b`.	`26`
`CF3B`	`BCHKBITREFS`	`b x y -`	Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.	`26/76`
`CF3F`	`BCHKBITREFSQ`	`b x y - ?`	Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.	`26`
`CF38cc`	`[cc+1] BCHKBITS#`	`b -`	Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.	`34/84`
`CF3Ccc`	`[cc+1] BCHKBITSQ#`	`b - ?`	Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.	`34`
`CF39`	`BCHKBITS`	`b x -`	Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`. If there is no space for `x` more bits in `b`, or if `x` is not within the range `0...1023`, throws an exception.	`26/76`
`CF3A`	`BCHKREFS`	`b y -`	Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.	`26/76`
`CF3E`	`BCHKREFSQ`	`b y - ?`	Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.	`26`
`CF30`	`BDEPTH`	`b - x`	Returns the depth of Builder `b`. If no cell references are stored in `b`, then `x=0`; otherwise `x` is one plus the maximum of depths of cells referred to from `b`.	`26`
`CF32`	`BREFS`	`b - y`	Returns the number of cell references already stored in `b`.	`26`
`CF37`	`BREMBITREFS`	`b - x' y'`	Returns the numbers of both data bits and references that can still be stored in `b`.	`26`
`CF35`	`BREMBITS`	`b - x'`	Returns the number of data bits that can still be stored in `b`.	`26`
`CF36`	`BREMREFS`	`b - y'`	Returns the number of references that can still be stored in `b`.	`26`
`D76E_`	`[i] CDEPTHI`	`cell - depth`	Returns `i`th depth of the cell.	`26`
`D771`	`CDEPTHIX`	`cell i - depth`	Returns `i`th depth of the cell.	`26`
`D76A_`	`[i] CHASHI`	`cell - hash`	Returns `i`th hash of the cell.	`26`
`D770`	`CHASHIX`	`cell i - hash`	Returns `i`th hash of the cell.	`26`
`D766`	`CLEVEL`	`cell - level`	Returns level of the cell.	`26`
`D767`	`CLEVELMASK`	`cell - level_mask`	Returns level mask of the cell.	`26`
`D750`	`LDILE4`	`s - x s'`	Loads a little-endian signed 32-bit integer.	`26`
`D758`	`LDILE4Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian signed 32-bit integer.	`26`
`D752`	`LDILE8`	`s - x s'`	Loads a little-endian signed 64-bit integer.	`26`
`D75A`	`LDILE8Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian signed 64-bit integer.	`26`
`D70Ccc`	`[cc+1] LDIQ`	`s - x s' -1 or s 0`	A quiet version of `LDI`.	`34`
`D704`	`LDIXQ`	`s l - x s' -1 or s 0`	Quiet version of `LDIX`: loads a signed `l`-bit integer from `s` similarly to `LDIX`, but returns a success flag, equal to `-1` on success or to `0` on failure (if `s` does not have `l` bits), instead of throwing a cell underflow exception.	`26`
`D708cc`	`[cc+1] LDI_l`	`s - x s'`	A longer encoding for `LDI`.	`34`
`D761`	`LDONES`	`s - n s'`	Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.	`26`
`D762`	`LDSAME`	`s x - n s'`	Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.	`26`
`D71Ecc`	`[cc+1] LDSLICEQ`	`s - s'' s' -1 or s 0`	A quiet version of `LDSLICE`.	`34`
`D71A`	`LDSLICEXQ`	`s l - s'' s' -1 or s 0`	A quiet version of `LDSLICEX`.	`26`
`D71Ccc`	`[cc+1] LDSLICE_l`	`s - s'' s'`	A longer encoding for `LDSLICE`.	`34`
`D759`	`LDULE4Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian unsigned 32-bit integer.	`26`
`D753`	`LDULE8`	`s - x s'`	Loads a little-endian unsigned 64-bit integer.	`26`
`D75B`	`LDULE8Q`	`s - x s' -1 or s 0`	Quietly loads a little-endian unsigned 64-bit integer.	`26`
`D70Dcc`	`[cc+1] LDUQ`	`s - x s' -1 or s 0`	A quiet version of `LDU`.	`34`
`D709cc`	`[cc+1] LDU_l`	`s - x s'`	A longer encoding for `LDU`.	`34`
`D760`	`LDZEROES`	`s - n s'`	Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.	`26`
`D754`	`PLDILE4`	`s - x`	Preloads a little-endian signed 32-bit integer.	`26`
`D75C`	`PLDILE4Q`	`s - x -1 or 0`	Quietly preloads a little-endian signed 32-bit integer.	`26`
`D756`	`PLDILE8`	`s - x`	Preloads a little-endian signed 64-bit integer.	`26`
`D75E`	`PLDILE8Q`	`s - x -1 or 0`	Quietly preloads a little-endian signed 64-bit integer.	`26`
`D70Ecc`	`[cc+1] PLDIQ`	`s - x -1 or 0`	A quiet version of `PLDI`.	`34`
`D702`	`PLDIX`	`s l - x`	Preloads a signed `l`-bit integer from Slice `s`, for `0 <= l <= 257`.	`26`
`D706`	`PLDIXQ`	`s l - x -1 or 0`	Quiet version of `PLDIX`.	`26`
`D748`	`PLDREFVAR`	`s n - c`	Returns the `n`-th cell reference of Slice `s` for `0 <= n <= 3`.	`26`
`D71Fcc`	`[cc+1] PLDSLICEQ`	`s - s'' -1 or 0`	A quiet version of `PLDSLICE`.	`34`
`D71B`	`PLDSLICEXQ`	`s l - s' -1 or 0`	A quiet version of `LDSLICEXQ`.	`26`
`D755`	`PLDULE4`	`s - x`	Preloads a little-endian unsigned 32-bit integer.	`26`
`D75D`	`PLDULE4Q`	`s - x -1 or 0`	Quietly preloads a little-endian unsigned 32-bit integer.	`26`
`D757`	`PLDULE8`	`s - x`	Preloads a little-endian unsigned 64-bit integer.	`26`
`D75F`	`PLDULE8Q`	`s - x -1 or 0`	Quietly preloads a little-endian unsigned 64-bit integer.	`26`
`D70Fcc`	`[cc+1] PLDUQ`	`s - x -1 or 0`	A quiet version of `PLDU`.	`34`
`D707`	`PLDUXQ`	`s l - x -1 or 0`	Quiet version of `PLDUX`.	`26`
`D743`	`SCHKBITREFS`	`s l r -`	Checks whether there are at least `l` data bits and `r` references in Slice `s`.	`26/76`
`D747`	`SCHKBITREFSQ`	`s l r - ?`	Checks whether there are at least `l` data bits and `r` references in Slice `s`.	`26`
`D741`	`SCHKBITS`	`s l -`	Checks whether there are at least `l` data bits in Slice `s`. If this is not the case, throws a cell deserialisation (i.e., cell underflow) exception.	`26/76`
`D745`	`SCHKBITSQ`	`s l - ?`	Checks whether there are at least `l` data bits in Slice `s`.	`26`
`D742`	`SCHKREFS`	`s r -`	Checks whether there are at least `r` references in Slice `s`.	`26/76`
`D746`	`SCHKREFSQ`	`s r - ?`	Checks whether there are at least `r` references in Slice `s`.	`26`
`D730`	`SCUTFIRST`	`s l r - s'`	Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.	`26`
`D726`	`SDBEGINSX`	`s s' - s''`	Checks whether `s` begins with (the data bits of) `s'`, and removes `s'` from `s` on success. On failure throws a cell deserialization exception. Primitive `SDPFXREV` can be considered a quiet version of `SDBEGINSX`.	`26`
`D727`	`SDBEGINSXQ`	`s s' - s'' -1 or s 0`	A quiet version of `SDBEGINSX`.	`26`
`D737`	`SPLITQ`	`s l r - s' s'' -1 or s 0`	A quiet version of `SPLIT`.	`26`
`D731`	`SSKIPFIRST`	`s l r - s'`	Returns all but the first `l` bits of `s` and `r` references of `s`.	`26`
`D733`	`SSKIPLAST`	`s l r - s'`	Returns all but the last `l` bits of `s` and `r` references of `s`.	`26`
`CF1B`	`STBQ`	`b' b - b' b -1 or b'' 0`	Quiet version of `STB`.	`26`
`CF19`	`STBREFQ`	`b' b - b' b -1 or b'' 0`	Quiet version of `STBREF`.	`526`
`CD`	`STBREFR ENDCST`	`b b'' - b`	Equivalent to `ENDC` `SWAP` `STREF`.	`518`
`CF1D`	`STBREFRQ`	`b b' - b b' -1 or b'' 0`	Quiet version of `STBREFR`.	`526`
`CF15`	`STBREFR_l`	`b b' - b''`	A longer encoding of `STBREFR`.	`526`
`CF1F`	`STBRQ BCONCATQ`	`b b' - b b' -1 or b'' 0`	Quiet version of `STBR`.	`26`
`CF28`	`STILE4`	`x b - b'`	Stores a little-endian signed 32-bit integer.	`26`
`CF2A`	`STILE8`	`x b - b'`	Stores a little-endian signed 64-bit integer.	`26`
`CF0Ccc`	`[cc+1] STIQ`	`x b - x b f or b' 0`	A quiet version of `STI`.	`34`
`CF0Ecc`	`[cc+1] STIRQ`	`b x - b x f or b' 0`	A quiet version of `STIR`.	`34`
`CF04`	`STIXQ`	`x b l - x b f or b' 0`	A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`. If `x` does not fit into `l` bits, sets `b'=b` and `f=1`. If the operation succeeds, `b'` is the new Builder and `f=0`. However, `0 <= l <= 257`, with a range check exception if this is not so.	`26`
`CF02`	`STIXR`	`b x l - b'`	Similar to `STIX`, but with arguments in a different order.	`26`
`CF06`	`STIXRQ`	`b x l - b x f or b' 0`	A quiet version of `STIXR`.	`26`
`CF08cc`	`[cc+1] STI_l`	`x b - b'`	A longer version of `[cc+1] STI`.	`34`
`CF21`	`[ref] [ref] STREF2CONST`	`b - b'`	Equivalent to `STREFCONST` `STREFCONST`.	`26`
`CF20`	`[ref] STREFCONST`	`b - b'`	Equivalent to `PUSHREF` `STREFR`.	`26`
`CF18`	`STREFQ`	`c b - c b -1 or b' 0`	Quiet version of `STREF`.	`26`
`CF1C`	`STREFRQ`	`b c - b c -1 or b' 0`	Quiet version of `STREFR`.	`26`
`CF10`	`STREF_l`	`c b - b'`	A longer version of `STREF`.	`26`
`CF42`	`STSAME`	`b n x - b'`	Stores `n` binary `x`es (`0 <= x <= 1`) into Builder `b`.	`26`
`CF1A`	`STSLICEQ`	`s b - s b -1 or b' 0`	Quiet version of `STSLICE`.	`26`
`CF1E`	`STSLICERQ`	`b s - b s -1 or b'' 0`	Quiet version of `STSLICER`.	`26`
`CF12`	`STSLICE_l`	`s b - b'`	A longer version of `STSLICE`.	`26`
`CF2B`	`STULE8`	`x b - b'`	Stores a little-endian unsigned 64-bit integer.	`26`
`CF0Dcc`	`[cc+1] STUQ`	`x b - x b f or b' 0`	A quiet version of `STU`.	`34`
`CF0Fcc`	`[cc+1] STURQ`	`b x - b x f or b' 0`	A quiet version of `STUR`.	`34`
`CF05`	`STUXQ`	`x b l - x b f or b' 0`	A quiet version of `STUX`.	`26`
`CF03`	`STUXR`	`b x l - b'`	Similar to `STUX`, but with arguments in a different order.	`26`
`CF07`	`STUXRQ`	`b x l - b x f or b' 0`	A quiet version of `STUXR`.	`26`
`CF09cc`	`[cc+1] STU_l`	`x b - b'`	A longer version of `[cc+1] STU`.	`34`
`D734`	`SUBSLICE`	`s l r l' r' - s'`	Returns `0 <= l' <= 1023` bits and `0 <= r' <= 4` references from Slice `s`, after skipping the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references.	`26`
`D73B`	`XLOADQ`	`c - c' -1 or c 0`	Loads an exotic cell `c` and returns an ordinary cell `c'`. If `c` is already ordinary, does nothing. If `c` cannot be loaded, returns 0.

Opcode	Fift syntax	Stack	Description	Gas
`E0`	`IFJMP`	`f c -`	Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.	`18`
`DB3C`	`[ref] CALLREF`		Equivalent to `PUSHREFCONT` `CALLX`.	`126/51`
`ED5i`	`c[i] POPCTR c[i] POP`	`x -`	Pops a value `x` from the stack and stores it into control register `c(i)`, if supported in the current codepage. Notice that if a control register accepts only values of a specific type, a type-checking exception may occur.	`26`
`DD`	`IFNOTRET IF:`	`f -`	Performs a `RET`, but only if integer `f` is zero.	`18`
`ED4i`	`c[i] PUSHCTR c[i] PUSH`	`- x`	Pushes the current value of control register `c(i)`. If the control register is not supported in the current codepage, or if it does not have a value, an exception is triggered.	`26`
`F0nn`	`[nn] CALL [nn] CALLDICT`	`- nn`	Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument. Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.
`E2`	`IFELSE`	`f c c' -`	If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.	`18`
`E302`	`[ref] IFJMPREF`	`f -`	Equivalent to `PUSHREFCONT` `IFJMP`.	`26/126/51`
`DE`	`IF`	`f c -`	Performs `EXECUTE` for `c` (i.e., executes `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.	`18`
`E30D`	`[ref] IFREFELSE`	`f c -`	Equivalent to `PUSHREFCONT` `SWAP` `IFELSE`, with the optimization that the cell reference is not actually loaded into a Slice and then converted into an ordinary Continuation if `f=0`. Similar remarks apply to the next two primitives: cells are converted into continuations only when necessary.	`26/126/51`
`E6`	`UNTIL`	`c -`	Executes continuation `c`, then pops an integer `x` from the resulting stack. If `x` is zero, performs another iteration of this loop. The actual implementation of this primitive involves an extraordinary continuation `ec_until` with its arguments set to the body of the loop (continuation `c`) and the original current continuation `cc`. This extraordinary continuation is then saved into the savelist of `c` as `c.c0` and the modified `c` is then executed. The other loop primitives are implemented similarly with the aid of suitable extraordinary continuations.	`18`
`EDFB`	`SAMEALTSAVE`	`-`	Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`. Equivalent to `c1 SAVE` `SAMEALT`.	`26`
`E8`	`WHILE`	`c' c -`	Executes `c'` and pops an integer `x` from the resulting stack. If `x` is zero, exists the loop and transfers control to the original `cc`. If `x` is non-zero, executes `c`, and then begins a new iteration.	`18`
`EDAi`	`c[i] SAVE c[i] SAVECTR`		Saves the current value of `c(i)` into the savelist of continuation `c0`. If an entry for `c[i]` is already present in the savelist of `c0`, nothing is done. Equivalent to `c[i] PUSHCTR` `c[i] SETRETCTR`.	`26`
`D8`	`EXECUTE CALLX`	`c -`	Calls, or executes, continuation `c`.	`18`
`E300`	`[ref] IFREF`	`f -`	Equivalent to `PUSHREFCONT` `IF`, with the optimization that the cell reference is not actually loaded into a Slice and then converted into an ordinary Continuation if `f=0`. Gas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before. Similar remarks apply other primitives that accept a continuation as a reference.	`26/126/51`
`E1`	`IFNOTJMP`	`f c -`	Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.	`18`
`E30F`	`[ref] [ref] IFREFELSEREF`	`f -`	Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.	`126/51`
`E30E`	`[ref] IFELSEREF`	`f c -`	Equivalent to `PUSHREFCONT` `IFELSE`.	`26/126/51`
`DC`	`IFRET IFNOT:`	`f -`	Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.	`18`
`DF`	`IFNOT`	`f c -`	Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.	`18`
`E4`	`REPEAT`	`n c -`	Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception. Notice that a `RET` inside the code of `c` works as a `continue`, not as a `break`. One should use either alternative (experimental) loops or alternative `RETALT` (along with a `SETEXITALT` before the loop) to `break` out of a loop.	`18`
`ED6i`	`c[i] SETCONT c[i] SETCONTCTR`	`x c - c'`	Stores `x` into the savelist of continuation `c` as `c(i)`, and returns the resulting continuation `c'`. Almost all operations with continuations may be expressed in terms of `SETCONTCTR`, `POPCTR`, and `PUSHCTR`.	`26`
`EDF1`	`COMPOSALT BOOLOR`	`c c' - c''`	Computes the alternative composition `compose1(c, c')`, which has the meaning of ''perform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.	`26`
`ED11`	`SETCONTVARARGS`	`x_1 x_2...x_r c r n - c'`	Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.	`26+s''`
`DB0p`	`[p] -1 CALLXARGS`	`c -`	Calls continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.	`26`
`E303`	`[ref] IFNOTJMPREF`	`f -`	Equivalent to `PUSHREFCONT` `IFNOTJMP`.	`26/126/51`
`F12_n`	`[n] CALL [n] CALLDICT`	`- n`	For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.
`ED1E`	`BLESS`	`s - c`	Transforms a Slice `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.	`26`
`DApr`	`[p] [r] CALLXARGS`	`c -`	Calls continuation `c` with `p` parameters and expecting `r` return values `0 <= p <= 15`, `0 <= r <= 15`	`26`
`E301`	`[ref] IFNOTREF`	`f -`	Equivalent to `PUSHREFCONT` `IFNOT`.	`26/126/51`
`D9`	`JMPX`	`c -`	Jumps, or transfers control, to continuation `c`. The remainder of the previous current continuation `cc` is discarded.	`18`
`F1A_n`	`[n] PREPARE [n] PREPAREDICT`	`- n c`	Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`. In this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`. One might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.
`E308`	`IFRETALT`	`f -`	Performs `RETALT` if integer `f!=0`.	`26`
`DB35`	`JMPXDATA`	`c -`	Similar to `CALLCC`, but the remainder of the current continuation (the old value of `cc`) is converted into a Slice before pushing it into the stack of `c`.	`26`
`DB4fff`	`flags RUNVM`	`x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]`	Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
`E309`	`IFNOTRETALT`	`f -`	Performs `RETALT` if integer `f=0`.	`26`
`EB`	`AGAINEND AGAIN:`	`-`	Similar to `AGAIN`, but performed with respect to the current continuation `cc`.	`18`
`ECrn`	`[r] [n] SETCONTARGS`	`x_1 x_2...x_r c - c'`	Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. When `n` is 15 (-1 in Fift notation), does nothing with `c.nargs`. For `0 <= n <= 14`, sets `c.nargs` to the final size of the stack of `c'` plus `n`. In other words, transforms `c` into a closure or a partially applied function, with `0 <= n <= 14` arguments missing.	`26+s''`
`EA`	`AGAIN`	`c -`	Similar to `REPEAT`, but executes `c` infinitely many times. A `RET` only begins a new iteration of the infinite loop, which can be exited only by an exception, or a `RETALT` (or an explicit `JMPX`).	`18`
`E31A`	`AGAINBRK`	`c -`	Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E31B`	`AGAINENDBRK AGAINBRK:`	`-`	Equivalent to `SAMEALTSAVE` `AGAINEND`.	`26`
`EDF3`	`ATEXIT`	`c -`	Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.	`26`
`EDF4`	`ATEXITALT`	`c -`	Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.	`26`
`EErn`	`[r] [n] BLESSARGS`	`x_1...x_r s - c`	`0 <= r <= 15`, `-1 <= n <= 14` Equivalent to `BLESS` `[r] [n] SETCONTARGS`. The value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.	`26`
`ED1F`	`BLESSVARARGS`	`x_1...x_r s r n - c`	Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.	`26+s''`
`EDF9`	`BOOLEVAL`	`c - ?`	Performs `cc:=compose1(compose0(c, compose0(-1 PUSHINT, cc)), compose0(0 PUSHINT, cc))`. If `c` represents a boolean circuit, the net effect is to evaluate it and push either `-1` or `0` into the stack before continuing.	`26`
`DB32`	`BRANCH RETBOOL`	`f -`	Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.	`26`
`DB34`	`CALLCC`	`c -`	Call with current continuation, transfers control to `c`, pushing the old value of `cc` into `c`'s stack (instead of discarding it or writing it into new `c0`).	`26`
`DB36pr`	`[p] [r] CALLCCARGS`	`c -`	Similar to `CALLXARGS`, but pushes the old value of `cc` (along with the top `0 <= p <= 15` values from the original stack) into the stack of newly-invoked continuation `c`, setting `cc.nargs` to `-1 <= r <= 14`.	`34`
`DB3B`	`CALLCCVARARGS`	`c p r -`	Similar to `CALLCCARGS`.	`26`
`DB38`	`CALLXVARARGS`	`c p r -`	Similar to `CALLXARGS`, but takes `-1 <= p,r <= 254` from the stack. The next three operations also take `p` and `r` from the stack, both in the range `-1...254`.	`26`
`EDF0`	`COMPOS BOOLAND`	`c c' - c''`	Computes the composition `compose0(c, c')`, which has the meaning of ''perform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply ''perform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.	`26`
`EDF2`	`COMPOSBOTH`	`c c' - c''`	Computes composition `compose1(compose0(c, c'), c')`, which has the meaning of ''compute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.	`26`
`E304`	`CONDSEL`	`f x y - x or y`	If integer `f` is non-zero, returns `x`, otherwise returns `y`. Notice that no type checks are performed on `x` and `y`; as such, it is more like a conditional stack operation. Roughly equivalent to `ROT` `ISZERO` `INC` `ROLLX` `NIP`.	`26`
`E305`	`CONDSELCHK`	`f x y - x or y`	Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.	`26`
`E39_n`	`[n] IFBITJMP`	`x c - x`	Checks whether bit `0 <= n <= 31` is set in integer `x`, and if so, performs `JMPX` to continuation `c`. Value `x` is left in the stack.	`26`
`E3D_n`	`[ref] [n] IFBITJMPREF`	`x - x`	Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.	`126/51`
`E3B_n`	`[n] IFNBITJMP`	`x c - x`	Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.	`26`
`E3F_n`	`[ref] [n] IFNBITJMPREF`	`x - x`	Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.	`126/51`
`EDF8`	`INVERT`	`-`	Interchanges `c0` and `c1`.	`26`
`F16_n`	`[n] JMP`	`- n`	Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument. Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.
`DB3D`	`[ref] JMPREF`		Equivalent to `PUSHREFCONT` `JMPX`.	`126/51`
`DB3E`	`[ref] JMPREFDATA`		Equivalent to `PUSHREFCONT` `JMPXDATA`.	`126/51`
`DB1p`	`[p] JMPXARGS`	`c -`	Jumps to continuation `c`, passing only the top `0 <= p <= 15` values from the current stack to it (the remainder of the current stack is discarded).	`26`
`DB3A`	`JMPXVARARGS`	`c p r -`	Similar to `JMPXARGS`.	`26`
`EDE1`	`POPCTRX`	`x i -`	Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.	`26`
`ED9i`	`c[i] POPSAVE c[i] POPCTRSAVE`	`x -`	Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`. Equivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.	`26`
`EDE0`	`PUSHCTRX`	`i - x`	Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack. Notice that this primitive is one of the few ''exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of `x` depends on `i`.	`26`
`E314`	`REPEATBRK`	`n c -`	Similar to `REPEAT`, but also sets `c1` to the original `cc` after saving the old value of `c1` into the savelist of the original `cc`. In this way `RETALT` could be used to break out of the loop body.	`26`
`E5`	`REPEATEND REPEAT:`	`n -`	Similar to `REPEAT`, but it is applied to the current continuation `cc`.	`18`
`E315`	`REPEATENDBRK`	`n -`	Similar to `REPEATEND`, but also sets `c1` to the original `c0` after saving the old value of `c1` into the savelist of the original `c0`. Equivalent to `SAMEALTSAVE` `REPEATEND`.	`26`
`DB30`	`RET RETTRUE`		Returns to the continuation at `c0`. The remainder of the current continuation `cc` is discarded. Approximately equivalent to `c0 PUSHCTR` `JMPX`.	`26`
`DB31`	`RETALT RETFALSE`		Returns to the continuation at `c1`. Approximately equivalent to `c1 PUSHCTR` `JMPX`.	`26`
`DB2r`	`[r] RETARGS`		Returns to `c0`, with `0 <= r <= 15` return values taken from the current stack.	`26`
`DB3F`	`RETDATA`		Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a Slice and returned to the caller.	`26`
`ED0p`	`[p] RETURNARGS`	`-`	Leaves only the top `0 <= p <= 15` values in the current stack (somewhat similarly to `ONLYTOPX`), with all the unused bottom values not discarded, but saved into continuation `c0` in the same way as `SETCONTARGS` does.	`26+s''`
`ED10`	`RETURNVARARGS`	`p -`	Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.	`26+s''`
`DB39`	`RETVARARGS`	`p r -`	Similar to `RETARGS`.	`26`
`DB50`	`RUNVMX`	`x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] flags - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]`	Runs child VM with code `code` and stack `x_1...x_n`. Returns the resulting stack `x'_1...x'_m` and exitcode. Other arguments and return values are enabled by flags.
`EDFA`	`SAMEALT`	`-`	Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.	`26`
`EDBi`	`c[i] SAVEALT c[i] SAVEALTCTR`		Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.	`26`
`EDCi`	`c[i] SAVEBOTH c[i] SAVEBOTHCTR`		Equivalent to `c[i] SAVE` `c[i] SAVEALT`.	`26`
`ED8i`	`c[i] SETALTCTR`	`x -`	Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.	`26`
`EDE2`	`SETCONTCTRX`	`x c i - c'`	Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.	`26`
`EDF5`	`SETEXITALT`	`c -`	Sets `c1` to `compose1(compose0(c, c0), c1)`, In this way, a subsequent `RETALT` will first execute `c`, then transfer control to the original `c0`. This can be used, for instance, to exit from nested loops.	`26`
`ED12`	`SETNUMVARARGS`	`c n - c'`	`-1 <= n <= 255` If `n=-1`, this operation does nothing (`c'=c`). Otherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.	`26`
`ED7i`	`c[i] SETRETCTR`	`x -`	Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.	`26`
`EDF6`	`THENRET`	`c - c'`	Computes `compose0(c, c0)`.	`26`
`EDF7`	`THENRETALT`	`c - c'`	Computes `compose0(c, c1)`	`26`
`E316`	`UNTILBRK`	`c -`	Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E7`	`UNTILEND UNTIL:`	`-`	Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.	`18`
`E317`	`UNTILENDBRK UNTILBRK:`	`-`	Equivalent to `SAMEALTSAVE` `UNTILEND`.	`26`
`E318`	`WHILEBRK`	`c' c -`	Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.	`26`
`E9`	`WHILEEND`	`c' -`	Similar to `WHILE`, but uses the current continuation `cc` as the loop body.	`18`
`E319`	`WHILEENDBRK`	`c -`	Equivalent to `SAMEALTSAVE` `WHILEEND`.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`F2E4_n`	`[n] THROWIFNOT`	`f -`	For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.	`34/84`
`F2A_n`	`[n] THROWIFNOT`	`f -`	Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.	`26/76`
`F26_n`	`[n] THROWIF`	`f -`	Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.	`26/76`
`F2D4_n`	`[n] THROWIF`	`f -`	For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.	`34/84`
`F2F0`	`THROWANY`	`n - 0 n`	Throws exception `0 <= n < 2^16` with parameter zero. Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.	`76`
`F2F4`	`THROWANYIFNOT`	`n f -`	Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.	`26/76`
`F2F2`	`THROWANYIF`	`n f -`	Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.	`26/76`
`F2C4_n`	`[n] THROW`	`- 0 nn`	For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.	`84`
`F2FF`	`TRY`	`c c' -`	Sets `c2` to `c'`, first saving the old value of `c2` both into the savelist of `c'` and into the savelist of the current continuation, which is stored into `c.c0` and `c'.c0`. Then runs `c` similarly to `EXECUTE`. If `c` does not throw any exceptions, the original value of `c2` is automatically restored on return from `c`. If an exception occurs, the execution is transferred to `c'`, but the original value of `c2` is restored in the process, so that `c'` can re-throw the exception by `THROWANY` if it cannot handle it by itself.	`26`
`F22_n`	`[n] THROW`	`- 0 n`	Throws exception `0 <= n <= 63` with parameter zero. In other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.	`76`
`F2CC_n`	`[n] THROWARG`	`x - x nn`	Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.	`84`
`F2F1`	`THROWARGANY`	`x n - x n`	Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`. Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.	`76`
`F2F3`	`THROWARGANYIF`	`x n f -`	Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.	`26/76`
`F2F5`	`THROWARGANYIFNOT`	`x n f -`	Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.	`26/76`
`F2DC_n`	`[n] THROWARGIF`	`x f -`	Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.	`34/84`
`F2EC_n`	`[n] THROWARGIFNOT`	`x f -`	Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.	`34/84`
`F3pr`	`[p] [r] TRYARGS`	`c c' -`	Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`. In this way, all but the top `0 <= p <= 15` stack elements will be saved into current continuation's stack, and then restored upon return from either `c` or `c'`, with the top `0 <= r <= 15` values of the resulting stack of `c` or `c'` copied as return values.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`F400`	`STDICT STOPTREF`	`D b - b'`	Stores dictionary `D` into Builder `b`, returning the resulting Builder `b'`. In other words, if `D` is a cell, performs `STONE` and `STREF`; if `D` is Null, performs `NIP` and `STZERO`; otherwise throws a type checking exception.	`26`
`F404`	`LDDICT LDOPTREF`	`s - D s'`	Loads (parses) a dictionary `D` from Slice `s`, and returns the remainder of `s` as `s'`. May be applied to dictionaries or to values of arbitrary `(^Y)?` types.	`26`
`F40E`	`DICTUGET`	`i D n - x -1 or 0`	Similar to `DICTIGET`, but with unsigned (big-endian) `n`-bit Integer `i` used as a key.
`F417`	`DICTUSETREF`	`c i D n - D'`	Similar to `DICTISETREF`, but with `i` unsigned.
`F443`	`DICTUSETB`	`b i D n - D'`
`F40A`	`DICTGET`	`k D n - x -1 or 0`	Looks up key `k` (represented by a Slice, the first `0 <= n <= 1023` data bits of which are used as a key) in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the value found as a Slice `x`.
`F40F`	`DICTUGETREF`	`i D n - c -1 or 0`	Similar to `DICTIGETREF`, but with an unsigned `n`-bit Integer key `i`.
`F416`	`DICTUSET`	`x i D n - D'`	Similar to `DICTISET`, but with `i` an unsigned `n`-bit integer.
`F405`	`PLDDICT PLDOPTREF`	`s - D`	Preloads a dictionary `D` from Slice `s`. Approximately equivalent to `LDDICT` `DROP`.	`26`
`F486`	`DICTUMIN`	`D n - x i -1 or 0`	Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit Integer `i`.
`F46B`	`DICTUGETOPTREF`	`i D n - c^?`	`DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns Null.
`F45B`	`DICTUDEL`	`i D n - D' ?`	Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.
`F466`	`DICTUDELGET`	`i D n - D' x -1 or D 0`	`DICTDELGET`, but with `i` an unsigned `n`-bit integer.
`F401`	`SKIPDICT SKIPOPTREF`	`s - s'`	Equivalent to `LDDICT` `NIP`.	`26`
`F441`	`DICTSETB`	`b k D n - D'`
`F47C`	`DICTUGETNEXT`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian unsigned `n`-bit integers, and computes the minimal key `i'` that is larger than Integer `i` (which does not necessarily fit into `n` bits, and is not necessarily non-negative).
`F48E`	`DICTUMAX`	`D n - x i -1 or 0`	Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit Integer `i`.
`F48F`	`DICTUMAXREF`	`D n - c i -1 or 0`	Similar to `DICTUMAX`, but returns the only reference in the value.
`F453`	`DICTUADDB`	`b i D n - D' -1 or D 0`
`F4A6_n`	`[ref] [n] DICTPUSHCONST`	`- D n`	Pushes a non-empty constant dictionary `D` (as a `Cell^?`) along with its key length `0 <= n <= 1023`, stored as a part of the instruction. The dictionary itself is created from the first of remaining references of the current continuation. In this way, the complete `DICTPUSHCONST` instruction can be obtained by first serializing `xF4A4_`, then the non-empty dictionary itself (one `1` bit and a cell reference), and then the unsigned 10-bit integer `n` (as if by a `STU 10` instruction). An empty dictionary can be pushed by a `NEWDICT` primitive instead.	`34`
`F487`	`DICTUMINREF`	`D n - c i -1 or 0`	Similar to `DICTUMIN`, but returns the only reference in the value.
`F4A1`	`DICTUGETJMP`	`i D n -`	Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.
`F40D`	`DICTIGETREF`	`i D n - c -1 or 0`	Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit Integer `i` as a key and returns a Cell instead of a Slice on success.
`F40C`	`DICTIGET`	`i D n - x -1 or 0`	Similar to `DICTGET`, but with a signed (big-endian) `n`-bit Integer `i` as a key. If `i` does not fit into `n` bits, returns `0`. If `i` is a `NaN`, throws an integer overflow exception.
`F4A8`	`PFXDICTGETQ`	`s D n - s' x s'' -1 or s 0`	Looks up the unique prefix of Slice `s` present in the prefix code dictionary represented by `Cell^?` `D` and `0 <= n <= 1023`. If found, the prefix of `s` is returned as `s'`, and the corresponding value (also a Slice) as `x`. The remainder of `s` is returned as a Slice `s''`. If no prefix of `s` is a key in prefix code dictionary `D`, returns the unchanged `s` and a zero flag to indicate failure.
`F47F`	`DICTUGETPREVEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.
`F46A`	`DICTIGETOPTREF`	`i D n - c^?`	`DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns Null.
`F482`	`DICTMIN`	`D n - x k -1 or 0`	Computes the minimal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
`F40B`	`DICTGETREF`	`k D n - c -1 or 0`	Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success. This operation is useful for dictionaries of type `HashmapE(n,^Y)`.
`F470`	`PFXDICTSET`	`x k D n - D' -1 or D 0`
`F4A0`	`DICTIGETJMP`	`i D n -`	Similar to `DICTIGET`, but with `x` `BLESS`ed into a continuation with a subsequent `JMPX` to it on success. On failure, does nothing. This is useful for implementing `switch`/`case` constructions.
`F44B`	`DICTUREPLACEB`	`b i D n - D' -1 or D 0`
`F415`	`DICTISETREF`	`c i D n - D'`	Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.
`F496`	`DICTUREMMIN`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit Integer `i`.
`F41E`	`DICTUSETGET`	`x i D n - D' y -1 or D' 0`	`DICTISETGET`, but with `i` an unsigned `n`-bit integer.
`F497`	`DICTUREMMINREF`	`D n - D' c i -1 or D 0`	Similar to `DICTUREMMIN`, but returns the only reference in the value.
`F47E`	`DICTUGETPREV`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.
`F484`	`DICTIMIN`	`D n - x i -1 or 0`	Similar to `DICTMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMIN` and `DICTUMIN`.
`F436`	`DICTUADD`	`x i D n - D' -1 or D 0`	`DICTADD`, but with `i` an unsigned `n`-bit integer.
`F414`	`DICTISET`	`x i D n - D'`	Similar to `DICTSET`, but with the key represented by a (big-endian) signed `n`-bit integer `i`. If `i` does not fit into `n` bits, a range check exception is generated.
`F469`	`DICTGETOPTREF`	`k D n - c^?`	A variant of `DICTGETREF` that returns Null instead of the value `c^?` if the key `k` is absent from dictionary `D`.
`F45A`	`DICTIDEL`	`i D n - D' ?`	A version of `DICTDEL` with the key represented by a signed `n`-bit Integer `i`. If `i` does not fit into `n` bits, simply returns `D` `0` (''key not found, dictionary unmodified'').
`F467`	`DICTUDELGETREF`	`i D n - D' c -1 or D 0`	`DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.
`F407`	`PLDDICTQ`	`s - D -1 or 0`	A quiet version of `PLDDICT`.	`26`
`F462`	`DICTDELGET`	`k D n - D' x -1 or D 0`	Deletes `n`-bit key, represented by a Slice `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'`, the original value `x` associated with the key `k` (represented by a Slice), and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
`F478`	`DICTIGETNEXT`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXT`, but interprets all keys in dictionary `D` as big-endian signed `n`-bit integers, and computes the minimal key `i'` that is larger than Integer `i` (which does not necessarily fit into `n` bits).
`F412`	`DICTSET`	`x k D n - D'`	Sets the value associated with `n`-bit key `k` (represented by a Slice as in `DICTGET`) in dictionary `D` (also represented by a Slice) to value `x` (again a Slice), and returns the resulting dictionary as `D'`.
`F413`	`DICTSETREF`	`c k D n - D'`	Similar to `DICTSET`, but with the value set to a reference to Cell `c`.
`F437`	`DICTUADDREF`	`c i D n - D' -1 or D 0`	`DICTADDREF`, but with `i` an unsigned `n`-bit integer.
`F485`	`DICTIMINREF`	`D n - c i -1 or 0`	Similar to `DICTIMIN`, but returns the only reference in the value.
`F4BC`	`DICTIGETJMPZ`	`i D n - i or nothing`	A variant of `DICTIGETJMP` that returns index `i` on failure.
`F435`	`DICTIADDREF`	`c i D n - D' -1 or D 0`	`DICTADDREF`, but with `i` a signed `n`-bit integer.
`F47B`	`DICTIGETPREVEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.
`F451`	`DICTADDB`	`b k D n - D' -1 or D 0`
`F475`	`DICTGETNEXTEQ`	`k D n - x' k' -1 or 0`	Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.
`F459`	`DICTDEL`	`k D n - D' -1 or D 0`	Deletes `n`-bit key, represented by a Slice `k`, from dictionary `D`. If the key is present, returns the modified dictionary `D'` and the success flag `-1`. Otherwise, returns the original dictionary `D` and `0`.
`F47D`	`DICTUGETNEXTEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.
`F48A`	`DICTMAX`	`D n - x k -1 or 0`	Computes the maximal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, and returns `k` along with the associated value `x`.
`F442`	`DICTISETB`	`b i D n - D'`
`F424`	`DICTIREPLACE`	`x i D n - D' -1 or D 0`	`DICTREPLACE`, but with `i` a signed `n`-bit integer.
`F432`	`DICTADD`	`x k D n - D' -1 or D 0`	An Add counterpart of `DICTSET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if it is not already present in `D`.
`F43A`	`DICTADDGET`	`x k D n - D' -1 or D y 0`	An Add counterpart of `DICTSETGET`: sets the value associated with key `k` in dictionary `D` to `x`, but only if key `k` is not already present in `D`. Otherwise, just returns the old value `y` without changing the dictionary.
`F455`	`DICTADDGETB`	`b k D n - D' -1 or D y 0`
`F43B`	`DICTADDGETREF`	`c k D n - D' -1 or D c' 0`	An Add counterpart of `DICTSETGETREF`.
`F433`	`DICTADDREF`	`c k D n - D' -1 or D 0`	An Add counterpart of `DICTSETREF`.
`F463`	`DICTDELGETREF`	`k D n - D' c -1 or D 0`	Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a Cell.
`F474`	`DICTGETNEXT`	`k D n - x' k' -1 or 0`	Computes the minimal key `k'` in dictionary `D` that is lexicographically greater than `k`, and returns `k'` (represented by a Slice) along with associated value `x'` (also represented by a Slice).
`F476`	`DICTGETPREV`	`k D n - x' k' -1 or 0`	Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.
`F477`	`DICTGETPREVEQ`	`k D n - x' k' -1 or 0`	Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.
`F434`	`DICTIADD`	`x i D n - D' -1 or D 0`	`DICTADD`, but with `i` a signed `n`-bit integer.
`F452`	`DICTIADDB`	`b i D n - D' -1 or D 0`
`F43C`	`DICTIADDGET`	`x i D n - D' -1 or D y 0`	`DICTADDGET`, but with `i` a signed `n`-bit integer.
`F456`	`DICTIADDGETB`	`b i D n - D' -1 or D y 0`
`F43D`	`DICTIADDGETREF`	`c i D n - D' -1 or D c' 0`	`DICTADDGETREF`, but with `i` a signed `n`-bit integer.
`F464`	`DICTIDELGET`	`i D n - D' x -1 or D 0`	`DICTDELGET`, but with `i` a signed `n`-bit integer.
`F465`	`DICTIDELGETREF`	`i D n - D' c -1 or D 0`	`DICTDELGETREF`, but with `i` a signed `n`-bit integer.
`F4A2`	`DICTIGETEXEC`	`i D n -`	Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.
`F4BE`	`DICTIGETEXECZ`	`i D n - i or nothing`	A variant of `DICTIGETEXEC` that returns index `i` on failure.
`F479`	`DICTIGETNEXTEQ`	`i D n - x' i' -1 or 0`	Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.
`F48C`	`DICTIMAX`	`D n - x i -1 or 0`	Similar to `DICTMAX`, but computes the maximal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTMAX` and `DICTUMAX`.
`F48D`	`DICTIMAXREF`	`D n - c i -1 or 0`	Similar to `DICTIMAX`, but returns the only reference in the value.
`F49C`	`DICTIREMMAX`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMAX`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMAX` and `DICTUREMMAX`.
`F49D`	`DICTIREMMAXREF`	`D n - D' c i -1 or D 0`	Similar to `DICTIREMMAX`, but returns the only reference in the value.
`F494`	`DICTIREMMIN`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMIN`, but computes the minimal key `i` under the assumption that all keys are big-endian signed `n`-bit integers. Notice that the key and value returned may differ from those computed by `DICTREMMIN` and `DICTUREMMIN`.
`F495`	`DICTIREMMINREF`	`D n - D' c i -1 or D 0`	Similar to `DICTIREMMIN`, but returns the only reference in the value.
`F44A`	`DICTIREPLACEB`	`b i D n - D' -1 or D 0`
`F42C`	`DICTIREPLACEGET`	`x i D n - D' y -1 or D 0`	`DICTREPLACEGET`, but with `i` a signed `n`-bit integer.
`F44E`	`DICTIREPLACEGETB`	`b i D n - D' y -1 or D 0`
`F42D`	`DICTIREPLACEGETREF`	`c i D n - D' c' -1 or D 0`	`DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.
`F425`	`DICTIREPLACEREF`	`c i D n - D' -1 or D 0`	`DICTREPLACEREF`, but with `i` a signed `n`-bit integer.
`F41C`	`DICTISETGET`	`x i D n - D' y -1 or D' 0`	`DICTISETGET`, but with `i` a signed `n`-bit integer.
`F446`	`DICTISETGETB`	`b i D n - D' y -1 or D' 0`
`F46E`	`DICTISETGETOPTREF`	`c^? i D n - D' ~c^?`	Similar to primitive `DICTSETGETOPTREF`, but using signed `n`-bit Integer `i` as a key. If `i` does not fit into `n` bits, throws a range checking exception.
`F41D`	`DICTISETGETREF`	`c i D n - D' c' -1 or D' 0`	`DICTISETGETREF`, but with `i` a signed `n`-bit integer.
`F48B`	`DICTMAXREF`	`D n - c k -1 or 0`	Similar to `DICTMAX`, but returns the only reference in the value.
`F483`	`DICTMINREF`	`D n - c k -1 or 0`	Similar to `DICTMIN`, but returns the only reference in the value as a Cell `c`.
`F49A`	`DICTREMMAX`	`D n - D' x k -1 or D 0`	Computes the maximal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
`F49B`	`DICTREMMAXREF`	`D n - D' c k -1 or D 0`	Similar to `DICTREMMAX`, but returns the only reference in the value as a Cell `c`.
`F492`	`DICTREMMIN`	`D n - D' x k -1 or D 0`	Computes the minimal key `k` (represented by a Slice with `n` data bits) in dictionary `D`, removes `k` from the dictionary, and returns `k` along with the associated value `x` and the modified dictionary `D'`.
`F493`	`DICTREMMINREF`	`D n - D' c k -1 or D 0`	Similar to `DICTREMMIN`, but returns the only reference in the value as a Cell `c`.
`F422`	`DICTREPLACE`	`x k D n - D' -1 or D 0`	A Replace operation, which is similar to `DICTSET`, but sets the value of key `k` in dictionary `D` to `x` only if the key `k` was already present in `D`.
`F449`	`DICTREPLACEB`	`b k D n - D' -1 or D 0`
`F42A`	`DICTREPLACEGET`	`x k D n - D' y -1 or D 0`	A Replace counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.
`F44D`	`DICTREPLACEGETB`	`b k D n - D' y -1 or D 0`
`F42B`	`DICTREPLACEGETREF`	`c k D n - D' c' -1 or D 0`	A Replace counterpart of `DICTSETGETREF`.
`F423`	`DICTREPLACEREF`	`c k D n - D' -1 or D 0`	A Replace counterpart of `DICTSETREF`.
`F41A`	`DICTSETGET`	`x k D n - D' y -1 or D' 0`	Combines `DICTSET` with `DICTGET`: it sets the value corresponding to key `k` to `x`, but also returns the old value `y` associated with the key in question, if present.
`F445`	`DICTSETGETB`	`b k D n - D' y -1 or D' 0`
`F46D`	`DICTSETGETOPTREF`	`c^? k D n - D' ~c^?`	A variant of both `DICTGETOPTREF` and `DICTSETGETREF` that sets the value corresponding to key `k` in dictionary `D` to `c^?` (if `c^?` is Null, then the key is deleted instead), and returns the old value `~c^?` (if the key `k` was absent before, returns Null instead).
`F41B`	`DICTSETGETREF`	`c k D n - D' c' -1 or D' 0`	Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.
`F43E`	`DICTUADDGET`	`x i D n - D' -1 or D y 0`	`DICTADDGET`, but with `i` an unsigned `n`-bit integer.
`F457`	`DICTUADDGETB`	`b i D n - D' -1 or D y 0`
`F43F`	`DICTUADDGETREF`	`c i D n - D' -1 or D c' 0`	`DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.
`F4A3`	`DICTUGETEXEC`	`i D n -`	Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.
`F4BF`	`DICTUGETEXECZ`	`i D n - i or nothing`	A variant of `DICTUGETEXEC` that returns index `i` on failure.
`F4BD`	`DICTUGETJMPZ`	`i D n - i or nothing`	A variant of `DICTUGETJMP` that returns index `i` on failure.
`F49E`	`DICTUREMMAX`	`D n - D' x i -1 or D 0`	Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit Integer `i`.
`F49F`	`DICTUREMMAXREF`	`D n - D' c i -1 or D 0`	Similar to `DICTUREMMAX`, but returns the only reference in the value.
`F426`	`DICTUREPLACE`	`x i D n - D' -1 or D 0`	`DICTREPLACE`, but with `i` an unsigned `n`-bit integer.
`F42E`	`DICTUREPLACEGET`	`x i D n - D' y -1 or D 0`	`DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.
`F44F`	`DICTUREPLACEGETB`	`b i D n - D' y -1 or D 0`
`F42F`	`DICTUREPLACEGETREF`	`c i D n - D' c' -1 or D 0`	`DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.
`F427`	`DICTUREPLACEREF`	`c i D n - D' -1 or D 0`	`DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.
`F447`	`DICTUSETGETB`	`b i D n - D' y -1 or D' 0`
`F46F`	`DICTUSETGETOPTREF`	`c^? i D n - D' ~c^?`	Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit Integer `i` as a key.
`F41F`	`DICTUSETGETREF`	`c i D n - D' c' -1 or D' 0`	`DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.
`F406`	`LDDICTQ`	`s - D s' -1 or s 0`	A quiet version of `LDDICT`.	`26`
`F402`	`LDDICTS`	`s - s' s''`	Loads (parses) a (Slice-represented) dictionary `s'` from Slice `s`, and returns the remainder of `s` as `s''`. This is a ''split function'' for all `HashmapE(n,X)` dictionary types.	`26`
`F472`	`PFXDICTADD`	`x k D n - D' -1 or D 0`
`F4AE_n`	`[ref] [n] PFXDICTCONSTGETJMP [ref] [n] PFXDICTSWITCH`	`s - s' s'' or s`	Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.
`F473`	`PFXDICTDEL`	`k D n - D' -1 or D 0`
`F4A9`	`PFXDICTGET`	`s D n - s' x s''`	Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.
`F4AB`	`PFXDICTGETEXEC`	`s D n - s' s''`	Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.
`F4AA`	`PFXDICTGETJMP`	`s D n - s' s'' or s`	Similar to `PFXDICTGETQ`, but on success `BLESS`es the value `x` into a Continuation and transfers control to it as if by a `JMPX`. On failure, returns `s` unchanged and continues execution.
`F471`	`PFXDICTREPLACE`	`x k D n - D' -1 or D 0`
`F403`	`PLDDICTS`	`s - s'`	Preloads a (Slice-represented) dictionary `s'` from Slice `s`. Approximately equivalent to `LDDICTS` `DROP`.	`26`
`F47A`	`DICTIGETPREV`	`i D n - x' i' -1 or 0`	Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.
`F4B1`	`SUBDICTGET`	`k l D n - D'`	Constructs a subdictionary consisting of all keys beginning with prefix `k` (represented by a Slice, the first `0 <= l <= n <= 1023` data bits of which are used as a key) of length `l` in dictionary `D` of type `HashmapE(n,X)` with `n`-bit keys. On success, returns the new subdictionary of the same type `HashmapE(n,X)` as a Slice `D'`.
`F4B2`	`SUBDICTIGET`	`x l D n - D'`	Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit Integer `x`, where necessarily `l <= 257`.
`F4B6`	`SUBDICTIRPGET`	`x l D n - D'`	Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit Integer `x`, where necessarily `l <= 257`.
`F4B5`	`SUBDICTRPGET`	`k l D n - D'`	Similar to `SUBDICTGET`, but removes the common prefix `k` from all keys of the new dictionary `D'`, which becomes of type `HashmapE(n-l,X)`.
`F4B3`	`SUBDICTUGET`	`x l D n - D'`	Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit Integer `x`, where necessarily `l <= 256`.
`F4B7`	`SUBDICTURPGET`	`x l D n - D'`	Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit Integer `x`, where necessarily `l <= 256`.

Opcode	Fift syntax	Stack	Description	Gas
`FA40`	`LDMSGADDR`	`s - s' s''`	Loads from Slice `s` the only prefix that is a valid `MsgAddress`, and returns both this prefix `s'` and the remainder `s''` of `s` as slices.	`26`
`F85_k`	`[k] GETGLOB`	`- x`	Returns the `k`-th global variable for `1 <= k <= 31`. Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.	`26`
`F82i`	`[i] GETPARAM`	`- x`	Returns the `i`-th parameter from the Tuple provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`. If one of these internal operations fails, throws an appropriate type checking or range checking exception.	`26`
`F87_k`	`[k] SETGLOB`	`x -`	Assigns `x` to the `k`-th global variable for `1 <= k <= 31`. Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.	`26+\|c7'\|`
`F901`	`HASHSU`	`s - x`	Computes the hash of a Slice `s` and returns it as a 256-bit unsigned integer `x`. The result is the same as if an ordinary cell containing only data and references from `s` had been created and its hash computed by `HASHCU`.	`526`
`F800`	`ACCEPT`	`-`	Sets current gas limit `g_l` to its maximal allowed value `g_m`, and resets the gas credit `g_c` to zero, decreasing the value of `g_r` by `g_c` in the process. In other words, the current smart contract agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves.	`26`
`F910`	`CHKSIGNU`	`h s k - ?`	Checks the Ed25519-signature `s` of a hash `h` (a 256-bit unsigned integer, usually computed as the hash of some data) using public key `k` (also represented by a 256-bit unsigned integer). The signature `s` must be a Slice containing at least 512 data bits; only the first 512 bits are used. The result is `-1` if the signature is valid, `0` otherwise. Notice that `CHKSIGNU` is equivalent to `ROT` `NEWC` `256 STU` `ENDC` `ROTREV` `CHKSIGNS`, i.e., to `CHKSIGNS` with the first argument `d` set to 256-bit Slice containing `h`. Therefore, if `h` is computed as the hash of some data, these data are hashed twice, the second hashing occurring inside `CHKSIGNS`.	`26`
`FA00`	`LDGRAMS LDVARUINT16`	`s - x s'`	Loads (deserializes) a `Gram` or `VarUInteger 16` amount from Slice `s`, and returns the amount as Integer `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`. The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.	`26`
`FA02`	`STGRAMS STVARUINT16`	`b x - b'`	Stores (serializes) an Integer `x` in the range `0...2^120-1` into Builder `b`, and returns the resulting Builder `b'`. The serialization of `x` consists of a 4-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.	`26`
`FB00`	`SENDRAWMSG`	`c x -`	Sends a raw message contained in Cell `c`, which should contain a correctly serialized object `Message X`, with the only exception that the source address is allowed to have dummy value `addr_none` (to be automatically replaced with the current smart-contract address), and `ihr_fee`, `fwd_fee`, `created_lt` and `created_at` fields can have arbitrary values (to be rewritten with correct values during the action phase of the current transaction). Integer parameter `x` contains the flags. Currently `x=0` is used for ordinary messages; `x=128` is used for messages that are to carry all the remaining balance of the current smart contract (instead of the value originally indicated in the message); `x=64` is used for messages that carry all the remaining value of the inbound message in addition to the value initially indicated in the new message (if bit 0 is not set, the gas fees are deducted from this amount); `x'=x+1` means that the sender wants to pay transfer fees separately; `x'=x+2` means that any errors arising while processing this message during the action phase should be ignored. Finally, `x'=x+32` means that the current account must be destroyed if its resulting balance is zero. This flag is usually employed together with `+128`.	`526`
`F900`	`HASHCU`	`c - x`	Computes the representation hash of a Cell `c` and returns it as a 256-bit unsigned integer `x`. Useful for signing and checking signatures of arbitrary entities represented by a tree of cells.	`26`
`FA44`	`REWRITESTDADDR`	`s - x y`	Parses Slice `s` containing a valid `MsgAddressInt` (usually a `msg_addr_std`), applies rewriting from the `anycast` (if present) to the same-length prefix of the address, and returns both the workchain `x` and the 256-bit address `y` as integers. If the address is not 256-bit, or if `s` is not a valid serialization of `MsgAddressInt`, throws a cell deserialization exception.	`26`
`F836`	`GETGASFEE`	`gas_used is_mc - price`	Calculates gas fee
`FB02`	`RAWRESERVE`	`x y -`	Creates an output action which would reserve exactly `x` nanograms (if `y=0`), at most `x` nanograms (if `y=2`), or all but `x` nanograms (if `y=1` or `y=3`), from the remaining balance of the account. It is roughly equivalent to creating an outbound message carrying `x` nanograms (or `b-x` nanograms, where `b` is the remaining balance) to oneself, so that the subsequent output actions would not be able to spend more money than the remainder. Bit `+2` in `y` means that the external action does not fail if the specified amount cannot be reserved; instead, all remaining balance is reserved. Bit `+8` in `y` means `x:=-x` before performing any further actions. Bit `+4` in `y` means that `x` is increased by the original balance of the current account (before the compute phase), including all extra currencies, before performing any other checks and actions. Currently `x` must be a non-negative integer, and `y` must be in the range `0...15`.	`526`
`F80F`	`COMMIT`	`-`	Commits the current state of registers `c4` (''persistent data'') and `c5` (''actions'') so that the current execution is considered ''successful'' with the saved values even if an exception is thrown later.	`26`
`F815`	`ADDRAND RANDOMIZE`	`x -`	Mixes unsigned 256-bit Integer `x` into the random seed `r` by setting the random seed to `Sha` of the concatenation of two 32-byte strings: the first with the big-endian representation of the old seed `r`, and the second with the big-endian representation of `x`.	`26`
`F833`	`CONFIGOPTPARAM`	`i - c^?`	Returns the value of the global configuration parameter with integer index `i` as a Maybe Cell `c^?`. Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.
`F838`	`GETFORWARDFEE`	`cells bits is_mc - price`	Calculates forward fee.
`F811`	`RAND`	`y - z`	Generates a new pseudo-random integer `z` in the range `0...y-1` (or `y...-1`, if `y<0`). More precisely, an unsigned random value `x` is generated as in `RAND256U`; then `z:=floor(x*y/2^256)` is computed. Equivalent to `RANDU256` `256 MULRSHIFT`.	`26+\|c7\|+\|c1_1\|`
`F810`	`RANDU256`	`- x`	Generates a new pseudo-random unsigned 256-bit Integer `x`. The algorithm is as follows: if `r` is the old value of the random seed, considered as a 32-byte array (by constructing the big-endian representation of an unsigned 256-bit integer), then its `sha512(r)` is computed; the first 32 bytes of this hash are stored as the new value `r'` of the random seed, and the remaining 32 bytes are returned as the next random value `x`.	`26+\|c7\|+\|c1_1\|`
`F902`	`SHA256U`	`s - x`	Computes `Sha` of the data bits of Slice `s`. If the bit length of `s` is not divisible by eight, throws a cell underflow exception. The hash value is returned as a 256-bit unsigned integer `x`.	`26`
`FA03`	`STVARINT16`	`b x - b'`	Similar to `STVARUINT16`, but serializes a signed Integer `x` in the range `-2^119...2^119-1`.	`26`
`FB04`	`SETCODE`	`c -`	Creates an output action that would change this smart contract code to that given by Cell `c`. Notice that this change will take effect only after the successful termination of the current run of the smart contract.	`526`
`F83A`	`GETORIGINALFWDFEE`	`fwd_fee is_mc - orig_fwd_fee`	Calculate `fwd_fee * 2^16 / first_frac`. Can be used to get the original `fwd_fee` of the message.
`F801`	`SETGASLIMIT`	`g -`	Sets current gas limit `g_l` to the minimum of `g` and `g_m`, and resets the gas credit `g_c` to zero. If the gas consumed so far (including the present instruction) exceeds the resulting value of `g_l`, an (unhandled) out of gas exception is thrown before setting new gas limits. Notice that `SETGASLIMIT` with an argument `g >= 2^63-1` is equivalent to `ACCEPT`.	`26`
`FA46`	`REWRITEVARADDR`	`s - x s'`	A variant of `REWRITESTDADDR` that returns the (rewritten) address as a Slice `s`, even if it is not exactly 256 bit long (represented by a `msg_addr_var`).	`26`
`F911`	`CHKSIGNS`	`d s k - ?`	Checks whether `s` is a valid Ed25519-signature of the data portion of Slice `d` using public key `k`, similarly to `CHKSIGNU`. If the bit length of Slice `d` is not divisible by eight, throws a cell underflow exception. The verification of Ed25519 signatures is the standard one, with `Sha` used to reduce `d` to the 256-bit number that is actually signed.	`26`
`F941`	`CDATASIZE`	`c n - x y z`	A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.
`FA01`	`LDVARINT16`	`s - x s'`	Similar to `LDVARUINT16`, but loads a signed Integer `x`. Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.	`26`
`F93010`	`BLS_G1_ADD`	`x y - x+y`	Addition on G1.	`3934`
`F93013`	`BLS_G1_MUL`	`x s - x*s`	Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.	`5234`
`F837`	`GETSTORAGEFEE`	`cells bits seconds is_mc - price`	Calculates storage fees (only current StoragePrices entry is used).
`F90403`	`HASHEXT_KECCAK256`	`s_1 ... s_n n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/11 gas per byte`
`F940`	`CDATASIZEQ`	`c n - x y z -1 or 0`	Recursively computes the count of distinct cells `x`, data bits `y`, and cell references `z` in the dag rooted at Cell `c`, effectively returning the total storage used by this dag taking into account the identification of equal cells. The values of `x`, `y`, and `z` are computed by a depth-first traversal of this dag, with a hash table of visited cell hashes used to prevent visits of already-visited cells. The total count of visited cells `x` cannot exceed non-negative Integer `n`; otherwise the computation is aborted before visiting the `(n+1)`-st cell and a zero is returned to indicate failure. If `c` is Null, returns `x=y=z=0`.
`F839`	`GETPRECOMPILEDGAS`	`- x`	Returns gas usage for the current contract if it is precompiled, `null` otherwise.
`F83C`	`GETFORWARDFEESIMPLE`	`cells bits is_mc - price`	Same as `GETFORWARDFEE`, but without lump price (just (`bitsbit_price + cellscell_price) / 2^16`).
`F807`	`GASCONSUMED`	`- g_c`	Returns gas consumed by VM so far (including this instruction).	`26`
`F814`	`SETRAND`	`x -`	Sets the random seed to unsigned 256-bit Integer `x`.	`26+\|c7\|+\|c1_1\|`
`F912`	`ECRECOVER`	`hash v r s - 0 or h x1 x2 -1`	Recovers the public key from a secp256k1 signature, identical to Bitcoin/Ethereum operations. Takes a 32-byte hash as `uint256 hash` and a 65-byte signature as `uint8 v`, `uint256 r`, and `uint256 s`. In TON, the `v` value is strictly 0 or 1; no extra flags or extended values are supported. If the public key cannot be recovered, the instruction returns `0`. On success, it returns the recovered 65-byte public key as `uint8 h`, `uint256 x1`, and `uint256 x2`, followed by `-1`.	`1526`
`F93012`	`BLS_G1_NEG`	`x - -x`	Negation on G1.	`784`
`F93030`	`BLS_PAIRING`	`x_1 y_1 ... x_n y_n n - bool`	Given G1 points `x_i` and G2 points `y_i`, calculates and multiply pairings of `x_i,y_i`. Returns true if the result is the multiplicative identity in FP12, false otherwise. Returns false if `n=0`.	`20034+n*11800`
`F90400`	`HASHEXT_SHA256`	`s_1 ... s_n n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/33 gas per byte`
`FA42`	`PARSEMSGADDR`	`s - t`	Decomposes Slice `s` containing a valid `MsgAddress` into a Tuple `t` with separate fields of this `MsgAddress`. If `s` is not a valid `MsgAddress`, a cell deserialization exception is thrown.	`26`
`FA41`	`LDMSGADDRQ`	`s - s' s'' -1 or s 0`	A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.	`26`
`F943`	`SDATASIZE`	`s n - x y z`	A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.
`FB06`	`SETLIBCODE`	`c x -`	Creates an output action that would modify the collection of this smart contract libraries by adding or removing library with code given in Cell `c`. If `x=0`, the library is actually removed if it was previously present in the collection (if not, this action does nothing). If `x=1`, the library is added as a private library, and if `x=2`, the library is added as a public library (and becomes available to all smart contracts if the current smart contract resides in the masterchain); if the library was present in the collection before, its public/private status is changed according to `x`. Values of `x` other than `0...2` are invalid.	`526`
`F83400`	`PREVMCBLOCKS`	`- t`	Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).
`FB08`	`SENDMSG`	`c x - fee`	Creates an output action and returns a fee for creating a message. Mode has the same effect as in the case of `SENDRAWMSG`. Additionally `+1024` means - do not create an action, only estimate fee. Other modes affect the fee calculation as follows: `+64` substitutes the entire balance of the incoming message as an outcoming value (slightly inaccurate, gas expenses that cannot be estimated before the computation is completed are not taken into account), `+128` substitutes the value of the entire balance of the contract before the start of the computation phase (slightly inaccurate, since gas expenses that cannot be estimated before the completion of the computation phase are not taken into account).	`526`
`F83401`	`PREVKEYBLOCK`	`- t`	Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).
`F924`	`RIST255_MUL`	`x n - x*n`	Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.	`2026`
`F90600`	`HASHEXTA_SHA256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/33 gas per byte`
`F925`	`RIST255_MULBASE`	`n - g*n`	Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.	`776`
`F840`	`GETGLOBVAR`	`k - x`	Returns the `k`-th global variable for `0 <= k < 255`. Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.	`26`
`F83B`	`GETGASFEESIMPLE`	`gas_used is_mc - price`	Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.
`F835`	`GLOBALID`	`- i`	Retrieves `global_id` from 19 network config.
`F90401`	`HASHEXT_SHA512`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/16 gas per byte`
`F920`	`RIST255_FROMHASH`	`h1 h2 - x`	Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).	`626`
`F926`	`RIST255_PUSHL`	`- l`	Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.	`26`
`F923`	`RIST255_SUB`	`x y - x-y`	Subtraction of two points on curve.	`626`
`F921`	`RIST255_VALIDATE`	`x -`	Checks that integer `x` is a valid representation of some curve point. Throws range_chk on error.	`226`
`F93014`	`BLS_G1_MULTIEXP`	`x_1 s_1 ... x_n s_n n - x_1s_1+...+x_ns_n`	Calculates `x_1s_1+...+x_ns_n` for G1 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.	`11409+n630+n/floor(max(log2(n),4))8820`
`FA45`	`REWRITESTDADDRQ`	`s - x y -1 or 0`	A quiet version of primitive `REWRITESTDADDR`.	`26`
`F914`	`P256_CHKSIGNU`	`h sig k - ?`	Checks seck256r1-signature `sig` of a number `h` (a 256-bit unsigned integer, usually computed as the hash of some data) and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).	`3526`
`F93001`	`BLS_AGGREGATE`	`sig_1 ... sig_n n - sig`	Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.	`n*4350-2616`
`F93003`	`BLS_AGGREGATEVERIFY`	`pk_1 msg_1 ... pk_n msg_n n sgn - bool`	Checks aggregated BLS signature for key-message pairs `pk_1 msg_1...pk_n msg_n`. Return true on success, false otherwise. Return false if `n=0`.	`38534+n*22500`
`F93002`	`BLS_FASTAGGREGATEVERIFY`	`pk_1 ... pk_n n msg sig - bool`	Checks aggregated BLS signature for keys `pk_1...pk_n` and message `msg`. Return true on success, false otherwise. Return false if `n=0`.	`58034+n*3000`
`F93017`	`BLS_G1_INGROUP`	`x - bool`	Checks that slice `x` represents a valid element of G1.	`2984`
`F93018`	`BLS_G1_ISZERO`	`x - bool`	Checks that G1 point `x` is equal to zero.	`34`
`F93011`	`BLS_G1_SUB`	`x y - x-y`	Subtraction on G1.	`3934`
`F93015`	`BLS_G1_ZERO`	`- zero`	Pushes zero point in G1.	`34`
`F93020`	`BLS_G2_ADD`	`x y - x+y`	Addition on G2.	`6134`
`F93027`	`BLS_G2_INGROUP`	`x - bool`	Checks that slice `x` represents a valid element of G2.	`4284`
`F93028`	`BLS_G2_ISZERO`	`x - bool`	Checks that G2 point `x` is equal to zero.	`34`
`F93023`	`BLS_G2_MUL`	`x s - x*s`	Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.	`10584`
`F93024`	`BLS_G2_MULTIEXP`	`x_1 s_1 ... x_n s_n n - x_1s_1+...+x_ns_n`	Calculates `x_1s_1+...+x_ns_n` for G2 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.	`30422+n1280+n/floor(max(log2(n),4))22840`
`F93022`	`BLS_G2_NEG`	`x - -x`	Negation on G2.	`1584`
`F93021`	`BLS_G2_SUB`	`x y - x-y`	Subtraction on G2.	`6134`
`F93025`	`BLS_G2_ZERO`	`- zero`	Pushes zero point in G2.	`34`
`F93016`	`BLS_MAP_TO_G1`	`f - x`	Converts FP element `f` to a G1 point.	`2384`
`F93026`	`BLS_MAP_TO_G2`	`f - x`	Converts FP2 element `f` to a G2 point.	`7984`
`F93031`	`BLS_PUSHR`	`- r`	Pushes the order of G1 and G2 (approx. `2^255`).	`34`
`F93000`	`BLS_VERIFY`	`pk msg sgn - bool`	Checks BLS signature, return true on success, false otherwise.	`61034`
`FB07`	`CHANGELIB`	`h x -`	Creates an output action similarly to `SETLIBCODE`, but instead of the library code accepts its hash as an unsigned 256-bit integer `h`. If `x!=0` and the library with hash `h` is absent from the library collection of this smart contract, this output action will fail.	`526`
`F830`	`CONFIGDICT`	`- D 32`	Returns the global configuration dictionary along with its key length (32). Equivalent to `CONFIGROOT` `32 PUSHINT`.	`26`
`F832`	`CONFIGPARAM`	`i - c -1 or 0`	Returns the value of the global configuration parameter with integer index `i` as a Cell `c`, and a flag to indicate success. Equivalent to `CONFIGDICT` `DICTIGETREF`.
`F90702`	`HASHEXTAR_BLAKE2B`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/19 gas per byte`
`F90703`	`HASHEXTAR_KECCAK256`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/11 gas per byte`
`F90704`	`HASHEXTAR_KECCAK512`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/6 gas per byte`
`F90700`	`HASHEXTAR_SHA256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/33 gas per byte`
`F90701`	`HASHEXTAR_SHA512`	`b s_n ... s_1 n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/16 gas per byte`
`F90602`	`HASHEXTA_BLAKE2B`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/19 gas per byte`
`F90603`	`HASHEXTA_KECCAK256`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/11 gas per byte`
`F90604`	`HASHEXTA_KECCAK512`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/6 gas per byte`
`F90601`	`HASHEXTA_SHA512`	`b s_1 ... s_n n - b'`	Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.	`1/16 gas per byte`
`F90502`	`HASHEXTR_BLAKE2B`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90503`	`HASHEXTR_KECCAK256`	`s_n ... s_1 n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/11 gas per byte`
`F90504`	`HASHEXTR_KECCAK512`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90500`	`HASHEXTR_SHA256`	`s_n ... s_1 n - h`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/33 gas per byte`
`F90501`	`HASHEXTR_SHA512`	`s_n ... s_1 n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/16 gas per byte`
`F90402`	`HASHEXT_BLAKE2B`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`F90404`	`HASHEXT_KECCAK512`	`s_1 ... s_n n - h1 h2`	Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.	`1/19 gas per byte`
`FA05`	`LDVARINT32`	`s - x s'`	Similar to `LDVARUINT32`, but loads a signed Integer `x`. Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.	`26`
`FA04`	`LDVARUINT32`	`s - x s'`	Loads (deserializes) a `VarUInteger 32` amount from Slice `s`, and returns the amount as Integer `x` along with the remainder `s'` of `s`. The expected serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, followed by an `8l`-bit unsigned big-endian representation of `x`. The net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.	`26`
`F915`	`P256_CHKSIGNS`	`d sig k - ?`	Checks seck256r1-signature `sig` of data portion of slice `d` and public key `k`. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).	`3526`
`FA43`	`PARSEMSGADDRQ`	`s - t -1 or 0`	A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.	`26`
`FB03`	`RAWRESERVEX`	`x D y -`	Similar to `RAWRESERVE`, but also accepts a dictionary `D` (represented by a Cell or Null) with extra currencies. In this way currencies other than Grams can be reserved.	`526`
`FA47`	`REWRITEVARADDRQ`	`s - x s' -1 or 0`	A quiet version of primitive `REWRITEVARADDR`.	`26`
`F922`	`RIST255_ADD`	`x y - x+y`	Addition of two points on a curve.	`626`
`B7F922`	`RIST255_QADD`	`x y - 0 or x+y -1`	Addition of two points on a curve. Returns -1 on success and 0 on failure.	`634`
`B7F924`	`RIST255_QMUL`	`x n - 0 or x*n -1`	Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.	`2034`
`B7F925`	`RIST255_QMULBASE`	`n - 0 or g*n -1`	Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.	`784`
`B7F923`	`RIST255_QSUB`	`x y - 0 or x-y -1`	Subtraction of two points on curve. Returns -1 on success and 0 on failure.	`634`
`B7F921`	`RIST255_QVALIDATE`	`x - 0 or -1`	Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.	`234`
`F942`	`SDATASIZEQ`	`s n - x y z -1 or 0`	Similar to `CDATASIZEQ`, but accepting a Slice `s` instead of a Cell. The returned value of `x` does not take into account the cell that contains the slice `s` itself; however, the data bits and the cell references of `s` are accounted for in `y` and `z`.
`F860`	`SETGLOBVAR`	`x k -`	Assigns `x` to the `k`-th global variable for `0 <= k < 255`. Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.	`26+\|c7'\|`
`FA07`	`STVARINT32`	`b x - b'`	Similar to `STVARUINT32`, but serializes a signed Integer `x` in the range `-2^247...2^247-1`.	`26`
`FA06`	`STVARUINT32`	`b x - b'`	Stores (serializes) an Integer `x` in the range `0...2^248-1` into Builder `b`, and returns the resulting Builder `b'`. The serialization of `x` consists of a 5-bit unsigned big-endian integer `l`, which is the smallest integer `l>=0`, such that `x<2^(8l)`, followed by an `8l`-bit unsigned big-endian representation of `x`. If `x` does not belong to the supported range, a range check exception is thrown.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`FFnn`	`[nn] SETCP`	`-`	Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.	`26`
`FEij`	`{i*16+j} DEBUG`	`-`		`26`
`FEFnssss`	`{string} DEBUGSTR {string} {x} DEBUGSTRI`	`-`	`0 <= n < 16`. Length of `ssss` is `n+1` bytes. `{string}` is a string literal. `DEBUGSTR`: `ssss` is the given string. `DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.	`26`
`FFF0`	`SETCPX`	`c -`	Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.	`26`
`FFFz`	`[z-16] SETCP`	`-`	Selects TVM codepage `z-16` for `1 <= z <= 15`. Negative codepages `-13...-1` are reserved for restricted versions of TVM needed to validate runs of TVM in other codepages. Negative codepage `-14` is reserved for experimental codepages, not necessarily compatible between different TVM implementations, and should be disabled in the production versions of TVM.	`26`

Opcode	Fift syntax	Stack	Description	Gas
`0i`	`SWAP`	`x y - y x`	Same as `s1 XCHG0`.	`18`
`2i`	`DUP`	`x - x x`	Same as `s0 PUSH`.	`18`
`2i`	`OVER`	`x y - x y x`	Same as `s1 PUSH`.	`18`
`3i`	`DROP`	`x -`	Same as `s0 POP`, discards the top-of-stack value.	`18`
`3i`	`NIP`	`x y - y`	Same as `s1 POP`.	`18`
`55ij`	`ROT2 2ROT`	`a b c d e f - c d e f a b`	Rotates the three topmost pairs of stack entries.	`26`
`55ij`	`[i+1] ROLL`		Rotates the top `i+1` stack entries. Equivalent to `1 [i+1] BLKSWAP`.	`26`
`55ij`	`[i+1] -ROLL [i+1] ROLLREV`		Rotates the top `i+1` stack entries in the other direction. Equivalent to `[i+1] 1 BLKSWAP`.	`26`
`6F0n`	`NIL`	`- t`	Pushes the only Tuple `t=()` of length zero.	`26+n`
`6F0n`	`SINGLE`	`x - t`	Creates a singleton `t:=(x)`, i.e., a Tuple of length one.	`26+n`
`6F0n`	`PAIR CONS`	`x y - t`	Creates pair `t:=(x,y)`.	`26+n`
`6F0n`	`TRIPLE`	`x y z - t`	Creates triple `t:=(x,y,z)`.	`26+n`
`6F1k`	`FIRST CAR`	`t - x`	Returns the first element of a Tuple.	`26`
`6F1k`	`SECOND CDR`	`t - y`	Returns the second element of a Tuple.	`26`
`6F1k`	`THIRD`	`t - z`	Returns the third element of a Tuple.	`26`
`6F2n`	`UNSINGLE`	`t - x`	Unpacks a singleton `t=(x)`.	`26+n`
`6F2n`	`UNPAIR UNCONS`	`t - x y`	Unpacks a pair `t=(x,y)`.	`26+n`
`6F2n`	`UNTRIPLE`	`t - x y z`	Unpacks a triple `t=(x,y,z)`.	`26+n`
`6F3k`	`CHKTUPLE`	`t -`	Checks whether `t` is a Tuple. If not, throws a type check exception.	`26+k`
`6F5k`	`SETFIRST`	`t x - t'`	Sets the first component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t\|`
`6F5k`	`SETSECOND`	`t x - t'`	Sets the second component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t\|`
`6F5k`	`SETTHIRD`	`t x - t'`	Sets the third component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t\|`
`6F6k`	`FIRSTQ CARQ`	`t - x`	Returns the first element of a Tuple.	`26`
`6F6k`	`SECONDQ CDRQ`	`t - y`	Returns the second element of a Tuple.	`26`
`6F6k`	`THIRDQ`	`t - z`	Returns the third element of a Tuple.	`26`
`6F7k`	`SETFIRSTQ`	`t x - t'`	Sets the first component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t'\|`
`6F7k`	`SETSECONDQ`	`t x - t'`	Sets the second component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t'\|`
`6F7k`	`SETTHIRDQ`	`t x - t'`	Sets the third component of Tuple `t` to `x` and returns the resulting Tuple `t'`.	`26+\|t'\|`
`6FBij`	`CADR`	`t - x`	Recovers `x=(t_2)_1`.	`26`
`6FBij`	`CDDR`	`t - x`	Recovers `x=(t_2)_2`.	`26`
`6FE_ijk`	`CADDR`	`t - x`	Recovers `x=t_2_2_1`.	`26`
`6FE_ijk`	`CDDDR`	`t - x`	Recovers `x=t_2_2_2`.	`26`
`7i`	`ZERO FALSE`	`- 0`		`18`
`7i`	`ONE`	`- 1`		`18`
`7i`	`TWO`	`- 2`		`18`
`7i`	`TEN`	`- 10`		`18`
`7i`	`TRUE`	`- -1`		`18`
`B4cc`	`CHKBOOL`	`x - x`	Checks whether `x` is a ''boolean value'' (i.e., either 0 or -1).	`26/76`
`B5cc`	`CHKBIT`	`x - x`	Checks whether `x` is a binary digit (i.e., zero or one).	`26/76`
`C0yy`	`ISZERO`	`x - x=0`	Checks whether an integer is zero. Corresponds to Forth's `0=`.	`26`
`C1yy`	`ISNEG`	`x - x<0`	Checks whether an integer is negative. Corresponds to Forth's `0<`.	`26`
`C1yy`	`ISNPOS`	`x - x<=0`	Checks whether an integer is non-positive.	`26`
`C2yy`	`ISPOS`	`x - x>0`	Checks whether an integer is positive. Corresponds to Forth's `0>`.	`26`
`C2yy`	`ISNNEG`	`x - x >=0`	Checks whether an integer is non-negative.	`26`
`CFC0_xysss`	`STZERO`	`b - b'`	Stores one binary zero.	`24`
`CFC0_xysss`	`STONE`	`b - b'`	Stores one binary one.	`24`
`D74E_n`	`PLDREF`	`s - c`	Preloads the first cell reference of a Slice.	`26`
`ECrn`	`[n] SETNUMARGS`	`c - c'`	Sets `c.nargs` to `n` plus the current depth of `c`'s stack, where `0 <= n <= 14`. If `c.nargs` is already set to a non-negative value, does nothing.	`26+s''`
`ECrn`	`[r] -1 SETCONTARGS`	`x_1 x_2...x_r c - c'`	Pushes `0 <= r <= 15` values `x_1...x_r` into the stack of (a copy of) the continuation `c`, starting with `x_1`. If the final depth of `c`'s stack turns out to be greater than `c.nargs`, a stack overflow exception is generated.	`26+s''`
`EErn`	`[n] BLESSNUMARGS`	`s - c`	Also transforms a Slice `s` into a Continuation `c`, but sets `c.nargs` to `0 <= n <= 14`.	`26`
`ED4i`	`c4 PUSHCTR c4 PUSH`	`- x`	Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data.	`26`
`ED5i`	`c4 POPCTR c4 POP`	`x -`	Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data.	`26`
`6D`	`NEWDICT`	`- D`	Returns a new empty dictionary. It is an alternative mnemonics for `PUSHNULL`.	`18`
`6E`	`DICTEMPTY`	`D - ?`	Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly. It is an alternative mnemonics for `ISNULL`.	`18`
`CE`	`STDICTS`	`s b - b'`	Stores a Slice-represented dictionary `s` into Builder `b`. It is actually a synonym for `STSLICE`.	`18`
`F82i`	`NOW`	`- x`	Returns the current Unix time as an Integer. If it is impossible to recover the requested value starting from `c7`, throws a type checking or range checking exception as appropriate. Equivalent to `3 GETPARAM`.	`26`
`F82i`	`BLOCKLT`	`- x`	Returns the starting logical time of the current block. Equivalent to `4 GETPARAM`.	`26`
`F82i`	`LTIME`	`- x`	Returns the logical time of the current transaction. Equivalent to `5 GETPARAM`.	`26`
`F82i`	`RANDSEED`	`- x`	Returns the current random seed as an unsigned 256-bit Integer. Equivalent to `6 GETPARAM`.	`26`
`F82i`	`BALANCE`	`- t`	Returns the remaining balance of the smart contract as a Tuple consisting of an Integer (the remaining Gram balance in nanograms) and a Maybe Cell (a dictionary with 32-bit keys representing the balance of ''extra currencies''). Equivalent to `7 GETPARAM`. Note that `RAW` primitives such as `SENDRAWMSG` do not update this field.	`26`
`F82i`	`MYADDR`	`- s`	Returns the internal address of the current smart contract as a Slice with a `MsgAddressInt`. If necessary, it can be parsed further using primitives such as `PARSEMSGADDR` or `REWRITESTDADDR`. Equivalent to `8 GETPARAM`.	`26`
`F82i`	`CONFIGROOT`	`- D`	Returns the Maybe Cell `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM` .	`26`
`F82i`	`MYCODE`	`- c`	Retrieves code of smart-contract from c7. Equivalent to `10 GETPARAM` .	`26`
`F82i`	`INCOMINGVALUE`	`- t`	Retrieves value of incoming message from c7. Equivalent to `11 GETPARAM` .	`26`
`F82i`	`STORAGEFEES`	`- i`	Retrieves value of storage phase fees from c7. Equivalent to `12 GETPARAM` .	`26`
`F82i`	`PREVBLOCKSINFOTUPLE`	`- t`	Retrives PrevBlocksInfo: `[last_mc_blocks, prev_key_block]` from c7. Equivalent to `13 GETPARAM` .	`26`
`FEij`	`DUMPSTK`	`-`	Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM.	`26`
`FEij`	`STRDUMP`	`-`	Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.	`26`
`FEij`	`s[j] DUMP`	`-`	Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.	`26`
`FFnn`	`SETCP0`	`-`	Selects TVM (test) codepage zero as described in this document.	`26`

Exit From TVM Instruction Full Screen Mode

Introduction​

Gas prices​

Quick search​

Introduction

Gas prices

Quick search