# Instructions (https://docs-orhepa2tm-ton-core-docs.vercel.app/llms/tvm/instructions/content.md)
The [notation](#notation) section below explains how the table encodes TVM instruction opcodes and immediate arguments in binary.
## Notation [#notation]
### Opcodes [#opcodes]
TVM instructions are encoded as variable-length bit sequences, with each instruction being a multiple of a byte. The immediate arguments form a part of the instruction and have no special demarcation in a bitstream. This leads to some instructions sharing the same opcode *prefix*.
For instance, the `NOP` instruction has the full opcode `0x00`, which represents 8 consecutive zero bits (a null byte). At the same time, the `XCHG_0I` family of instructions starts with `0x0`, which is 4 consecutive zero bits, then continues with a 4-bit immediate argument ranging from `0x1` to `0xF`.
The `opcode` column lists instruction prefixes without arguments in hexadecimal, representing the corresponding bit sequences that are always multiples of 4. Yet, the `opcode` *box* on an instruction card shows the full [TL-B](/llms/foundations/tlb/overview/content.md) schema for the instruction, including immediate arguments.
### Stack slots [#stack-slots]
The `s[i]` notation refers to the `i`-th stack slot counting from the top, and the top being the `0`-th slot. Particular stack slots are referenced directly as `s0`, `s1` and so forth in TASM, Fift and documentation, and are encoded simply by index in the binary.
### Bracket formulas [#bracket-formulas]
The `[32(c+1)] PLDUZ` notation means a value for `c` should be chosen, the calculation performed, and the result substituted. For example, with `c = 2`, the instruction is written as `96 PLDUZ` in Fift. The value `96` is the actual number of bits to read, while the bitstream stores only the value for `c`, and the TVM performs the calculation on its own.
{/* STATIC_START tvm_instructions */}
#### `00` NOP [#00-nop]
Does nothing.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
NOP
```
#### `0i` XCHG\_0I [#0i-xchg_0i]
Interchanges `s0` with `s[i]`, `1 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s[i] XCHG0
```
**Aliases**:
* `SWAP`
Same as `s1 XCHG0`.
#### `10ij` XCHG\_IJ [#10ij-xchg_ij]
Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s[i] s[j] XCHG
```
#### `11ii` XCHG\_0I\_LONG [#11ii-xchg_0i_long]
Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s0 [ii] s() XCHG
```
#### `1i` XCHG\_1I [#1i-xchg_1i]
Interchanges `s1` with `s[i]`, `2 <= i <= 15`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s1 s[i] XCHG
```
#### `2i` PUSH [#2i-push]
Pushes a copy of the old `s[i]` into the stack.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s[i] PUSH
```
**Aliases**:
* `DUP`
Same as `s0 PUSH`.
* `OVER`
Same as `s1 PUSH`.
#### `3i` POP [#3i-pop]
Pops the old `s0` value into the old `s[i]`.
**Category:** Stack Basic (stack\_basic)
```fift title="Fift"
s[i] POP
```
**Aliases**:
* `DROP`
Same as `s0 POP`, discards the top-of-stack value.
* `NIP`
Same as `s1 POP`.
#### `4ijk` XCHG3 [#4ijk-xchg3]
Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k] XCHG3
```
#### `50ij` XCHG2 [#50ij-xchg2]
Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] XCHG2
```
#### `51ij` XCPU [#51ij-xcpu]
Equivalent to `s[i] XCHG0` `s[j] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] XCPU
```
#### `52ij` PUXC [#52ij-puxc]
Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j-1] PUXC
```
#### `53ij` PUSH2 [#53ij-push2]
Equivalent to `s[i] PUSH` `s[j+1] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] PUSH2
```
#### `540ijk` XCHG3\_ALT [#540ijk-xchg3_alt]
Long form of `XCHG3`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k] XCHG3_l
```
#### `541ijk` XC2PU [#541ijk-xc2pu]
Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k] XC2PU
```
#### `542ijk` XCPUXC [#542ijk-xcpuxc]
Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k-1] XCPUXC
```
#### `543ijk` XCPU2 [#543ijk-xcpu2]
Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k] XCPU2
```
#### `544ijk` PUXC2 [#544ijk-puxc2]
Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j-1] s[k-1] PUXC2
```
#### `545ijk` PUXCPU [#545ijk-puxcpu]
Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j-1] s[k-1] PUXCPU
```
#### `546ijk` PU2XC [#546ijk-pu2xc]
Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j-1] s[k-2] PU2XC
```
#### `547ijk` PUSH3 [#547ijk-push3]
Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
s[i] s[j] s[k] PUSH3
```
#### `55ij` BLKSWAP [#55ij-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`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[i+1] [j+1] BLKSWAP
```
**Aliases**:
* `ROT2`
Rotates the three topmost pairs of stack entries.
* `ROLL`
Rotates the top `i+1` stack entries.
Equivalent to `1 [i+1] BLKSWAP`.
* `ROLLREV`
Rotates the top `i+1` stack entries in the other direction.
Equivalent to `[i+1] 1 BLKSWAP`.
#### `56ii` PUSH\_LONG [#56ii-push_long]
Pushes a copy of the old `s[ii]` into the stack.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[ii] s() PUSH
```
#### `57ii` POP\_LONG [#57ii-pop_long]
Pops the old `s0` value into the old `s[ii]`.
`0 <= ii <= 255`
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[ii] s() POP
```
#### `58` ROT [#58-rot]
Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
ROT
```
#### `59` ROTREV [#59-rotrev]
Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
ROTREV
-ROT
```
#### `5A` SWAP2 [#5a-swap2]
Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
SWAP2
2SWAP
```
#### `5B` DROP2 [#5b-drop2]
Equivalent to `DROP` `DROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
DROP2
2DROP
```
#### `5C` DUP2 [#5c-dup2]
Equivalent to `s1 s0 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
DUP2
2DUP
```
#### `5D` OVER2 [#5d-over2]
Equivalent to `s3 s2 PUSH2`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
OVER2
2OVER
```
#### `5Eij` REVERSE [#5eij-reverse]
Reverses the order of `s[j+i+1] ... s[j]`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[i+2] [j] REVERSE
```
#### `5F0i` BLKDROP [#5f0i-blkdrop]
Equivalent to `DROP` performed `i` times.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[i] BLKDROP
```
#### `5Fij` BLKPUSH [#5fij-blkpush]
Equivalent to `PUSH s(j)` performed `i` times.
`1 <= i <= 15`, `0 <= j <= 15`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[i] [j] BLKPUSH
```
#### `60` PICK [#60-pick]
Pops integer `i` from the stack, then performs `s[i] PUSH`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
PICK
PUSHX
```
#### `61` ROLLX [#61-rollx]
Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
ROLLX
```
#### `62` -ROLLX [#62--rollx]
Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
-ROLLX
ROLLREVX
```
#### `63` BLKSWX [#63-blkswx]
Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
BLKSWX
```
#### `64` REVX [#64-revx]
Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
REVX
```
#### `65` DROPX [#65-dropx]
Pops integer `i` from the stack, then performs `[i] BLKDROP`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
DROPX
```
#### `66` TUCK [#66-tuck]
Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
TUCK
```
#### `67` XCHGX [#67-xchgx]
Pops integer `i` from the stack, then performs `s[i] XCHG`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
XCHGX
```
#### `68` DEPTH [#68-depth]
Pushes the current depth of the stack.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
DEPTH
```
#### `69` CHKDEPTH [#69-chkdepth]
Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
CHKDEPTH
```
#### `6A` ONLYTOPX [#6a-onlytopx]
Pops integer `i` from the stack, then removes all but the top `i` elements.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
ONLYTOPX
```
#### `6B` ONLYX [#6b-onlyx]
Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
ONLYX
```
#### `6Cij` BLKDROP2 [#6cij-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`.
**Category:** Stack Complex (stack\_complex)
```fift title="Fift"
[i] [j] BLKDROP2
```
#### `6D` NULL [#6d-null]
Pushes the only value of type *Null*.
**Category:** Tuple (tuple)
```fift title="Fift"
NULL
PUSHNULL
```
**Aliases**:
* `NEWDICT`
Returns a new empty dictionary.
It is an alternative mnemonics for `PUSHNULL`.
#### `6E` ISNULL [#6e-isnull]
Checks whether `x` is a *Null*, and returns `-1` or `0` accordingly.
**Category:** Tuple (tuple)
```fift title="Fift"
ISNULL
```
**Aliases**:
* `DICTEMPTY`
Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.
It is an alternative mnemonics for `ISNULL`.
#### `6F0n` TUPLE [#6f0n-tuple]
Creates a new *Tuple* `t=(x_1, ... ,x_n)` containing `n` values `x_1`,..., `x_n`.
`0 <= n <= 15`
**Category:** Tuple (tuple)
```fift title="Fift"
[n] TUPLE
```
**Aliases**:
* `NIL`
Pushes the only *Tuple* `t=()` of length zero.
* `SINGLE`
Creates a singleton `t:=(x)`, i.e., a *Tuple* of length one.
* `PAIR`
Creates pair `t:=(x,y)`.
* `TRIPLE`
Creates triple `t:=(x,y,z)`.
#### `6F1k` INDEX [#6f1k-index]
Returns the `k`-th element of a *Tuple* `t`.
`0 <= k <= 15`.
**Category:** Tuple (tuple)
```fift title="Fift"
[k] INDEX
```
**Aliases**:
* `FIRST`
Returns the first element of a *Tuple*.
* `SECOND`
Returns the second element of a *Tuple*.
* `THIRD`
Returns the third element of a *Tuple*.
#### `6F2n` UNTUPLE [#6f2n-untuple]
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.
**Category:** Tuple (tuple)
```fift title="Fift"
[n] UNTUPLE
```
**Aliases**:
* `UNSINGLE`
Unpacks a singleton `t=(x)`.
* `UNPAIR`
Unpacks a pair `t=(x,y)`.
* `UNTRIPLE`
Unpacks a triple `t=(x,y,z)`.
#### `6F3k` UNPACKFIRST [#6f3k-unpackfirst]
Unpacks first `0 <= k <= 15` elements of a *Tuple* `t`.
If `|t|
**Category:** Tuple (tuple)
```fift title="Fift"
[k] UNPACKFIRST
```
**Aliases**:
* `CHKTUPLE`
Checks whether `t` is a *Tuple*. If not, throws a type check exception.
#### `6F4n` EXPLODE [#6f4n-explode]
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.
**Category:** Tuple (tuple)
```fift title="Fift"
[n] EXPLODE
```
#### `6F5k` SETINDEX [#6f5k-setindex]
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.
**Category:** Tuple (tuple)
```fift title="Fift"
[k] SETINDEX
```
**Aliases**:
* `SETFIRST`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
* `SETSECOND`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
* `SETTHIRD`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
#### `6F6k` INDEXQ [#6f6k-indexq]
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`.
**Category:** Tuple (tuple)
```fift title="Fift"
[k] INDEXQ
```
**Aliases**:
* `FIRSTQ`
Returns the first element of a *Tuple*.
* `SECONDQ`
Returns the second element of a *Tuple*.
* `THIRDQ`
Returns the third element of a *Tuple*.
#### `6F7k` SETINDEXQ [#6f7k-setindexq]
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).
**Category:** Tuple (tuple)
```fift title="Fift"
[k] SETINDEXQ
```
**Aliases**:
* `SETFIRSTQ`
Sets the first component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
* `SETSECONDQ`
Sets the second component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
* `SETTHIRDQ`
Sets the third component of *Tuple* `t` to `x` and returns the resulting *Tuple* `t'`.
#### `6F80` TUPLEVAR [#6f80-tuplevar]
Creates a new *Tuple* `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
TUPLEVAR
```
#### `6F81` INDEXVAR [#6f81-indexvar]
Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
INDEXVAR
```
#### `6F82` UNTUPLEVAR [#6f82-untuplevar]
Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
UNTUPLEVAR
```
#### `6F83` UNPACKFIRSTVAR [#6f83-unpackfirstvar]
Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
UNPACKFIRSTVAR
```
#### `6F84` EXPLODEVAR [#6f84-explodevar]
Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
EXPLODEVAR
```
#### `6F85` SETINDEXVAR [#6f85-setindexvar]
Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
SETINDEXVAR
```
#### `6F86` INDEXVARQ [#6f86-indexvarq]
Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
INDEXVARQ
```
#### `6F87` SETINDEXVARQ [#6f87-setindexvarq]
Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.
**Category:** Tuple (tuple)
```fift title="Fift"
SETINDEXVARQ
```
#### `6F88` TLEN [#6f88-tlen]
Returns the length of a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift"
TLEN
```
#### `6F89` QTLEN [#6f89-qtlen]
Similar to `TLEN`, but returns `-1` if `t` is not a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift"
QTLEN
```
#### `6F8A` ISTUPLE [#6f8a-istuple]
Returns `-1` or `0` depending on whether `t` is a *Tuple*.
**Category:** Tuple (tuple)
```fift title="Fift"
ISTUPLE
```
#### `6F8B` LAST [#6f8b-last]
Returns the last element of a non-empty *Tuple* `t`.
**Category:** Tuple (tuple)
```fift title="Fift"
LAST
```
#### `6F8C` TPUSH [#6f8c-tpush]
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.
**Category:** Tuple (tuple)
```fift title="Fift"
TPUSH
COMMA
```
#### `6F8D` TPOP [#6f8d-tpop]
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`.
**Category:** Tuple (tuple)
```fift title="Fift"
TPOP
```
#### `6FA0` NULLSWAPIF [#6fa0-nullswapif]
Pushes a *Null* under the topmost *Integer* `x`, but only if `x!=0`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLSWAPIF
```
#### `6FA1` NULLSWAPIFNOT [#6fa1-nullswapifnot]
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`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLSWAPIFNOT
```
#### `6FA2` NULLROTRIF [#6fa2-nullrotrif]
Pushes a *Null* under the second stack entry from the top, but only if the topmost *Integer* `y` is non-zero.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLROTRIF
```
#### `6FA3` NULLROTRIFNOT [#6fa3-nullrotrifnot]
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`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLROTRIFNOT
```
#### `6FA4` NULLSWAPIF2 [#6fa4-nullswapif2]
Pushes two nulls under the topmost *Integer* `x`, but only if `x!=0`.
Equivalent to `NULLSWAPIF` `NULLSWAPIF`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLSWAPIF2
```
#### `6FA5` NULLSWAPIFNOT2 [#6fa5-nullswapifnot2]
Pushes two nulls under the topmost *Integer* `x`, but only if `x=0`.
Equivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLSWAPIFNOT2
```
#### `6FA6` NULLROTRIF2 [#6fa6-nullrotrif2]
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`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLROTRIF2
```
#### `6FA7` NULLROTRIFNOT2 [#6fa7-nullrotrifnot2]
Pushes two nulls under the second stack entry from the top, but only if the topmost *Integer* `y` is zero.
Equivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.
**Category:** Tuple (tuple)
```fift title="Fift"
NULLROTRIFNOT2
```
#### `6FBij` INDEX2 [#6fbij-index2]
Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.
Equivalent to `[i] INDEX` `[j] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift"
[i] [j] INDEX2
```
**Aliases**:
* `CADR`
Recovers `x=(t_2)_1`.
* `CDDR`
Recovers `x=(t_2)_2`.
#### `6FE_ijk` INDEX3 [#6fe_ijk-index3]
Recovers `x=t_{i+1}_{j+1}_{k+1}`.
`0 <= i,j,k <= 3`
Equivalent to `[i] [j] INDEX2` `[k] INDEX`.
**Category:** Tuple (tuple)
```fift title="Fift"
[i] [j] [k] INDEX3
```
**Aliases**:
* `CADDR`
Recovers `x=t_2_2_1`.
* `CDDDR`
Recovers `x=t_2_2_2`.
#### `7i` PUSHINT\_4 [#7i-pushint_4]
Pushes integer `x` into the stack. `-5 <= x <= 10`.
Here `i` equals four lower-order bits of `x` (`i=x mod 16`).
**Category:** Const Int (const\_int)
```fift title="Fift"
[x] PUSHINT
[x] INT
```
**Aliases**:
* `ZERO`
* `ONE`
* `TWO`
* `TEN`
* `TRUE`
#### `80xx` PUSHINT\_8 [#80xx-pushint_8]
Pushes integer `xx`. `-128 <= xx <= 127`.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xx] PUSHINT
[xx] INT
```
#### `81xxxx` PUSHINT\_16 [#81xxxx-pushint_16]
Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xxxx] PUSHINT
[xxxx] INT
```
#### `82lxxx` PUSHINT\_LONG [#82lxxx-pushint_long]
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.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xxx] PUSHINT
[xxx] INT
```
#### `83xx` PUSHPOW2 [#83xx-pushpow2]
(Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.
`2^256` is a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xx+1] PUSHPOW2
```
#### `83FF` PUSHNAN [#83ff-pushnan]
Pushes a `NaN`.
**Category:** Const Int (const\_int)
```fift title="Fift"
PUSHNAN
```
#### `84xx` PUSHPOW2DEC [#84xx-pushpow2dec]
Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xx+1] PUSHPOW2DEC
```
#### `85xx` PUSHNEGPOW2 [#85xx-pushnegpow2]
Pushes `-2^(xx+1)` for `0 <= xx <= 255`.
**Category:** Const Int (const\_int)
```fift title="Fift"
[xx+1] PUSHNEGPOW2
```
#### `88` PUSHREF [#88-pushref]
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).
**Category:** Const Data (const\_data)
```fift title="Fift"
[ref] PUSHREF
```
#### `89` PUSHREFSLICE [#89-pushrefslice]
Similar to `PUSHREF`, but converts the cell into a *Slice*.
**Category:** Const Data (const\_data)
```fift title="Fift"
[ref] PUSHREFSLICE
```
#### `8A` PUSHREFCONT [#8a-pushrefcont]
Similar to `PUSHREFSLICE`, but makes a simple ordinary *Continuation* out of the cell.
**Category:** Const Data (const\_data)
```fift title="Fift"
[ref] PUSHREFCONT
```
#### `8Bxsss` PUSHSLICE [#8bxsss-pushslice]
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.
**Category:** Const Data (const\_data)
```fift title="Fift"
[slice] PUSHSLICE
[slice] SLICE
```
#### `8Crxxssss` PUSHSLICE\_REFS [#8crxxssss-pushslice_refs]
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.
**Category:** Const Data (const\_data)
```fift title="Fift"
[slice] PUSHSLICE
[slice] SLICE
```
#### `8Drxxsssss` PUSHSLICE\_LONG [#8drxxsssss-pushslice_long]
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.
**Category:** Const Data (const\_data)
```fift title="Fift"
[slice] PUSHSLICE
[slice] SLICE
```
#### `8F_rxxcccc` PUSHCONT [#8f_rxxcccc-pushcont]
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`.
**Category:** Const Data (const\_data)
```fift title="Fift"
[builder] PUSHCONT
[builder] CONT
```
#### `9xccc` PUSHCONT\_SHORT [#9xccc-pushcont_short]
Pushes a continuation made from `builder`.
*Details:* Pushes an `x`-byte continuation for `0 <= x <= 15`.
**Category:** Const Data (const\_data)
```fift title="Fift"
[builder] PUSHCONT
[builder] CONT
```
#### `A0` ADD [#a0-add]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
ADD
```
#### `A1` SUB [#a1-sub]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
SUB
```
#### `A2` SUBR [#a2-subr]
Equivalent to `SWAP` `SUB`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
SUBR
```
#### `A3` NEGATE [#a3-negate]
Equivalent to `-1 MULCONST` or to `ZERO SUBR`.
Notice that it triggers an integer overflow exception if `x=-2^256`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
NEGATE
```
#### `A4` INC [#a4-inc]
Equivalent to `1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
INC
```
#### `A5` DEC [#a5-dec]
Equivalent to `-1 ADDCONST`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
DEC
```
#### `A6cc` ADDCONST [#a6cc-addconst]
`-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
[cc] ADDCONST
[cc] ADDINT
[-cc] SUBCONST
[-cc] SUBINT
```
#### `A7cc` MULCONST [#a7cc-mulconst]
`-128 <= cc <= 127`.
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
[cc] MULCONST
[cc] MULINT
```
#### `A8` MUL [#a8-mul]
**Category:** Arithm Basic (arithm\_basic)
```fift title="Fift"
MUL
```
#### `A900` ADDDIVMOD [#a900-adddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDDIVMOD
```
#### `A901` ADDDIVMODR [#a901-adddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDDIVMODR
```
#### `A902` ADDDIVMODC [#a902-adddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDDIVMODC
```
#### `A904` DIV [#a904-div]
`q=floor(x/y)`, `r=x-y*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIV
```
#### `A905` DIVR [#a905-divr]
`q'=round(x/y)`, `r'=x-y*q'`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIVR
```
#### `A906` DIVC [#a906-divc]
`q''=ceil(x/y)`, `r''=x-y*q''`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIVC
```
#### `A908` MOD [#a908-mod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MOD
```
#### `A909` MODR [#a909-modr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MODR
```
#### `A90A` MODC [#a90a-modc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MODC
```
#### `A90C` DIVMOD [#a90c-divmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIVMOD
```
#### `A90D` DIVMODR [#a90d-divmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIVMODR
```
#### `A90E` DIVMODC [#a90e-divmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
DIVMODC
```
#### `A920` ADDRSHIFTMOD\_VAR [#a920-addrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDRSHIFTMOD
```
#### `A921` ADDRSHIFTMODR [#a921-addrshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDRSHIFTMODR
```
#### `A922` ADDRSHIFTMODC [#a922-addrshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
ADDRSHIFTMODC
```
#### `A925` RSHIFTR\_VAR [#a925-rshiftr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
RSHIFTR
```
#### `A926` RSHIFTC\_VAR [#a926-rshiftc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
RSHIFTC
```
#### `A928` MODPOW2\_VAR [#a928-modpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MODPOW2
```
#### `A929` MODPOW2R\_VAR [#a929-modpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MODPOW2R
```
#### `A92A` MODPOW2C\_VAR [#a92a-modpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MODPOW2C
```
#### `A92C` RSHIFTMOD\_VAR [#a92c-rshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
RSHIFTMOD
```
#### `A92D` RSHIFTMODR\_VAR [#a92d-rshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
RSHIFTMODR
```
#### `A92E` RSHIFTMODC\_VAR [#a92e-rshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
RSHIFTMODC
```
#### `A930tt` ADDRSHIFTMOD [#a930tt-addrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] ADDRSHIFT#MOD
```
#### `A931tt` ADDRSHIFTRMOD [#a931tt-addrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] ADDRSHIFTR#MOD
```
#### `A932tt` ADDRSHIFTCMOD [#a932tt-addrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] ADDRSHIFTC#MOD
```
#### `A935tt` RSHIFTR [#a935tt-rshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] RSHIFTR#
```
#### `A936tt` RSHIFTC [#a936tt-rshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] RSHIFTC#
```
#### `A938tt` MODPOW2 [#a938tt-modpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MODPOW2#
```
#### `A939tt` MODPOW2R [#a939tt-modpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MODPOW2R#
```
#### `A93Att` MODPOW2C [#a93att-modpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MODPOW2C#
```
#### `A93Ctt` RSHIFTMOD [#a93ctt-rshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] RSHIFT#MOD
```
#### `A93Dtt` RSHIFTRMOD [#a93dtt-rshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] RSHIFTR#MOD
```
#### `A93Ett` RSHIFTCMOD [#a93ett-rshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] RSHIFTC#MOD
```
#### `A980` MULADDDIVMOD [#a980-muladddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDDIVMOD
```
#### `A981` MULADDDIVMODR [#a981-muladddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDDIVMODR
```
#### `A982` MULADDDIVMODC [#a982-muladddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDDIVMODC
```
#### `A984` MULDIV [#a984-muldiv]
`q=floor(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIV
```
#### `A985` MULDIVR [#a985-muldivr]
`q'=round(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIVR
```
#### `A986` MULDIVC [#a986-muldivc]
`q'=ceil(x*y/z)`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIVC
```
#### `A988` MULMOD [#a988-mulmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMOD
```
#### `A989` MULMODR [#a989-mulmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMODR
```
#### `A98A` MULMODC [#a98a-mulmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMODC
```
#### `A98C` MULDIVMOD [#a98c-muldivmod]
`q=floor(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIVMOD
```
#### `A98D` MULDIVMODR [#a98d-muldivmodr]
`q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIVMODR
```
#### `A98E` MULDIVMODC [#a98e-muldivmodc]
`q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULDIVMODC
```
#### `A9A0` MULADDRSHIFTMOD\_VAR [#a9a0-muladdrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDRSHIFTMOD
```
#### `A9A1` MULADDRSHIFTRMOD\_VAR [#a9a1-muladdrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDRSHIFTRMOD
```
#### `A9A2` MULADDRSHIFTCMOD\_VAR [#a9a2-muladdrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULADDRSHIFTCMOD
```
#### `A9A4` MULRSHIFT\_VAR [#a9a4-mulrshift_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFT
```
#### `A9A5` MULRSHIFTR\_VAR [#a9a5-mulrshiftr_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTR
```
#### `A9A6` MULRSHIFTC\_VAR [#a9a6-mulrshiftc_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTC
```
#### `A9A8` MULMODPOW2\_VAR [#a9a8-mulmodpow2_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMODPOW2_VAR
```
#### `A9A9` MULMODPOW2R\_VAR [#a9a9-mulmodpow2r_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMODPOW2R_VAR
```
#### `A9AA` MULMODPOW2C\_VAR [#a9aa-mulmodpow2c_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULMODPOW2C_VAR
```
#### `A9AC` MULRSHIFTMOD\_VAR [#a9ac-mulrshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTMOD_VAR
```
#### `A9AD` MULRSHIFTRMOD\_VAR [#a9ad-mulrshiftrmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTRMOD_VAR
```
#### `A9AE` MULRSHIFTCMOD\_VAR [#a9ae-mulrshiftcmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTCMOD_VAR
```
#### `A9B0tt` MULADDRSHIFTMOD [#a9b0tt-muladdrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULADDRSHIFT#MOD
```
#### `A9B1tt` MULADDRSHIFTRMOD [#a9b1tt-muladdrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULADDRSHIFTR#MOD
```
#### `A9B2tt` MULADDRSHIFTCMOD [#a9b2tt-muladdrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULADDRSHIFTC#MOD
```
#### `A9B4tt` MULRSHIFT [#a9b4tt-mulrshift]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULRSHIFT#
```
#### `A9B5tt` MULRSHIFTR [#a9b5tt-mulrshiftr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULRSHIFTR#
```
#### `A9B6tt` MULRSHIFTC [#a9b6tt-mulrshiftc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULRSHIFTC#
```
#### `A9B8tt` MULMODPOW2 [#a9b8tt-mulmodpow2]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULMODPOW2#
```
#### `A9B9tt` MULMODPOW2R [#a9b9tt-mulmodpow2r]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULMODPOW2R#
```
#### `A9BAtt` MULMODPOW2C [#a9batt-mulmodpow2c]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] MULMODPOW2C#
```
#### `A9BC` MULRSHIFTMOD [#a9bc-mulrshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFT#MOD
```
#### `A9BD` MULRSHIFTRMOD [#a9bd-mulrshiftrmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTR#MOD
```
#### `A9BE` MULRSHIFTCMOD [#a9be-mulrshiftcmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
MULRSHIFTC#MOD
```
#### `A9C0` LSHIFTADDDIVMOD\_VAR [#a9c0-lshiftadddivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTADDDIVMOD
```
#### `A9C1` LSHIFTADDDIVMODR\_VAR [#a9c1-lshiftadddivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTADDDIVMODR
```
#### `A9C2` LSHIFTADDDIVMODC\_VAR [#a9c2-lshiftadddivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTADDDIVMODC
```
#### `A9C4` LSHIFTDIV\_VAR [#a9c4-lshiftdiv_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIV
```
#### `A9C5` LSHIFTDIVR\_VAR [#a9c5-lshiftdivr_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIVR
```
#### `A9C6` LSHIFTDIVC\_VAR [#a9c6-lshiftdivc_var]
`0 <= z <= 256`
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIVC
```
#### `A9C8` LSHIFTMOD\_VAR [#a9c8-lshiftmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTMOD
```
#### `A9C9` LSHIFTMODR\_VAR [#a9c9-lshiftmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTMODR
```
#### `A9CA` LSHIFTMODC\_VAR [#a9ca-lshiftmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTMODC
```
#### `A9CC` LSHIFTDIVMOD\_VAR [#a9cc-lshiftdivmod_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIVMOD
```
#### `A9CD` LSHIFTDIVMODR\_VAR [#a9cd-lshiftdivmodr_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIVMODR
```
#### `A9CE` LSHIFTDIVMODC\_VAR [#a9ce-lshiftdivmodc_var]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
LSHIFTDIVMODC
```
#### `A9D0tt` LSHIFTADDDIVMOD [#a9d0tt-lshiftadddivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#ADDDIVMOD
```
#### `A9D1tt` LSHIFTADDDIVMODR [#a9d1tt-lshiftadddivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#ADDDIVMODR
```
#### `A9D2tt` LSHIFTADDDIVMODC [#a9d2tt-lshiftadddivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#ADDDIVMODC
```
#### `A9D4tt` LSHIFTDIV [#a9d4tt-lshiftdiv]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIV
```
#### `A9D5tt` LSHIFTDIVR [#a9d5tt-lshiftdivr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIVR
```
#### `A9D6tt` LSHIFTDIVC [#a9d6tt-lshiftdivc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIVC
```
#### `A9D8tt` LSHIFTMOD [#a9d8tt-lshiftmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#MOD
```
#### `A9D9tt` LSHIFTMODR [#a9d9tt-lshiftmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#MODR
```
#### `A9DAtt` LSHIFTMODC [#a9datt-lshiftmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#MODC
```
#### `A9DCtt` LSHIFTDIVMOD [#a9dctt-lshiftdivmod]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIVMOD
```
#### `A9DDtt` LSHIFTDIVMODR [#a9ddtt-lshiftdivmodr]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIVMODR
```
#### `A9DEtt` LSHIFTDIVMODC [#a9dett-lshiftdivmodc]
**Category:** Arithm Div (arithm\_div)
```fift title="Fift"
[tt+1] LSHIFT#DIVMODC
```
#### `AAcc` LSHIFT [#aacc-lshift]
`0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
[cc+1] LSHIFT#
```
#### `ABcc` RSHIFT [#abcc-rshift]
`0 <= cc <= 255`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
[cc+1] RSHIFT#
```
#### `AC` LSHIFT\_VAR [#ac-lshift_var]
`0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
LSHIFT
```
#### `AD` RSHIFT\_VAR [#ad-rshift_var]
`0 <= y <= 1023`
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
RSHIFT
```
#### `AE` POW2 [#ae-pow2]
`0 <= y <= 1023`
Equivalent to `ONE` `SWAP` `LSHIFT`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
POW2
```
#### `B0` AND [#b0-and]
Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
AND
```
#### `B1` OR [#b1-or]
Bitwise or of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
OR
```
#### `B2` XOR [#b2-xor]
Bitwise xor of two integers.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
XOR
```
#### `B3` NOT [#b3-not]
Bitwise not of an integer.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
NOT
```
#### `B4cc` FITS [#b4cc-fits]
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).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
[cc+1] FITS
```
**Aliases**:
* `CHKBOOL`
Checks whether `x` is a ''boolean value'' (i.e., either 0 or -1).
#### `B5cc` UFITS [#b5cc-ufits]
Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
[cc+1] UFITS
```
**Aliases**:
* `CHKBIT`
Checks whether `x` is a binary digit (i.e., zero or one).
#### `B600` FITSX [#b600-fitsx]
Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
FITSX
```
#### `B601` UFITSX [#b601-ufitsx]
Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
UFITSX
```
#### `B602` BITSIZE [#b602-bitsize]
Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
BITSIZE
```
#### `B603` UBITSIZE [#b603-ubitsize]
Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
UBITSIZE
```
#### `B608` MIN [#b608-min]
Computes the minimum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
MIN
```
#### `B609` MAX [#b609-max]
Computes the maximum of two integers `x` and `y`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
MAX
```
#### `B60A` MINMAX [#b60a-minmax]
Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
MINMAX
INTSORT2
```
#### `B60B` ABS [#b60b-abs]
Computes the absolute value of an integer `x`.
**Category:** Arithm Logical (arithm\_logical)
```fift title="Fift"
ABS
```
#### `B7A0` QADD [#b7a0-qadd]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADD
```
#### `B7A1` QSUB [#b7a1-qsub]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QSUB
```
#### `B7A2` QSUBR [#b7a2-qsubr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QSUBR
```
#### `B7A3` QNEGATE [#b7a3-qnegate]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QNEGATE
```
#### `B7A4` QINC [#b7a4-qinc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QINC
```
#### `B7A5` QDEC [#b7a5-qdec]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDEC
```
#### `B7A8` QMUL [#b7a8-qmul]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMUL
```
#### `B7A900` QADDDIVMOD [#b7a900-qadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDDIVMOD
```
#### `B7A901` QADDDIVMODR [#b7a901-qadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDDIVMODR
```
#### `B7A902` QADDDIVMODC [#b7a902-qadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDDIVMODC
```
#### `B7A904` QDIV [#b7a904-qdiv]
Division returns `NaN` if `y=0`.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIV
```
#### `B7A905` QDIVR [#b7a905-qdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIVR
```
#### `B7A906` QDIVC [#b7a906-qdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIVC
```
#### `B7A908` QMOD [#b7a908-qmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMOD
```
#### `B7A909` QMODR [#b7a909-qmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMODR
```
#### `B7A90A` QMODC [#b7a90a-qmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMODC
```
#### `B7A90C` QDIVMOD [#b7a90c-qdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIVMOD
```
#### `B7A90D` QDIVMODR [#b7a90d-qdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIVMODR
```
#### `B7A90E` QDIVMODC [#b7a90e-qdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QDIVMODC
```
#### `B7A920` QADDRSHIFTMOD [#b7a920-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDRSHIFTMOD
```
#### `B7A921` QADDRSHIFTMODR [#b7a921-qaddrshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDRSHIFTMODR
```
#### `B7A922` QADDRSHIFTMODC [#b7a922-qaddrshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QADDRSHIFTMODC
```
#### `B7A925` QRSHIFTR\_VAR [#b7a925-qrshiftr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFTR
```
#### `B7A926` QRSHIFTC\_VAR [#b7a926-qrshiftc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFTC
```
#### `B7A928` QMODPOW2\_VAR [#b7a928-qmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMODPOW2
```
#### `B7A929` QMODPOW2R\_VAR [#b7a929-qmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMODPOW2R
```
#### `B7A92A` QMODPOW2C\_VAR [#b7a92a-qmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMODPOW2C
```
#### `B7A92C` QRSHIFTMOD\_VAR [#b7a92c-qrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFTMOD
```
#### `B7A92D` QRSHIFTMODR\_VAR [#b7a92d-qrshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFTMODR
```
#### `B7A92E` QRSHIFTMODC\_VAR [#b7a92e-qrshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFTMODC
```
#### `B7A930tt` QADDRSHIFTMOD [#b7a930tt-qaddrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QADDRSHIFT#MOD
```
#### `B7A931tt` QADDRSHIFTRMOD [#b7a931tt-qaddrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QADDRSHIFTR#MOD
```
#### `B7A932tt` QADDRSHIFTCMOD [#b7a932tt-qaddrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QADDRSHIFTC#MOD
```
#### `B7A935tt` QRSHIFTR [#b7a935tt-qrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QRSHIFTR#
```
#### `B7A936tt` QRSHIFTC [#b7a936tt-qrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QRSHIFTC#
```
#### `B7A938tt` QMODPOW2 [#b7a938tt-qmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMODPOW2#
```
#### `B7A939tt` QMODPOW2R [#b7a939tt-qmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMODPOW2R#
```
#### `B7A93Att` QMODPOW2C [#b7a93att-qmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMODPOW2C#
```
#### `B7A93Ctt` QRSHIFTMOD [#b7a93ctt-qrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QRSHIFT#MOD
```
#### `B7A93Dtt` QRSHIFTRMOD [#b7a93dtt-qrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QRSHIFTR#MOD
```
#### `B7A93Ett` QRSHIFTCMOD [#b7a93ett-qrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QRSHIFTC#MOD
```
#### `B7A980` QMULADDDIVMOD [#b7a980-qmuladddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDDIVMOD
```
#### `B7A981` QMULADDDIVMODR [#b7a981-qmuladddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDDIVMODR
```
#### `B7A982` QMULADDDIVMODC [#b7a982-qmuladddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDDIVMODC
```
#### `B7A984` QMULDIV [#b7a984-qmuldiv]
`q=floor(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIV
```
#### `B7A985` QMULDIVR [#b7a985-qmuldivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIVR
```
#### `B7A986` QMULDIVC [#b7a986-qmuldivc]
`q'=ceil(x*y/z)`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIVC
```
#### `B7A988` QMULMOD [#b7a988-qmulmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMOD
```
#### `B7A989` QMULMODR [#b7a989-qmulmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMODR
```
#### `B7A98A` QMULMODC [#b7a98a-qmulmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMODC
```
#### `B7A98C` QMULDIVMOD [#b7a98c-qmuldivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIVMOD
```
#### `B7A98D` QMULDIVMODR [#b7a98d-qmuldivmodr]
`q=round(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIVMODR
```
#### `B7A98E` QMULDIVMODC [#b7a98e-qmuldivmodc]
`q=ceil(x*y/z)`, `r=x*y-z*q`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULDIVMODC
```
#### `B7A9A0` QMULADDRSHIFTMOD\_VAR [#b7a9a0-qmuladdrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDRSHIFTMOD
```
#### `B7A9A1` QMULADDRSHIFTRMOD\_VAR [#b7a9a1-qmuladdrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDRSHIFTRMOD
```
#### `B7A9A2` QMULADDRSHIFTCMOD\_VAR [#b7a9a2-qmuladdrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULADDRSHIFTCMOD
```
#### `B7A9A4` QMULRSHIFT\_VAR [#b7a9a4-qmulrshift_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFT
```
#### `B7A9A5` QMULRSHIFTR\_VAR [#b7a9a5-qmulrshiftr_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTR
```
#### `B7A9A6` QMULRSHIFTC\_VAR [#b7a9a6-qmulrshiftc_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTC
```
#### `B7A9A8` QMULMODPOW2\_VAR [#b7a9a8-qmulmodpow2_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMODPOW2_VAR
```
#### `B7A9A9` QMULMODPOW2R\_VAR [#b7a9a9-qmulmodpow2r_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMODPOW2R_VAR
```
#### `B7A9AA` QMULMODPOW2C\_VAR [#b7a9aa-qmulmodpow2c_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULMODPOW2C_VAR
```
#### `B7A9AC` QMULRSHIFTMOD\_VAR [#b7a9ac-qmulrshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTMOD_VAR
```
#### `B7A9AD` QMULRSHIFTRMOD\_VAR [#b7a9ad-qmulrshiftrmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTRMOD_VAR
```
#### `B7A9AE` QMULRSHIFTCMOD\_VAR [#b7a9ae-qmulrshiftcmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTCMOD_VAR
```
#### `B7A9B0tt` QMULADDRSHIFTMOD [#b7a9b0tt-qmuladdrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULADDRSHIFT#MOD
```
#### `B7A9B1tt` QMULADDRSHIFTRMOD [#b7a9b1tt-qmuladdrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULADDRSHIFTR#MOD
```
#### `B7A9B2tt` QMULADDRSHIFTCMOD [#b7a9b2tt-qmuladdrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULADDRSHIFTC#MOD
```
#### `B7A9B4tt` QMULRSHIFT [#b7a9b4tt-qmulrshift]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULRSHIFT#
```
#### `B7A9B5tt` QMULRSHIFTR [#b7a9b5tt-qmulrshiftr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULRSHIFTR#
```
#### `B7A9B6tt` QMULRSHIFTC [#b7a9b6tt-qmulrshiftc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULRSHIFTC#
```
#### `B7A9B8tt` QMULMODPOW2 [#b7a9b8tt-qmulmodpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULMODPOW2#
```
#### `B7A9B9tt` QMULMODPOW2R [#b7a9b9tt-qmulmodpow2r]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULMODPOW2R#
```
#### `B7A9BAtt` QMULMODPOW2C [#b7a9batt-qmulmodpow2c]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QMULMODPOW2C#
```
#### `B7A9BC` QMULRSHIFTMOD [#b7a9bc-qmulrshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFT#MOD
```
#### `B7A9BD` QMULRSHIFTRMOD [#b7a9bd-qmulrshiftrmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTR#MOD
```
#### `B7A9BE` QMULRSHIFTCMOD [#b7a9be-qmulrshiftcmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QMULRSHIFTC#MOD
```
#### `B7A9C0` QLSHIFTADDDIVMOD\_VAR [#b7a9c0-qlshiftadddivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTADDDIVMOD
```
#### `B7A9C1` QLSHIFTADDDIVMODR\_VAR [#b7a9c1-qlshiftadddivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTADDDIVMODR
```
#### `B7A9C2` QLSHIFTADDDIVMODC\_VAR [#b7a9c2-qlshiftadddivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTADDDIVMODC
```
#### `B7A9C4` QLSHIFTDIV\_VAR [#b7a9c4-qlshiftdiv_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIV
```
#### `B7A9C5` QLSHIFTDIVR\_VAR [#b7a9c5-qlshiftdivr_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIVR
```
#### `B7A9C6` QLSHIFTDIVC\_VAR [#b7a9c6-qlshiftdivc_var]
`0 <= z <= 256`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIVC
```
#### `B7A9C8` QLSHIFTMOD\_VAR [#b7a9c8-qlshiftmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTMOD
```
#### `B7A9C9` QLSHIFTMODR\_VAR [#b7a9c9-qlshiftmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTMODR
```
#### `B7A9CA` QLSHIFTMODC\_VAR [#b7a9ca-qlshiftmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTMODC
```
#### `B7A9CC` QLSHIFTDIVMOD\_VAR [#b7a9cc-qlshiftdivmod_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIVMOD
```
#### `B7A9CD` QLSHIFTDIVMODR\_VAR [#b7a9cd-qlshiftdivmodr_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIVMODR
```
#### `B7A9CE` QLSHIFTDIVMODC\_VAR [#b7a9ce-qlshiftdivmodc_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFTDIVMODC
```
#### `B7A9D0tt` QLSHIFTADDDIVMOD [#b7a9d0tt-qlshiftadddivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#ADDDIVMOD
```
#### `B7A9D1tt` QLSHIFTADDDIVMODR [#b7a9d1tt-qlshiftadddivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#ADDDIVMODR
```
#### `B7A9D2tt` QLSHIFTADDDIVMODC [#b7a9d2tt-qlshiftadddivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#ADDDIVMODC
```
#### `B7A9D4tt` QLSHIFTDIV [#b7a9d4tt-qlshiftdiv]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIV
```
#### `B7A9D5tt` QLSHIFTDIVR [#b7a9d5tt-qlshiftdivr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIVR
```
#### `B7A9D6tt` QLSHIFTDIVC [#b7a9d6tt-qlshiftdivc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIVC
```
#### `B7A9D8tt` QLSHIFTMOD [#b7a9d8tt-qlshiftmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#MOD
```
#### `B7A9D9tt` QLSHIFTMODR [#b7a9d9tt-qlshiftmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#MODR
```
#### `B7A9DAtt` QLSHIFTMODC [#b7a9datt-qlshiftmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#MODC
```
#### `B7A9DCtt` QLSHIFTDIVMOD [#b7a9dctt-qlshiftdivmod]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIVMOD
```
#### `B7A9DDtt` QLSHIFTDIVMODR [#b7a9ddtt-qlshiftdivmodr]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIVMODR
```
#### `B7A9DEtt` QLSHIFTDIVMODC [#b7a9dett-qlshiftdivmodc]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[tt+1] QLSHIFT#DIVMODC
```
#### `B7AAcc` QLSHIFT [#b7aacc-qlshift]
`0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[cc+1] QLSHIFT#
```
#### `B7ABcc` QRSHIFT [#b7abcc-qrshift]
`0 <= cc <= 255`
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[cc+1] QRSHIFT#
```
#### `B7AC` QLSHIFT\_VAR [#b7ac-qlshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QLSHIFT
```
#### `B7AD` QRSHIFT\_VAR [#b7ad-qrshift_var]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QRSHIFT
```
#### `B7AE` QPOW2 [#b7ae-qpow2]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QPOW2
```
#### `B7B0` QAND [#b7b0-qand]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QAND
```
#### `B7B1` QOR [#b7b1-qor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QOR
```
#### `B7B2` QXOR [#b7b2-qxor]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QXOR
```
#### `B7B3` QNOT [#b7b3-qnot]
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QNOT
```
#### `B7B4cc` QFITS [#b7b4cc-qfits]
Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[cc+1] QFITS
```
#### `B7B5cc` QUFITS [#b7b5cc-qufits]
Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
[cc+1] QUFITS
```
#### `B7B600` QFITSX [#b7b600-qfitsx]
Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QFITSX
```
#### `B7B601` QUFITSX [#b7b601-qufitsx]
Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.
**Category:** Arithm Quiet (arithm\_quiet)
```fift title="Fift"
QUFITSX
```
#### `B8` SGN [#b8-sgn]
Computes the sign of an integer `x`:
`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
SGN
```
#### `B9` LESS [#b9-less]
Returns `-1` if `x
**Category:** Compare Int (compare\_int)
```fift title="Fift"
LESS
```
#### `BA` EQUAL [#ba-equal]
Returns `-1` if `x=y`, `0` otherwise.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
EQUAL
```
#### `BB` LEQ [#bb-leq]
**Category:** Compare Int (compare\_int)
```fift title="Fift"
LEQ
```
#### `BC` GREATER [#bc-greater]
**Category:** Compare Int (compare\_int)
```fift title="Fift"
GREATER
```
#### `BD` NEQ [#bd-neq]
Equivalent to `EQUAL` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
NEQ
```
#### `BE` GEQ [#be-geq]
Equivalent to `LESS` `NOT`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
GEQ
```
#### `BF` CMP [#bf-cmp]
Computes the sign of `x-y`:
`-1` if `xy`.
No integer overflow can occur here unless `x` or `y` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
CMP
```
#### `C0yy` EQINT [#c0yy-eqint]
Returns `-1` if `x=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
[yy] EQINT
```
**Aliases**:
* `ISZERO`
Checks whether an integer is zero. Corresponds to Forth's `0=`.
#### `C1yy` LESSINT [#c1yy-lessint]
Returns `-1` if `x`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
[yy] LESSINT
[yy-1] LEQINT
```
**Aliases**:
* `ISNEG`
Checks whether an integer is negative. Corresponds to Forth's `0<`.
* `ISNPOS`
Checks whether an integer is non-positive.
#### `C2yy` GTINT [#c2yy-gtint]
Returns `-1` if `x>yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
[yy] GTINT
[yy+1] GEQINT
```
**Aliases**:
* `ISPOS`
Checks whether an integer is positive. Corresponds to Forth's `0>`.
* `ISNNEG`
Checks whether an integer is non-negative.
#### `C3yy` NEQINT [#c3yy-neqint]
Returns `-1` if `x!=yy`, `0` otherwise.
`-2^7 <= yy < 2^7`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
[yy] NEQINT
```
#### `C4` ISNAN [#c4-isnan]
Checks whether `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
ISNAN
```
#### `C5` CHKNAN [#c5-chknan]
Throws an arithmetic overflow exception if `x` is a `NaN`.
**Category:** Compare Int (compare\_int)
```fift title="Fift"
CHKNAN
```
#### `C700` SEMPTY [#c700-sempty]
Checks whether a *Slice* `s` is empty (i.e., contains no bits of data and no cell references).
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SEMPTY
```
#### `C701` SDEMPTY [#c701-sdempty]
Checks whether *Slice* `s` has no bits of data.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDEMPTY
```
#### `C702` SREMPTY [#c702-srempty]
Checks whether *Slice* `s` has no references.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SREMPTY
```
#### `C703` SDFIRST [#c703-sdfirst]
Checks whether the first bit of *Slice* `s` is a one.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDFIRST
```
#### `C704` SDLEXCMP [#c704-sdlexcmp]
Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDLEXCMP
```
#### `C705` SDEQ [#c705-sdeq]
Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDEQ
```
#### `C708` SDPFX [#c708-sdpfx]
Checks whether `s` is a prefix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPFX
```
#### `C709` SDPFXREV [#c709-sdpfxrev]
Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPFXREV
```
#### `C70A` SDPPFX [#c70a-sdppfx]
Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPPFX
```
#### `C70B` SDPPFXREV [#c70b-sdppfxrev]
Checks whether `s'` is a proper prefix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPPFXREV
```
#### `C70C` SDSFX [#c70c-sdsfx]
Checks whether `s` is a suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDSFX
```
#### `C70D` SDSFXREV [#c70d-sdsfxrev]
Checks whether `s'` is a suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDSFXREV
```
#### `C70E` SDPSFX [#c70e-sdpsfx]
Checks whether `s` is a proper suffix of `s'`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPSFX
```
#### `C70F` SDPSFXREV [#c70f-sdpsfxrev]
Checks whether `s'` is a proper suffix of `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDPSFXREV
```
#### `C710` SDCNTLEAD0 [#c710-sdcntlead0]
Returns the number of leading zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDCNTLEAD0
```
#### `C711` SDCNTLEAD1 [#c711-sdcntlead1]
Returns the number of leading ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDCNTLEAD1
```
#### `C712` SDCNTTRAIL0 [#c712-sdcnttrail0]
Returns the number of trailing zeroes in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDCNTTRAIL0
```
#### `C713` SDCNTTRAIL1 [#c713-sdcnttrail1]
Returns the number of trailing ones in `s`.
**Category:** Compare Other (compare\_other)
```fift title="Fift"
SDCNTTRAIL1
```
#### `C8` NEWC [#c8-newc]
Creates a new empty *Builder*.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
NEWC
```
#### `C9` ENDC [#c9-endc]
Converts a *Builder* into an ordinary *Cell*.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
ENDC
```
#### `CAcc` STI [#cacc-sti]
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.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STI
```
#### `CBcc` STU [#cbcc-stu]
Stores an unsigned `cc+1`-bit integer `x` into *Builder* `b`. In all other respects it is similar to `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STU
```
#### `CC` STREF [#cc-stref]
Stores a reference to *Cell* `c` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STREF
```
#### `CD` STBREFR [#cd-stbrefr]
Equivalent to `ENDC` `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBREFR
ENDCST
```
#### `CE` STSLICE [#ce-stslice]
Stores *Slice* `s` into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSLICE
```
**Aliases**:
* `STDICTS`
Stores a *Slice*-represented dictionary `s` into *Builder* `b`.
It is actually a synonym for `STSLICE`.
#### `CF00` STIX [#cf00-stix]
Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STIX
```
#### `CF01` STUX [#cf01-stux]
Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STUX
```
#### `CF02` STIXR [#cf02-stixr]
Similar to `STIX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STIXR
```
#### `CF03` STUXR [#cf03-stuxr]
Similar to `STUX`, but with arguments in a different order.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STUXR
```
#### `CF04` STIXQ [#cf04-stixq]
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.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STIXQ
```
#### `CF05` STUXQ [#cf05-stuxq]
A quiet version of `STUX`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STUXQ
```
#### `CF06` STIXRQ [#cf06-stixrq]
A quiet version of `STIXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STIXRQ
```
#### `CF07` STUXRQ [#cf07-stuxrq]
A quiet version of `STUXR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STUXRQ
```
#### `CF08cc` STI\_ALT [#cf08cc-sti_alt]
A longer version of `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STI_l
```
#### `CF09cc` STU\_ALT [#cf09cc-stu_alt]
A longer version of `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STU_l
```
#### `CF0Acc` STIR [#cf0acc-stir]
Equivalent to `SWAP` `[cc+1] STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STIR
```
#### `CF0Bcc` STUR [#cf0bcc-stur]
Equivalent to `SWAP` `[cc+1] STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STUR
```
#### `CF0Ccc` STIQ [#cf0ccc-stiq]
A quiet version of `STI`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STIQ
```
#### `CF0Dcc` STUQ [#cf0dcc-stuq]
A quiet version of `STU`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STUQ
```
#### `CF0Ecc` STIRQ [#cf0ecc-stirq]
A quiet version of `STIR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STIRQ
```
#### `CF0Fcc` STURQ [#cf0fcc-sturq]
A quiet version of `STUR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] STURQ
```
#### `CF10` STREF\_ALT [#cf10-stref_alt]
A longer version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STREF_l
```
#### `CF11` STBREF [#cf11-stbref]
Equivalent to `SWAP` `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBREF
```
#### `CF12` STSLICE\_ALT [#cf12-stslice_alt]
A longer version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSLICE_l
```
#### `CF13` STB [#cf13-stb]
Appends all data from *Builder* `b'` to *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STB
```
#### `CF14` STREFR [#cf14-strefr]
Equivalent to `SWAP` `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STREFR
```
#### `CF15` STBREFR\_ALT [#cf15-stbrefr_alt]
A longer encoding of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBREFR_l
```
#### `CF16` STSLICER [#cf16-stslicer]
Equivalent to `SWAP` `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSLICER
```
#### `CF17` STBR [#cf17-stbr]
Concatenates two builders.
Equivalent to `SWAP` `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBR
BCONCAT
```
#### `CF18` STREFQ [#cf18-strefq]
Quiet version of `STREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STREFQ
```
#### `CF19` STBREFQ [#cf19-stbrefq]
Quiet version of `STBREF`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBREFQ
```
#### `CF1A` STSLICEQ [#cf1a-stsliceq]
Quiet version of `STSLICE`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSLICEQ
```
#### `CF1B` STBQ [#cf1b-stbq]
Quiet version of `STB`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBQ
```
#### `CF1C` STREFRQ [#cf1c-strefrq]
Quiet version of `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STREFRQ
```
#### `CF1D` STBREFRQ [#cf1d-stbrefrq]
Quiet version of `STBREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBREFRQ
```
#### `CF1E` STSLICERQ [#cf1e-stslicerq]
Quiet version of `STSLICER`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSLICERQ
```
#### `CF1F` STBRQ [#cf1f-stbrq]
Quiet version of `STBR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STBRQ
BCONCATQ
```
#### `CF20` STREFCONST [#cf20-strefconst]
Equivalent to `PUSHREF` `STREFR`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[ref] STREFCONST
```
#### `CF21` STREF2CONST [#cf21-stref2const]
Equivalent to `STREFCONST` `STREFCONST`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[ref] [ref] STREF2CONST
```
#### `CF23` ENDXC [#cf23-endxc]
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.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
ENDXC
```
#### `CF28` STILE4 [#cf28-stile4]
Stores a little-endian signed 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STILE4
```
#### `CF29` STULE4 [#cf29-stule4]
Stores a little-endian unsigned 32-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STULE4
```
#### `CF2A` STILE8 [#cf2a-stile8]
Stores a little-endian signed 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STILE8
```
#### `CF2B` STULE8 [#cf2b-stule8]
Stores a little-endian unsigned 64-bit integer.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STULE8
```
#### `CF30` BDEPTH [#cf30-bdepth]
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`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BDEPTH
```
#### `CF31` BBITS [#cf31-bbits]
Returns the number of data bits already stored in *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BBITS
```
#### `CF32` BREFS [#cf32-brefs]
Returns the number of cell references already stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BREFS
```
#### `CF33` BBITREFS [#cf33-bbitrefs]
Returns the numbers of both data bits and cell references in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BBITREFS
```
#### `CF35` BREMBITS [#cf35-brembits]
Returns the number of data bits that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BREMBITS
```
#### `CF36` BREMREFS [#cf36-bremrefs]
Returns the number of references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BREMREFS
```
#### `CF37` BREMBITREFS [#cf37-brembitrefs]
Returns the numbers of both data bits and references that can still be stored in `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BREMBITREFS
```
#### `CF38cc` BCHKBITS [#cf38cc-bchkbits]
Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] BCHKBITS#
```
#### `CF39` BCHKBITS\_VAR [#cf39-bchkbits_var]
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.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKBITS
```
#### `CF3A` BCHKREFS [#cf3a-bchkrefs]
Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKREFS
```
#### `CF3B` BCHKBITREFS [#cf3b-bchkbitrefs]
Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKBITREFS
```
#### `CF3Ccc` BCHKBITSQ [#cf3ccc-bchkbitsq]
Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[cc+1] BCHKBITSQ#
```
#### `CF3D` BCHKBITSQ\_VAR [#cf3d-bchkbitsq_var]
Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKBITSQ
```
#### `CF3E` BCHKREFSQ [#cf3e-bchkrefsq]
Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKREFSQ
```
#### `CF3F` BCHKBITREFSQ [#cf3f-bchkbitrefsq]
Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BCHKBITREFSQ
```
#### `CF40` STZEROES [#cf40-stzeroes]
Stores `n` binary zeroes into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STZEROES
```
#### `CF41` STONES [#cf41-stones]
Stores `n` binary ones into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STONES
```
#### `CF42` STSAME [#cf42-stsame]
Stores `n` binary `x`es (`0 <= x <= 1`) into *Builder* `b`.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
STSAME
```
#### `CF50` BTOS [#cf50-btos]
Same as `ENDC CTOS`, but without gas cost for cell creation and loading.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
BTOS
```
#### `CFC_xysss` STSLICECONST [#cfc_xysss-stsliceconst]
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.
**Category:** Cell Build (cell\_build)
```fift title="Fift"
[slice] STSLICECONST
```
**Aliases**:
* `STZERO`
Stores one binary zero.
* `STONE`
Stores one binary one.
#### `D0` CTOS [#d0-ctos]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CTOS
```
#### `D1` ENDS [#d1-ends]
Removes a *Slice* `s` from the stack, and throws an exception if it is not empty.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
ENDS
```
#### `D2cc` LDI [#d2cc-ldi]
Loads (i.e., parses) a signed `cc+1`-bit integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDI
```
#### `D3cc` LDU [#d3cc-ldu]
Loads an unsigned `cc+1`-bit integer `x` from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDU
```
#### `D4` LDREF [#d4-ldref]
Loads a cell reference `c` from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDREF
```
#### `D5` LDREFRTOS [#d5-ldrefrtos]
Equivalent to `LDREF` `SWAP` `CTOS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDREFRTOS
```
#### `D6cc` LDSLICE [#d6cc-ldslice]
Cuts the next `cc+1` bits of `s` into a separate *Slice* `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDSLICE
```
#### `D700` LDIX [#d700-ldix]
Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from *Slice* `s`, and returns the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDIX
```
#### `D701` LDUX [#d701-ldux]
Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDUX
```
#### `D702` PLDIX [#d702-pldix]
Preloads a signed `l`-bit integer from *Slice* `s`, for `0 <= l <= 257`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDIX
```
#### `D703` PLDUX [#d703-pldux]
Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDUX
```
#### `D704` LDIXQ [#d704-ldixq]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDIXQ
```
#### `D705` LDUXQ [#d705-lduxq]
Quiet version of `LDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDUXQ
```
#### `D706` PLDIXQ [#d706-pldixq]
Quiet version of `PLDIX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDIXQ
```
#### `D707` PLDUXQ [#d707-plduxq]
Quiet version of `PLDUX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDUXQ
```
#### `D708cc` LDI\_ALT [#d708cc-ldi_alt]
A longer encoding for `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDI_l
```
#### `D709cc` LDU\_ALT [#d709cc-ldu_alt]
A longer encoding for `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDU_l
```
#### `D70Acc` PLDI [#d70acc-pldi]
Preloads a signed `cc+1`-bit integer from *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDI
```
#### `D70Bcc` PLDU [#d70bcc-pldu]
Preloads an unsigned `cc+1`-bit integer from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDU
```
#### `D70Ccc` LDIQ [#d70ccc-ldiq]
A quiet version of `LDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDIQ
```
#### `D70Dcc` LDUQ [#d70dcc-lduq]
A quiet version of `LDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDUQ
```
#### `D70Ecc` PLDIQ [#d70ecc-pldiq]
A quiet version of `PLDI`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDIQ
```
#### `D70Fcc` PLDUQ [#d70fcc-plduq]
A quiet version of `PLDU`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDUQ
```
#### `D714_c` PLDUZ [#d714_c-plduz]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[32(c+1)] PLDUZ
```
#### `D718` LDSLICEX [#d718-ldslicex]
Loads the first `0 <= l <= 1023` bits from *Slice* `s` into a separate *Slice* `s''`, returning the remainder of `s` as `s'`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDSLICEX
```
#### `D719` PLDSLICEX [#d719-pldslicex]
Returns the first `0 <= l <= 1023` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDSLICEX
```
#### `D71A` LDSLICEXQ [#d71a-ldslicexq]
A quiet version of `LDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDSLICEXQ
```
#### `D71B` PLDSLICEXQ [#d71b-pldslicexq]
A quiet version of `LDSLICEXQ`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDSLICEXQ
```
#### `D71Ccc` LDSLICE\_ALT [#d71ccc-ldslice_alt]
A longer encoding for `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDSLICE_l
```
#### `D71Dcc` PLDSLICE [#d71dcc-pldslice]
Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDSLICE
```
#### `D71Ecc` LDSLICEQ [#d71ecc-ldsliceq]
A quiet version of `LDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] LDSLICEQ
```
#### `D71Fcc` PLDSLICEQ [#d71fcc-pldsliceq]
A quiet version of `PLDSLICE`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[cc+1] PLDSLICEQ
```
#### `D720` SDCUTFIRST [#d720-sdcutfirst]
Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDCUTFIRST
```
#### `D721` SDSKIPFIRST [#d721-sdskipfirst]
Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDSKIPFIRST
```
#### `D722` SDCUTLAST [#d722-sdcutlast]
Returns the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDCUTLAST
```
#### `D723` SDSKIPLAST [#d723-sdskiplast]
Returns all but the last `0 <= l <= 1023` bits of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDSKIPLAST
```
#### `D724` SDSUBSTR [#d724-sdsubstr]
Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDSUBSTR
```
#### `D726` SDBEGINSX [#d726-sdbeginsx]
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`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDBEGINSX
```
#### `D727` SDBEGINSXQ [#d727-sdbeginsxq]
A quiet version of `SDBEGINSX`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDBEGINSXQ
```
#### `D72A_xsss` SDBEGINS [#d72a_xsss-sdbegins]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[slice] SDBEGINS
```
#### `D72E_xsss` SDBEGINSQ [#d72e_xsss-sdbeginsq]
A quiet version of `SDBEGINS`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[slice] SDBEGINSQ
```
#### `D730` SCUTFIRST [#d730-scutfirst]
Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCUTFIRST
```
#### `D731` SSKIPFIRST [#d731-sskipfirst]
Returns all but the first `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SSKIPFIRST
```
#### `D732` SCUTLAST [#d732-scutlast]
Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCUTLAST
```
#### `D733` SSKIPLAST [#d733-sskiplast]
Returns all but the last `l` bits of `s` and `r` references of `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SSKIPLAST
```
#### `D734` SUBSLICE [#d734-subslice]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SUBSLICE
```
#### `D736` SPLIT [#d736-split]
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''`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SPLIT
```
#### `D737` SPLITQ [#d737-splitq]
A quiet version of `SPLIT`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SPLITQ
```
#### `D739` XCTOS [#d739-xctos]
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`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
XCTOS
```
#### `D73A` XLOAD [#d73a-xload]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
XLOAD
```
#### `D73B` XLOADQ [#d73b-xloadq]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
XLOADQ
```
#### `D741` SCHKBITS [#d741-schkbits]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKBITS
```
#### `D742` SCHKREFS [#d742-schkrefs]
Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKREFS
```
#### `D743` SCHKBITREFS [#d743-schkbitrefs]
Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKBITREFS
```
#### `D745` SCHKBITSQ [#d745-schkbitsq]
Checks whether there are at least `l` data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKBITSQ
```
#### `D746` SCHKREFSQ [#d746-schkrefsq]
Checks whether there are at least `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKREFSQ
```
#### `D747` SCHKBITREFSQ [#d747-schkbitrefsq]
Checks whether there are at least `l` data bits and `r` references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SCHKBITREFSQ
```
#### `D748` PLDREFVAR [#d748-pldrefvar]
Returns the `n`-th cell reference of *Slice* `s` for `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDREFVAR
```
#### `D749` SBITS [#d749-sbits]
Returns the number of data bits in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SBITS
```
#### `D74A` SREFS [#d74a-srefs]
Returns the number of references in *Slice* `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SREFS
```
#### `D74B` SBITREFS [#d74b-sbitrefs]
Returns both the number of data bits and the number of references in `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SBITREFS
```
#### `D74E_n` PLDREFIDX [#d74e_n-pldrefidx]
Returns the `n`-th cell reference of *Slice* `s`, where `0 <= n <= 3`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[n] PLDREFIDX
```
**Aliases**:
* `PLDREF`
Preloads the first cell reference of a *Slice*.
#### `D750` LDILE4 [#d750-ldile4]
Loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDILE4
```
#### `D751` LDULE4 [#d751-ldule4]
Loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDULE4
```
#### `D752` LDILE8 [#d752-ldile8]
Loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDILE8
```
#### `D753` LDULE8 [#d753-ldule8]
Loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDULE8
```
#### `D754` PLDILE4 [#d754-pldile4]
Preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDILE4
```
#### `D755` PLDULE4 [#d755-pldule4]
Preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDULE4
```
#### `D756` PLDILE8 [#d756-pldile8]
Preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDILE8
```
#### `D757` PLDULE8 [#d757-pldule8]
Preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDULE8
```
#### `D758` LDILE4Q [#d758-ldile4q]
Quietly loads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDILE4Q
```
#### `D759` LDULE4Q [#d759-ldule4q]
Quietly loads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDULE4Q
```
#### `D75A` LDILE8Q [#d75a-ldile8q]
Quietly loads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDILE8Q
```
#### `D75B` LDULE8Q [#d75b-ldule8q]
Quietly loads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDULE8Q
```
#### `D75C` PLDILE4Q [#d75c-pldile4q]
Quietly preloads a little-endian signed 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDILE4Q
```
#### `D75D` PLDULE4Q [#d75d-pldule4q]
Quietly preloads a little-endian unsigned 32-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDULE4Q
```
#### `D75E` PLDILE8Q [#d75e-pldile8q]
Quietly preloads a little-endian signed 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDILE8Q
```
#### `D75F` PLDULE8Q [#d75f-pldule8q]
Quietly preloads a little-endian unsigned 64-bit integer.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
PLDULE8Q
```
#### `D760` LDZEROES [#d760-ldzeroes]
Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDZEROES
```
#### `D761` LDONES [#d761-ldones]
Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDONES
```
#### `D762` LDSAME [#d762-ldsame]
Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
LDSAME
```
#### `D764` SDEPTH [#d764-sdepth]
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`.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
SDEPTH
```
#### `D765` CDEPTH [#d765-cdepth]
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.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CDEPTH
```
#### `D766` CLEVEL [#d766-clevel]
Returns level of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CLEVEL
```
#### `D767` CLEVELMASK [#d767-clevelmask]
Returns level mask of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CLEVELMASK
```
#### `D76A_` CHASHI [#d76a_-chashi]
Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[i] CHASHI
```
#### `D76E_` CDEPTHI [#d76e_-cdepthi]
Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
[i] CDEPTHI
```
#### `D770` CHASHIX [#d770-chashix]
Returns `i`th hash of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CHASHIX
```
#### `D771` CDEPTHIX [#d771-cdepthix]
Returns `i`th depth of the cell.
**Category:** Cell Parse (cell\_parse)
```fift title="Fift"
CDEPTHIX
```
#### `D8` EXECUTE [#d8-execute]
*Calls*, or *executes*, continuation `c`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
EXECUTE
CALLX
```
#### `D9` JMPX [#d9-jmpx]
*Jumps*, or transfers control, to continuation `c`.
The remainder of the previous current continuation `cc` is discarded.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
JMPX
```
#### `DApr` CALLXARGS [#dapr-callxargs]
*Calls* continuation `c` with `p` parameters and expecting `r` return values
`0 <= p <= 15`, `0 <= r <= 15`
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[p] [r] CALLXARGS
```
#### `DB0p` CALLXARGS\_VAR [#db0p-callxargs_var]
*Calls* continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[p] -1 CALLXARGS
```
#### `DB1p` JMPXARGS [#db1p-jmpxargs]
*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).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[p] JMPXARGS
```
#### `DB2r` RETARGS [#db2r-retargs]
*Returns* to `c0`, with `0 <= r <= 15` return values taken from the current stack.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[r] RETARGS
```
#### `DB30` RET [#db30-ret]
*Returns* to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.
Approximately equivalent to `c0 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
RET
RETTRUE
```
#### `DB31` RETALT [#db31-retalt]
*Returns* to the continuation at `c1`.
Approximately equivalent to `c1 PUSHCTR` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
RETALT
RETFALSE
```
#### `DB32` BRANCH [#db32-branch]
Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
BRANCH
RETBOOL
```
#### `DB34` CALLCC [#db34-callcc]
*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`).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
CALLCC
```
#### `DB35` JMPXDATA [#db35-jmpxdata]
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`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
JMPXDATA
```
#### `DB36pr` CALLCCARGS [#db36pr-callccargs]
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`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[p] [r] CALLCCARGS
```
#### `DB38` CALLXVARARGS [#db38-callxvarargs]
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`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
CALLXVARARGS
```
#### `DB39` RETVARARGS [#db39-retvarargs]
Similar to `RETARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
RETVARARGS
```
#### `DB3A` JMPXVARARGS [#db3a-jmpxvarargs]
Similar to `JMPXARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
JMPXVARARGS
```
#### `DB3B` CALLCCVARARGS [#db3b-callccvarargs]
Similar to `CALLCCARGS`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
CALLCCVARARGS
```
#### `DB3C` CALLREF [#db3c-callref]
Equivalent to `PUSHREFCONT` `CALLX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[ref] CALLREF
```
#### `DB3D` JMPREF [#db3d-jmpref]
Equivalent to `PUSHREFCONT` `JMPX`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[ref] JMPREF
```
#### `DB3E` JMPREFDATA [#db3e-jmprefdata]
Equivalent to `PUSHREFCONT` `JMPXDATA`.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
[ref] JMPREFDATA
```
#### `DB3F` RETDATA [#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.
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
RETDATA
```
#### `DB4fff` RUNVM [#db4fff-runvm]
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.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
flags RUNVM
```
#### `DB50` RUNVMX [#db50-runvmx]
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.
Flags operate similarly to `RUNVMX` in Fift:
- `+1`: sets `c3` to code.
- `+2`: pushes an implicit `0` before executing the code.
- `+4`: takes persistent data `c4` from the stack and returns its final value.
- `+8`: takes the gas limit `g_l` from the stack and returns the consumed gas `g_c`.
- `+16`: takes `c7` (smart contract context) from the stack.
- `+32`: returns the final value of `c5` (actions).
- `+64`: pops the hard gas limit `g_m` enabled by `ACCEPT` from the stack.
- `+128`: enables "isolated gas consumption", meaning the child VM maintains a separate set of visited cells and a `chksgn` counter.
- `+256`: pops an integer `r` and ensures exactly `r` values are returned from the top of the stack:
- If `RUNVM` call succeeds and `r` is set, it returns `r` elements. If `r` is not set, it returns all available elements.
- If `RUNVM` is successful but lacks elements on the stack, meaning the stack depth is less than `r`, it is treated as an exception in the child VM. The `exit_code` is set to `-3`, and `exit_arg` is set to `0`, so `0` is returned as the only stack element.
- If `RUNVM` fails with an exception, only one element is returned, `exit_arg`, which should not be confused with `exit_code`.
- In the case of running out of gas, `exit_code` is set to `-14`, and `exit_arg` contains the amount of gas.
Gas cost:
- 66 gas;
- 1 gas for each stack element passed to the child VM (the first 32 elements are free);
- 1 gas for each stack element returned from the child VM (the first 32 elements are free).
**Category:** Cont Basic (cont\_basic)
```fift title="Fift"
RUNVMX
```
#### `DC` IFRET [#dc-ifret]
Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFRET
IFNOT:
```
#### `DD` IFNOTRET [#dd-ifnotret]
Performs a `RET`, but only if integer `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFNOTRET
IF:
```
#### `DE` IF [#de-if]
Performs `EXECUTE` for `c` (i.e., *executes* `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IF
```
#### `DF` IFNOT [#df-ifnot]
Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFNOT
```
#### `E0` IFJMP [#e0-ifjmp]
Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFJMP
```
#### `E1` IFNOTJMP [#e1-ifnotjmp]
Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFNOTJMP
```
#### `E2` IFELSE [#e2-ifelse]
If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFELSE
```
#### `E300` IFREF [#e300-ifref]
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.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFREF
```
#### `E301` IFNOTREF [#e301-ifnotref]
Equivalent to `PUSHREFCONT` `IFNOT`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFNOTREF
```
#### `E302` IFJMPREF [#e302-ifjmpref]
Equivalent to `PUSHREFCONT` `IFJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFJMPREF
```
#### `E303` IFNOTJMPREF [#e303-ifnotjmpref]
Equivalent to `PUSHREFCONT` `IFNOTJMP`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFNOTJMPREF
```
#### `E304` CONDSEL [#e304-condsel]
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`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
CONDSEL
```
#### `E305` CONDSELCHK [#e305-condselchk]
Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
CONDSELCHK
```
#### `E308` IFRETALT [#e308-ifretalt]
Performs `RETALT` if integer `f!=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFRETALT
```
#### `E309` IFNOTRETALT [#e309-ifnotretalt]
Performs `RETALT` if integer `f=0`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
IFNOTRETALT
```
#### `E30D` IFREFELSE [#e30d-ifrefelse]
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.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFREFELSE
```
#### `E30E` IFELSEREF [#e30e-ifelseref]
Equivalent to `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] IFELSEREF
```
#### `E30F` IFREFELSEREF [#e30f-ifrefelseref]
Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] [ref] IFREFELSEREF
```
#### `E39_n` IFBITJMP [#e39_n-ifbitjmp]
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.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[n] IFBITJMP
```
#### `E3B_n` IFNBITJMP [#e3b_n-ifnbitjmp]
Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[n] IFNBITJMP
```
#### `E3D_n` IFBITJMPREF [#e3d_n-ifbitjmpref]
Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] [n] IFBITJMPREF
```
#### `E3F_n` IFNBITJMPREF [#e3f_n-ifnbitjmpref]
Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.
**Category:** Cont Conditional (cont\_conditional)
```fift title="Fift"
[ref] [n] IFNBITJMPREF
```
#### `E4` REPEAT [#e4-repeat]
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.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
REPEAT
```
#### `E5` REPEATEND [#e5-repeatend]
Similar to `REPEAT`, but it is applied to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
REPEATEND
REPEAT:
```
#### `E6` UNTIL [#e6-until]
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.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
UNTIL
```
#### `E7` UNTILEND [#e7-untilend]
Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
UNTILEND
UNTIL:
```
#### `E8` WHILE [#e8-while]
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.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
WHILE
```
#### `E9` WHILEEND [#e9-whileend]
Similar to `WHILE`, but uses the current continuation `cc` as the loop body.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
WHILEEND
```
#### `EA` AGAIN [#ea-again]
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`).
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
AGAIN
```
#### `EB` AGAINEND [#eb-againend]
Similar to `AGAIN`, but performed with respect to the current continuation `cc`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
AGAINEND
AGAIN:
```
#### `E314` REPEATBRK [#e314-repeatbrk]
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.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
REPEATBRK
```
#### `E315` REPEATENDBRK [#e315-repeatendbrk]
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`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
REPEATENDBRK
```
#### `E316` UNTILBRK [#e316-untilbrk]
Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
UNTILBRK
```
#### `E317` UNTILENDBRK [#e317-untilendbrk]
Equivalent to `SAMEALTSAVE` `UNTILEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
UNTILENDBRK
UNTILBRK:
```
#### `E318` WHILEBRK [#e318-whilebrk]
Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
WHILEBRK
```
#### `E319` WHILEENDBRK [#e319-whileendbrk]
Equivalent to `SAMEALTSAVE` `WHILEEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
WHILEENDBRK
```
#### `E31A` AGAINBRK [#e31a-againbrk]
Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
AGAINBRK
```
#### `E31B` AGAINENDBRK [#e31b-againendbrk]
Equivalent to `SAMEALTSAVE` `AGAINEND`.
**Category:** Cont Loops (cont\_loops)
```fift title="Fift"
AGAINENDBRK
AGAINBRK:
```
#### `ECrn` SETCONTARGS\_N [#ecrn-setcontargs_n]
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.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift"
[r] [n] SETCONTARGS
```
**Aliases**:
* `SETNUMARGS`
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.
* `SETCONTARGS`
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.
#### `ED0p` RETURNARGS [#ed0p-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.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift"
[p] RETURNARGS
```
#### `ED10` RETURNVARARGS [#ed10-returnvarargs]
Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift"
RETURNVARARGS
```
#### `ED11` SETCONTVARARGS [#ed11-setcontvarargs]
Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift"
SETCONTVARARGS
```
#### `ED12` SETNUMVARARGS [#ed12-setnumvarargs]
`-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.
**Category:** Cont Stack (cont\_stack)
```fift title="Fift"
SETNUMVARARGS
```
#### `ED1E` BLESS [#ed1e-bless]
Transforms a *Slice* `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.
**Category:** Cont Create (cont\_create)
```fift title="Fift"
BLESS
```
#### `ED1F` BLESSVARARGS [#ed1f-blessvarargs]
Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.
**Category:** Cont Create (cont\_create)
```fift title="Fift"
BLESSVARARGS
```
#### `EErn` BLESSARGS [#eern-blessargs]
`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`.
**Category:** Cont Create (cont\_create)
```fift title="Fift"
[r] [n] BLESSARGS
```
**Aliases**:
* `BLESSNUMARGS`
Also transforms a *Slice* `s` into a *Continuation* `c`, but sets `c.nargs` to `0 <= n <= 14`.
#### `ED4i` PUSHCTR [#ed4i-pushctr]
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.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] PUSHCTR
c[i] PUSH
```
**Aliases**:
* `PUSHROOT`
Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data.
#### `ED5i` POPCTR [#ed5i-popctr]
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.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] POPCTR
c[i] POP
```
**Aliases**:
* `POPROOT`
Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data.
#### `ED6i` SETCONTCTR [#ed6i-setcontctr]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SETCONT
c[i] SETCONTCTR
```
#### `ED7i` SETRETCTR [#ed7i-setretctr]
Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SETRETCTR
```
#### `ED8i` SETALTCTR [#ed8i-setaltctr]
Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SETALTCTR
```
#### `ED9i` POPSAVE [#ed9i-popsave]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] POPSAVE
c[i] POPCTRSAVE
```
#### `EDAi` SAVE [#edai-save]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SAVE
c[i] SAVECTR
```
#### `EDBi` SAVEALT [#edbi-savealt]
Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SAVEALT
c[i] SAVEALTCTR
```
#### `EDCi` SAVEBOTH [#edci-saveboth]
Equivalent to `c[i] SAVE` `c[i] SAVEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
c[i] SAVEBOTH
c[i] SAVEBOTHCTR
```
#### `EDE0` PUSHCTRX [#ede0-pushctrx]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
PUSHCTRX
```
#### `EDE1` POPCTRX [#ede1-popctrx]
Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
POPCTRX
```
#### `EDE2` SETCONTCTRX [#ede2-setcontctrx]
Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SETCONTCTRX
```
#### `EDE3mm` SETCONTCTRMANY [#ede3mm-setcontctrmany]
Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SETCONTCTRMANY
SETCONTMANY
```
#### `EDE4` SETCONTCTRMANYX [#ede4-setcontctrmanyx]
Takes continuation, performs the equivalent of `c[i] PUSHCTR SWAP c[i] SETCONTCNR` for each `i` that is set in `mask` (mask is in `0..255`).
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SETCONTCTRMANYX
SETCONTMANYX
```
#### `EDF0` COMPOS [#edf0-compos]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
COMPOS
BOOLAND
```
#### `EDF1` COMPOSALT [#edf1-composalt]
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`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
COMPOSALT
BOOLOR
```
#### `EDF2` COMPOSBOTH [#edf2-composboth]
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`''.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
COMPOSBOTH
```
#### `EDF3` ATEXIT [#edf3-atexit]
Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
ATEXIT
```
#### `EDF4` ATEXITALT [#edf4-atexitalt]
Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
ATEXITALT
```
#### `EDF5` SETEXITALT [#edf5-setexitalt]
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.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SETEXITALT
```
#### `EDF6` THENRET [#edf6-thenret]
Computes `compose0(c, c0)`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
THENRET
```
#### `EDF7` THENRETALT [#edf7-thenretalt]
Computes `compose0(c, c1)`
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
THENRETALT
```
#### `EDF8` INVERT [#edf8-invert]
Interchanges `c0` and `c1`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
INVERT
```
#### `EDF9` BOOLEVAL [#edf9-booleval]
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.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
BOOLEVAL
```
#### `EDFA` SAMEALT [#edfa-samealt]
Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SAMEALT
```
#### `EDFB` SAMEALTSAVE [#edfb-samealtsave]
Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.
Equivalent to `c1 SAVE` `SAMEALT`.
**Category:** Cont Registers (cont\_registers)
```fift title="Fift"
SAMEALTSAVE
```
#### `F0nn` CALLDICT [#f0nn-calldict]
Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.
Approximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift"
[nn] CALL
[nn] CALLDICT
```
#### `F12_n` CALLDICT\_LONG [#f12_n-calldict_long]
For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift"
[n] CALL
[n] CALLDICT
```
#### `F16_n` JMPDICT [#f16_n-jmpdict]
Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.
Approximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift"
[n] JMP
```
#### `F1A_n` PREPAREDICT [#f1a_n-preparedict]
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.
**Category:** Cont Dict (cont\_dict)
```fift title="Fift"
[n] PREPARE
[n] PREPAREDICT
```
#### `F22_n` THROW\_SHORT [#f22_n-throw_short]
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.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROW
```
#### `F26_n` THROWIF\_SHORT [#f26_n-throwif_short]
Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWIF
```
#### `F2A_n` THROWIFNOT\_SHORT [#f2a_n-throwifnot_short]
Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWIFNOT
```
#### `F2C4_n` THROW [#f2c4_n-throw]
For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROW
```
#### `F2CC_n` THROWARG [#f2cc_n-throwarg]
Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWARG
```
#### `F2D4_n` THROWIF [#f2d4_n-throwif]
For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWIF
```
#### `F2DC_n` THROWARGIF [#f2dc_n-throwargif]
Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWARGIF
```
#### `F2E4_n` THROWIFNOT [#f2e4_n-throwifnot]
For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWIFNOT
```
#### `F2EC_n` THROWARGIFNOT [#f2ec_n-throwargifnot]
Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[n] THROWARGIFNOT
```
#### `F2F0` THROWANY [#f2f0-throwany]
Throws exception `0 <= n < 2^16` with parameter zero.
Approximately equivalent to `ZERO` `SWAP` `THROWARGANY`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWANY
```
#### `F2F1` THROWARGANY [#f2f1-throwargany]
Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.
Approximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWARGANY
```
#### `F2F2` THROWANYIF [#f2f2-throwanyif]
Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWANYIF
```
#### `F2F3` THROWARGANYIF [#f2f3-throwarganyif]
Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWARGANYIF
```
#### `F2F4` THROWANYIFNOT [#f2f4-throwanyifnot]
Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWANYIFNOT
```
#### `F2F5` THROWARGANYIFNOT [#f2f5-throwarganyifnot]
Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.
**Category:** Exceptions (exceptions)
```fift title="Fift"
THROWARGANYIFNOT
```
#### `F2FF` TRY [#f2ff-try]
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.
**Category:** Exceptions (exceptions)
```fift title="Fift"
TRY
```
#### `F3pr` TRYARGS [#f3pr-tryargs]
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.
**Category:** Exceptions (exceptions)
```fift title="Fift"
[p] [r] TRYARGS
```
#### `F400` STDICT [#f400-stdict]
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.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
STDICT
STOPTREF
```
#### `F401` SKIPDICT [#f401-skipdict]
Equivalent to `LDDICT` `NIP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
SKIPDICT
SKIPOPTREF
```
#### `F402` LDDICTS [#f402-lddicts]
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.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
LDDICTS
```
#### `F403` PLDDICTS [#f403-plddicts]
Preloads a (*Slice*-represented) dictionary `s'` from *Slice* `s`.
Approximately equivalent to `LDDICTS` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
PLDDICTS
```
#### `F404` LDDICT [#f404-lddict]
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.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
LDDICT
LDOPTREF
```
#### `F405` PLDDICT [#f405-plddict]
Preloads a dictionary `D` from *Slice* `s`.
Approximately equivalent to `LDDICT` `DROP`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
PLDDICT
PLDOPTREF
```
#### `F406` LDDICTQ [#f406-lddictq]
A quiet version of `LDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
LDDICTQ
```
#### `F407` PLDDICTQ [#f407-plddictq]
A quiet version of `PLDDICT`.
**Category:** Dict Serial (dict\_serial)
```fift title="Fift"
PLDDICTQ
```
#### `F40A` DICTGET [#f40a-dictget]
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`.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTGET
```
#### `F40B` DICTGETREF [#f40b-dictgetref]
Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.
This operation is useful for dictionaries of type `HashmapE(n,^Y)`.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTGETREF
```
#### `F40C` DICTIGET [#f40c-dictiget]
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.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTIGET
```
#### `F40D` DICTIGETREF [#f40d-dictigetref]
Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit *Integer* `i` as a key and returns a *Cell* instead of a *Slice* on success.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTIGETREF
```
#### `F40E` DICTUGET [#f40e-dictuget]
Similar to `DICTIGET`, but with *unsigned* (big-endian) `n`-bit *Integer* `i` used as a key.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTUGET
```
#### `F40F` DICTUGETREF [#f40f-dictugetref]
Similar to `DICTIGETREF`, but with an unsigned `n`-bit *Integer* key `i`.
**Category:** Dict Get (dict\_get)
```fift title="Fift"
DICTUGETREF
```
#### `F412` DICTSET [#f412-dictset]
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'`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTSET
```
#### `F413` DICTSETREF [#f413-dictsetref]
Similar to `DICTSET`, but with the value set to a reference to *Cell* `c`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTSETREF
```
#### `F414` DICTISET [#f414-dictiset]
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.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTISET
```
#### `F415` DICTISETREF [#f415-dictisetref]
Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTISETREF
```
#### `F416` DICTUSET [#f416-dictuset]
Similar to `DICTISET`, but with `i` an *unsigned* `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUSET
```
#### `F417` DICTUSETREF [#f417-dictusetref]
Similar to `DICTISETREF`, but with `i` unsigned.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUSETREF
```
#### `F41A` DICTSETGET [#f41a-dictsetget]
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.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTSETGET
```
#### `F41B` DICTSETGETREF [#f41b-dictsetgetref]
Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTSETGETREF
```
#### `F41C` DICTISETGET [#f41c-dictisetget]
`DICTISETGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTISETGET
```
#### `F41D` DICTISETGETREF [#f41d-dictisetgetref]
`DICTISETGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTISETGETREF
```
#### `F41E` DICTUSETGET [#f41e-dictusetget]
`DICTISETGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUSETGET
```
#### `F41F` DICTUSETGETREF [#f41f-dictusetgetref]
`DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUSETGETREF
```
#### `F422` DICTREPLACE [#f422-dictreplace]
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`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTREPLACE
```
#### `F423` DICTREPLACEREF [#f423-dictreplaceref]
A *Replace* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTREPLACEREF
```
#### `F424` DICTIREPLACE [#f424-dictireplace]
`DICTREPLACE`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIREPLACE
```
#### `F425` DICTIREPLACEREF [#f425-dictireplaceref]
`DICTREPLACEREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIREPLACEREF
```
#### `F426` DICTUREPLACE [#f426-dictureplace]
`DICTREPLACE`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUREPLACE
```
#### `F427` DICTUREPLACEREF [#f427-dictureplaceref]
`DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUREPLACEREF
```
#### `F42A` DICTREPLACEGET [#f42a-dictreplaceget]
A *Replace* counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTREPLACEGET
```
#### `F42B` DICTREPLACEGETREF [#f42b-dictreplacegetref]
A *Replace* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTREPLACEGETREF
```
#### `F42C` DICTIREPLACEGET [#f42c-dictireplaceget]
`DICTREPLACEGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIREPLACEGET
```
#### `F42D` DICTIREPLACEGETREF [#f42d-dictireplacegetref]
`DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIREPLACEGETREF
```
#### `F42E` DICTUREPLACEGET [#f42e-dictureplaceget]
`DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUREPLACEGET
```
#### `F42F` DICTUREPLACEGETREF [#f42f-dictureplacegetref]
`DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUREPLACEGETREF
```
#### `F432` DICTADD [#f432-dictadd]
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`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTADD
```
#### `F433` DICTADDREF [#f433-dictaddref]
An *Add* counterpart of `DICTSETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTADDREF
```
#### `F434` DICTIADD [#f434-dictiadd]
`DICTADD`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIADD
```
#### `F435` DICTIADDREF [#f435-dictiaddref]
`DICTADDREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIADDREF
```
#### `F436` DICTUADD [#f436-dictuadd]
`DICTADD`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUADD
```
#### `F437` DICTUADDREF [#f437-dictuaddref]
`DICTADDREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUADDREF
```
#### `F43A` DICTADDGET [#f43a-dictaddget]
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.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTADDGET
```
#### `F43B` DICTADDGETREF [#f43b-dictaddgetref]
An *Add* counterpart of `DICTSETGETREF`.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTADDGETREF
```
#### `F43C` DICTIADDGET [#f43c-dictiaddget]
`DICTADDGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIADDGET
```
#### `F43D` DICTIADDGETREF [#f43d-dictiaddgetref]
`DICTADDGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTIADDGETREF
```
#### `F43E` DICTUADDGET [#f43e-dictuaddget]
`DICTADDGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUADDGET
```
#### `F43F` DICTUADDGETREF [#f43f-dictuaddgetref]
`DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Set (dict\_set)
```fift title="Fift"
DICTUADDGETREF
```
#### `F441` DICTSETB [#f441-dictsetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTSETB
```
#### `F442` DICTISETB [#f442-dictisetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTISETB
```
#### `F443` DICTUSETB [#f443-dictusetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUSETB
```
#### `F445` DICTSETGETB [#f445-dictsetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTSETGETB
```
#### `F446` DICTISETGETB [#f446-dictisetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTISETGETB
```
#### `F447` DICTUSETGETB [#f447-dictusetgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUSETGETB
```
#### `F449` DICTREPLACEB [#f449-dictreplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTREPLACEB
```
#### `F44A` DICTIREPLACEB [#f44a-dictireplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTIREPLACEB
```
#### `F44B` DICTUREPLACEB [#f44b-dictureplaceb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUREPLACEB
```
#### `F44D` DICTREPLACEGETB [#f44d-dictreplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTREPLACEGETB
```
#### `F44E` DICTIREPLACEGETB [#f44e-dictireplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTIREPLACEGETB
```
#### `F44F` DICTUREPLACEGETB [#f44f-dictureplacegetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUREPLACEGETB
```
#### `F451` DICTADDB [#f451-dictaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTADDB
```
#### `F452` DICTIADDB [#f452-dictiaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTIADDB
```
#### `F453` DICTUADDB [#f453-dictuaddb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUADDB
```
#### `F455` DICTADDGETB [#f455-dictaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTADDGETB
```
#### `F456` DICTIADDGETB [#f456-dictiaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTIADDGETB
```
#### `F457` DICTUADDGETB [#f457-dictuaddgetb]
**Category:** Dict Set Builder (dict\_set\_builder)
```fift title="Fift"
DICTUADDGETB
```
#### `F459` DICTDEL [#f459-dictdel]
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`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTDEL
```
#### `F45A` DICTIDEL [#f45a-dictidel]
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'').
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTIDEL
```
#### `F45B` DICTUDEL [#f45b-dictudel]
Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTUDEL
```
#### `F462` DICTDELGET [#f462-dictdelget]
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`.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTDELGET
```
#### `F463` DICTDELGETREF [#f463-dictdelgetref]
Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a *Cell*.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTDELGETREF
```
#### `F464` DICTIDELGET [#f464-dictidelget]
`DICTDELGET`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTIDELGET
```
#### `F465` DICTIDELGETREF [#f465-dictidelgetref]
`DICTDELGETREF`, but with `i` a signed `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTIDELGETREF
```
#### `F466` DICTUDELGET [#f466-dictudelget]
`DICTDELGET`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTUDELGET
```
#### `F467` DICTUDELGETREF [#f467-dictudelgetref]
`DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.
**Category:** Dict Delete (dict\_delete)
```fift title="Fift"
DICTUDELGETREF
```
#### `F469` DICTGETOPTREF [#f469-dictgetoptref]
A variant of `DICTGETREF` that returns *Null* instead of the value `c^?` if the key `k` is absent from dictionary `D`.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTGETOPTREF
```
#### `F46A` DICTIGETOPTREF [#f46a-dictigetoptref]
`DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTIGETOPTREF
```
#### `F46B` DICTUGETOPTREF [#f46b-dictugetoptref]
`DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns *Null*.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTUGETOPTREF
```
#### `F46D` DICTSETGETOPTREF [#f46d-dictsetgetoptref]
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).
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTSETGETOPTREF
```
#### `F46E` DICTISETGETOPTREF [#f46e-dictisetgetoptref]
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.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTISETGETOPTREF
```
#### `F46F` DICTUSETGETOPTREF [#f46f-dictusetgetoptref]
Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit *Integer* `i` as a key.
**Category:** Dict Mayberef (dict\_mayberef)
```fift title="Fift"
DICTUSETGETOPTREF
```
#### `F470` PFXDICTSET [#f470-pfxdictset]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift"
PFXDICTSET
```
#### `F471` PFXDICTREPLACE [#f471-pfxdictreplace]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift"
PFXDICTREPLACE
```
#### `F472` PFXDICTADD [#f472-pfxdictadd]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift"
PFXDICTADD
```
#### `F473` PFXDICTDEL [#f473-pfxdictdel]
**Category:** Dict Prefix (dict\_prefix)
```fift title="Fift"
PFXDICTDEL
```
#### `F474` DICTGETNEXT [#f474-dictgetnext]
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*).
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTGETNEXT
```
#### `F475` DICTGETNEXTEQ [#f475-dictgetnexteq]
Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTGETNEXTEQ
```
#### `F476` DICTGETPREV [#f476-dictgetprev]
Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTGETPREV
```
#### `F477` DICTGETPREVEQ [#f477-dictgetpreveq]
Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTGETPREVEQ
```
#### `F478` DICTIGETNEXT [#f478-dictigetnext]
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).
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTIGETNEXT
```
#### `F479` DICTIGETNEXTEQ [#f479-dictigetnexteq]
Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTIGETNEXTEQ
```
#### `F47A` DICTIGETPREV [#f47a-dictigetprev]
Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTIGETPREV
```
#### `F47B` DICTIGETPREVEQ [#f47b-dictigetpreveq]
Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTIGETPREVEQ
```
#### `F47C` DICTUGETNEXT [#f47c-dictugetnext]
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).
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTUGETNEXT
```
#### `F47D` DICTUGETNEXTEQ [#f47d-dictugetnexteq]
Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTUGETNEXTEQ
```
#### `F47E` DICTUGETPREV [#f47e-dictugetprev]
Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTUGETPREV
```
#### `F47F` DICTUGETPREVEQ [#f47f-dictugetpreveq]
Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.
**Category:** Dict Next (dict\_next)
```fift title="Fift"
DICTUGETPREVEQ
```
#### `F482` DICTMIN [#f482-dictmin]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTMIN
```
#### `F483` DICTMINREF [#f483-dictminref]
Similar to `DICTMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTMINREF
```
#### `F484` DICTIMIN [#f484-dictimin]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIMIN
```
#### `F485` DICTIMINREF [#f485-dictiminref]
Similar to `DICTIMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIMINREF
```
#### `F486` DICTUMIN [#f486-dictumin]
Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUMIN
```
#### `F487` DICTUMINREF [#f487-dictuminref]
Similar to `DICTUMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUMINREF
```
#### `F48A` DICTMAX [#f48a-dictmax]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTMAX
```
#### `F48B` DICTMAXREF [#f48b-dictmaxref]
Similar to `DICTMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTMAXREF
```
#### `F48C` DICTIMAX [#f48c-dictimax]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIMAX
```
#### `F48D` DICTIMAXREF [#f48d-dictimaxref]
Similar to `DICTIMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIMAXREF
```
#### `F48E` DICTUMAX [#f48e-dictumax]
Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUMAX
```
#### `F48F` DICTUMAXREF [#f48f-dictumaxref]
Similar to `DICTUMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUMAXREF
```
#### `F492` DICTREMMIN [#f492-dictremmin]
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'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTREMMIN
```
#### `F493` DICTREMMINREF [#f493-dictremminref]
Similar to `DICTREMMIN`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTREMMINREF
```
#### `F494` DICTIREMMIN [#f494-dictiremmin]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIREMMIN
```
#### `F495` DICTIREMMINREF [#f495-dictiremminref]
Similar to `DICTIREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIREMMINREF
```
#### `F496` DICTUREMMIN [#f496-dicturemmin]
Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUREMMIN
```
#### `F497` DICTUREMMINREF [#f497-dicturemminref]
Similar to `DICTUREMMIN`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUREMMINREF
```
#### `F49A` DICTREMMAX [#f49a-dictremmax]
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'`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTREMMAX
```
#### `F49B` DICTREMMAXREF [#f49b-dictremmaxref]
Similar to `DICTREMMAX`, but returns the only reference in the value as a *Cell* `c`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTREMMAXREF
```
#### `F49C` DICTIREMMAX [#f49c-dictiremmax]
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`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIREMMAX
```
#### `F49D` DICTIREMMAXREF [#f49d-dictiremmaxref]
Similar to `DICTIREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTIREMMAXREF
```
#### `F49E` DICTUREMMAX [#f49e-dicturemmax]
Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit *Integer* `i`.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUREMMAX
```
#### `F49F` DICTUREMMAXREF [#f49f-dicturemmaxref]
Similar to `DICTUREMMAX`, but returns the only reference in the value.
**Category:** Dict Min (dict\_min)
```fift title="Fift"
DICTUREMMAXREF
```
#### `F4A0` DICTIGETJMP [#f4a0-dictigetjmp]
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.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTIGETJMP
```
#### `F4A1` DICTUGETJMP [#f4a1-dictugetjmp]
Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTUGETJMP
```
#### `F4A2` DICTIGETEXEC [#f4a2-dictigetexec]
Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTIGETEXEC
```
#### `F4A3` DICTUGETEXEC [#f4a3-dictugetexec]
Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTUGETEXEC
```
#### `F4A6_n` DICTPUSHCONST [#f4a6_n-dictpushconst]
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.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
[ref] [n] DICTPUSHCONST
```
#### `F4A8` PFXDICTGETQ [#f4a8-pfxdictgetq]
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.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
PFXDICTGETQ
```
#### `F4A9` PFXDICTGET [#f4a9-pfxdictget]
Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
PFXDICTGET
```
#### `F4AA` PFXDICTGETJMP [#f4aa-pfxdictgetjmp]
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.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
PFXDICTGETJMP
```
#### `F4AB` PFXDICTGETEXEC [#f4ab-pfxdictgetexec]
Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
PFXDICTGETEXEC
```
#### `F4AE_n` PFXDICTCONSTGETJMP [#f4ae_n-pfxdictconstgetjmp]
Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
[ref] [n] PFXDICTCONSTGETJMP
[ref] [n] PFXDICTSWITCH
```
#### `F4BC` DICTIGETJMPZ [#f4bc-dictigetjmpz]
A variant of `DICTIGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTIGETJMPZ
```
#### `F4BD` DICTUGETJMPZ [#f4bd-dictugetjmpz]
A variant of `DICTUGETJMP` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTUGETJMPZ
```
#### `F4BE` DICTIGETEXECZ [#f4be-dictigetexecz]
A variant of `DICTIGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTIGETEXECZ
```
#### `F4BF` DICTUGETEXECZ [#f4bf-dictugetexecz]
A variant of `DICTUGETEXEC` that returns index `i` on failure.
**Category:** Dict Special (dict\_special)
```fift title="Fift"
DICTUGETEXECZ
```
#### `F4B1` SUBDICTGET [#f4b1-subdictget]
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'`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTGET
```
#### `F4B2` SUBDICTIGET [#f4b2-subdictiget]
Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTIGET
```
#### `F4B3` SUBDICTUGET [#f4b3-subdictuget]
Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTUGET
```
#### `F4B5` SUBDICTRPGET [#f4b5-subdictrpget]
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)`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTRPGET
```
#### `F4B6` SUBDICTIRPGET [#f4b6-subdictirpget]
Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit *Integer* `x`, where necessarily `l <= 257`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTIRPGET
```
#### `F4B7` SUBDICTURPGET [#f4b7-subdicturpget]
Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit *Integer* `x`, where necessarily `l <= 256`.
**Category:** Dict Sub (dict\_sub)
```fift title="Fift"
SUBDICTURPGET
```
#### `F800` ACCEPT [#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.
**Category:** App Gas (app\_gas)
```fift title="Fift"
ACCEPT
```
#### `F801` SETGASLIMIT [#f801-setgaslimit]
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`.
**Category:** App Gas (app\_gas)
```fift title="Fift"
SETGASLIMIT
```
#### `F807` GASCONSUMED [#f807-gasconsumed]
Returns gas consumed by VM so far (including this instruction).
**Category:** App Gas (app\_gas)
```fift title="Fift"
GASCONSUMED
```
#### `F80F` COMMIT [#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.
**Category:** App Gas (app\_gas)
```fift title="Fift"
COMMIT
```
#### `F810` RANDU256 [#f810-randu256]
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`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift"
RANDU256
```
#### `F811` RAND [#f811-rand]
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`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift"
RAND
```
#### `F814` SETRAND [#f814-setrand]
Sets the random seed to unsigned 256-bit *Integer* `x`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift"
SETRAND
```
#### `F815` ADDRAND [#f815-addrand]
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`.
**Category:** App Rnd (app\_rnd)
```fift title="Fift"
ADDRAND
RANDOMIZE
```
#### `F82i` GETPARAM [#f82i-getparam]
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.
**Category:** App Config (app\_config)
```fift title="Fift"
[i] GETPARAM
```
**Aliases**:
* `NOW`
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`.
* `BLOCKLT`
Returns the starting logical time of the current block.
Equivalent to `4 GETPARAM`.
* `LTIME`
Returns the logical time of the current transaction.
Equivalent to `5 GETPARAM`.
* `RANDSEED`
Returns the current random seed as an unsigned 256-bit *Integer*.
Equivalent to `6 GETPARAM`.
* `BALANCE`
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.
* `MYADDR`
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`.
* `CONFIGROOT`
Returns the *Maybe Cell* `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `.
* `MYCODE`
Retrieves code of smart-contract from c7. Equivalent to `10 GETPARAM `.
* `INCOMINGVALUE`
Retrieves value of incoming message from c7. Equivalent to `11 GETPARAM `.
* `STORAGEFEES`
Retrieves value of storage phase fees from c7. Equivalent to `12 GETPARAM `.
* `PREVBLOCKSINFOTUPLE`
Retrives PrevBlocksInfo: `[last_mc_blocks, prev_key_block]` from c7. Equivalent to `13 GETPARAM `.
* `UNPACKEDCONFIGTUPLE`
Retrives tuple that contains some config parameters as cell slices. If the parameter is absent from the config, the value is null. Values:
\* **0**: `StoragePrices` from `ConfigParam 18`. Not the whole dict, but only the one StoragePrices entry (one which corresponds to the current time).
\* **1**: `ConfigParam 19` (global id).
\* **2**: `ConfigParam 20` (mc gas prices).
\* **3**: `ConfigParam 21` (gas prices).
\* **4**: `ConfigParam 24` (mc fwd fees).
\* **5**: `ConfigParam 25` (fwd fees).
\* **6**: `ConfigParam 43` (size limits).
* `DUEPAYMENT`
Retrives current debt for storage fee (nanotons).
#### `F830` CONFIGDICT [#f830-configdict]
Returns the global configuration dictionary along with its key length (32).
Equivalent to `CONFIGROOT` `32 PUSHINT`.
**Category:** App Config (app\_config)
```fift title="Fift"
CONFIGDICT
```
#### `F832` CONFIGPARAM [#f832-configparam]
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`.
**Category:** App Config (app\_config)
```fift title="Fift"
CONFIGPARAM
```
#### `F833` CONFIGOPTPARAM [#f833-configoptparam]
Returns the value of the global configuration parameter with integer index `i` as a *Maybe Cell* `c^?`.
Equivalent to `CONFIGDICT` `DICTIGETOPTREF`.
**Category:** App Config (app\_config)
```fift title="Fift"
CONFIGOPTPARAM
```
#### `F83400` PREVMCBLOCKS [#f83400-prevmcblocks]
Retrives `last_mc_blocks` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift"
PREVMCBLOCKS
```
#### `F83401` PREVKEYBLOCK [#f83401-prevkeyblock]
Retrives `prev_key_block` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift"
PREVKEYBLOCK
```
#### `F83402` PREVMCBLOCKS\_100 [#f83402-prevmcblocks_100]
Retrives `last_mc_blocks_divisible_by_100` part of PrevBlocksInfo from c7 (parameter 13).
**Category:** App Config (app\_config)
```fift title="Fift"
PREVMCBLOCKS_100
```
#### `F835` GLOBALID [#f835-globalid]
Retrieves `global_id` from 19 network config.
**Category:** App Config (app\_config)
```fift title="Fift"
GLOBALID
```
#### `F836` GETGASFEE [#f836-getgasfee]
Calculates gas fee
**Category:** App Config (app\_config)
```fift title="Fift"
GETGASFEE
```
#### `F837` GETSTORAGEFEE [#f837-getstoragefee]
Calculates storage fees (only current StoragePrices entry is used).
**Category:** App Config (app\_config)
```fift title="Fift"
GETSTORAGEFEE
```
#### `F838` GETFORWARDFEE [#f838-getforwardfee]
Calculates forward fee.
**Category:** App Config (app\_config)
```fift title="Fift"
GETFORWARDFEE
```
#### `F839` GETPRECOMPILEDGAS [#f839-getprecompiledgas]
Returns gas usage for the current contract if it is precompiled, `null` otherwise.
**Category:** App Config (app\_config)
```fift title="Fift"
GETPRECOMPILEDGAS
```
#### `F83A` GETORIGINALFWDFEE [#f83a-getoriginalfwdfee]
Calculate `(fwd_fee * 2^16) / (2^16 - first_frac)`. Can be used to get the original `fwd_fee` of the message.
**Category:** App Config (app\_config)
```fift title="Fift"
GETORIGINALFWDFEE
```
#### `F83B` GETGASFEESIMPLE [#f83b-getgasfeesimple]
Same as `GETGASFEE`, but without flat price (just `(gas_used * price) / 2^16)`.
**Category:** App Config (app\_config)
```fift title="Fift"
GETGASFEESIMPLE
```
#### `F83C` GETFORWARDFEESIMPLE [#f83c-getforwardfeesimple]
Same as `GETFORWARDFEE`, but without lump price (just (`bits*bit_price + cells*cell_price) / 2^16`).
**Category:** App Config (app\_config)
```fift title="Fift"
GETFORWARDFEESIMPLE
```
#### `F840` GETGLOBVAR [#f840-getglobvar]
Returns the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.
**Category:** App Global (app\_global)
```fift title="Fift"
GETGLOBVAR
```
#### `F85_k` GETGLOB [#f85_k-getglob]
Returns the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `[k] INDEXQ`.
**Category:** App Global (app\_global)
```fift title="Fift"
[k] GETGLOB
```
#### `F860` SETGLOBVAR [#f860-setglobvar]
Assigns `x` to the `k`-th global variable for `0 <= k < 255`.
Equivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift"
SETGLOBVAR
```
#### `F87_k` SETGLOB [#f87_k-setglob]
Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.
Equivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.
**Category:** App Global (app\_global)
```fift title="Fift"
[k] SETGLOB
```
#### `F880` GETEXTRABALANCE [#f880-getextrabalance]
Takes id of the extra currency (integer in range `0..2^32-1`), returns the amount of this extra currency on the account balance. The first `5` executions of `GETEXTRABALANCE` consume at most `26 + 200` gas each. The subsequent executions incur the full gas cost of `26` (normal instruction cost) plus gas for loading cells (up to `3300` if the dictionary has maximum depth).
**Category:** App Global (app\_global)
```fift title="Fift"
GETEXTRABALANCE
```
#### `F881ii` GETPARAMLONG [#f881ii-getparamlong]
Returns the `i`-th parameter from the *Tuple* provided at `c7` for `0 <= i <= 255`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.
If one of these internal operations fails, throws an appropriate type checking or range checking exception.
**Category:** App Config (app\_config)
```fift title="Fift"
[i] GETPARAMLONG
```
#### `F89i` INMSGPARAM [#f89i-inmsgparam]
Equivalent to `INMSGPARAMS` `i INDEX`
**Category:** App Config (app\_config)
```fift title="Fift"
[i] INMSGPARAM
```
**Aliases**:
* `INMSG_BOUNCE`
Retrives `bounce` flag of incoming message.
* `INMSG_BOUNCED`
Retrives `bounced` flag of incoming message.
* `INMSG_SRC`
Retrives `src` flag of incoming message.
* `INMSG_FWDFEE`
Retrives `fwd_fee` field of incoming message.
* `INMSG_LT`
Retrives `lt` field of incoming message.
* `INMSG_UTIME`
Retrives `utime` field of incoming message.
* `INMSG_ORIGVALUE`
Retrives original value of the message. This is sometimes different from the value in `INCOMINGVALUE` and TVM stack because of storage fees.
* `INMSG_VALUE`
Retrives value of the message after deducting storage fees. This is same as in `INCOMINGVALUE` and TVM stack.
* `INMSG_VALUEEXTRA`
Same as in `INCOMINGVALUE`.
* `INMSG_STATEINIT`
Retrieves `init` field of the incoming message.
#### `F900` HASHCU [#f900-hashcu]
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.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHCU
```
#### `F901` HASHSU [#f901-hashsu]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHSU
```
#### `F902` SHA256U [#f902-sha256u]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
SHA256U
```
#### `F90400` HASHEXT\_SHA256 [#f90400-hashext_sha256]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXT_SHA256
```
#### `F90401` HASHEXT\_SHA512 [#f90401-hashext_sha512]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXT_SHA512
```
#### `F90402` HASHEXT\_BLAKE2B [#f90402-hashext_blake2b]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXT_BLAKE2B
```
#### `F90403` HASHEXT\_KECCAK256 [#f90403-hashext_keccak256]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXT_KECCAK256
```
#### `F90404` HASHEXT\_KECCAK512 [#f90404-hashext_keccak512]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXT_KECCAK512
```
#### `F90500` HASHEXTR\_SHA256 [#f90500-hashextr_sha256]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTR_SHA256
```
#### `F90501` HASHEXTR\_SHA512 [#f90501-hashextr_sha512]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTR_SHA512
```
#### `F90502` HASHEXTR\_BLAKE2B [#f90502-hashextr_blake2b]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTR_BLAKE2B
```
#### `F90503` HASHEXTR\_KECCAK256 [#f90503-hashextr_keccak256]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTR_KECCAK256
```
#### `F90504` HASHEXTR\_KECCAK512 [#f90504-hashextr_keccak512]
Calculates and returns hash of the concatenation of slices (or builders) `s_1...s_n`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTR_KECCAK512
```
#### `F90600` HASHEXTA\_SHA256 [#f90600-hashexta_sha256]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTA_SHA256
```
#### `F90601` HASHEXTA\_SHA512 [#f90601-hashexta_sha512]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTA_SHA512
```
#### `F90602` HASHEXTA\_BLAKE2B [#f90602-hashexta_blake2b]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTA_BLAKE2B
```
#### `F90603` HASHEXTA\_KECCAK256 [#f90603-hashexta_keccak256]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTA_KECCAK256
```
#### `F90604` HASHEXTA\_KECCAK512 [#f90604-hashexta_keccak512]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTA_KECCAK512
```
#### `F90700` HASHEXTAR\_SHA256 [#f90700-hashextar_sha256]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTAR_SHA256
```
#### `F90701` HASHEXTAR\_SHA512 [#f90701-hashextar_sha512]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTAR_SHA512
```
#### `F90702` HASHEXTAR\_BLAKE2B [#f90702-hashextar_blake2b]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTAR_BLAKE2B
```
#### `F90703` HASHEXTAR\_KECCAK256 [#f90703-hashextar_keccak256]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTAR_KECCAK256
```
#### `F90704` HASHEXTAR\_KECCAK512 [#f90704-hashextar_keccak512]
Calculates hash of the concatenation of slices (or builders) `s_1...s_n`. Appends the resulting hash to a builder `b`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHEXTAR_KECCAK512
```
#### `F910` CHKSIGNU [#f910-chksignu]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
CHKSIGNU
```
#### `F911` CHKSIGNS [#f911-chksigns]
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.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
CHKSIGNS
```
#### `F912` ECRECOVER [#f912-ecrecover]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
ECRECOVER
```
#### `F913` SECP256K1\_XONLY\_PUBKEY\_TWEAK\_ADD [#f913-secp256k1_xonly_pubkey_tweak_add]
performs [`secp256k1_xonly_pubkey_tweak_add`](https://github.com/bitcoin-core/secp256k1/blob/master/include/secp256k1_extrakeys.h#L120). `key` and `tweak` are 256-bit unsigned integers. 65-byte public key is returned as `uint8 f`, `uint256 x, y` (as in `ECRECOVER`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
SECP256K1_XONLY_PUBKEY_TWEAK_ADD
```
#### `F914` P256\_CHKSIGNU [#f914-p256_chksignu]
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](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
P256_CHKSIGNU
```
#### `F915` P256\_CHKSIGNS [#f915-p256_chksigns]
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](https://www.secg.org/sec1-v2.pdf)). Signature `sig` is a 64-byte slice (two 256-bit unsigned integers `r` and `s`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
P256_CHKSIGNS
```
#### `F916` HASHBU [#f916-hashbu]
Same as `ENDC HASHCU`, but without gas cost for cell creation.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
HASHBU
```
#### `F920` RIST255\_FROMHASH [#f920-rist255_fromhash]
Deterministically generates a valid point `x` from a 512-bit hash (given as two 256-bit integers).
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_FROMHASH
```
#### `F921` RIST255\_VALIDATE [#f921-rist255_validate]
Checks that integer `x` is a valid representation of some curve point. Throws range\_chk on error.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_VALIDATE
```
#### `F922` RIST255\_ADD [#f922-rist255_add]
Addition of two points on a curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_ADD
```
#### `F923` RIST255\_SUB [#f923-rist255_sub]
Subtraction of two points on curve.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_SUB
```
#### `F924` RIST255\_MUL [#f924-rist255_mul]
Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_MUL
```
#### `F925` RIST255\_MULBASE [#f925-rist255_mulbase]
Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_MULBASE
```
#### `F926` RIST255\_PUSHL [#f926-rist255_pushl]
Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_PUSHL
```
#### `B7F921` RIST255\_QVALIDATE [#b7f921-rist255_qvalidate]
Checks that integer `x` is a valid representation of some curve point. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_QVALIDATE
```
#### `B7F922` RIST255\_QADD [#b7f922-rist255_qadd]
Addition of two points on a curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_QADD
```
#### `B7F923` RIST255\_QSUB [#b7f923-rist255_qsub]
Subtraction of two points on curve. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_QSUB
```
#### `B7F924` RIST255\_QMUL [#b7f924-rist255_qmul]
Multiplies point `x` by a scalar `n`. Any `n` is valid, including negative. Returns -1 on success and 0 on failure.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_QMUL
```
#### `B7F925` RIST255\_QMULBASE [#b7f925-rist255_qmulbase]
Multiplies the generator point `g` by a scalar `n`. Any `n` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
RIST255_QMULBASE
```
#### `F93000` BLS\_VERIFY [#f93000-bls_verify]
Checks BLS signature, return true on success, false otherwise.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_VERIFY
```
#### `F93001` BLS\_AGGREGATE [#f93001-bls_aggregate]
Aggregates signatures. `n>0`. Throw exception if `n=0` or if some `sig_i` is not a valid signature.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_AGGREGATE
```
#### `F93002` BLS\_FASTAGGREGATEVERIFY [#f93002-bls_fastaggregateverify]
Checks aggregated BLS signature for keys `pk_1...pk_n` and message `msg`. Return true on success, false otherwise. Return false if `n=0`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_FASTAGGREGATEVERIFY
```
#### `F93003` BLS\_AGGREGATEVERIFY [#f93003-bls_aggregateverify]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_AGGREGATEVERIFY
```
#### `F93010` BLS\_G1\_ADD [#f93010-bls_g1_add]
Addition on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_ADD
```
#### `F93011` BLS\_G1\_SUB [#f93011-bls_g1_sub]
Subtraction on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_SUB
```
#### `F93012` BLS\_G1\_NEG [#f93012-bls_g1_neg]
Negation on G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_NEG
```
#### `F93013` BLS\_G1\_MUL [#f93013-bls_g1_mul]
Multiplies G1 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_MUL
```
#### `F93014` BLS\_G1\_MULTIEXP [#f93014-bls_g1_multiexp]
Calculates `x_1*s_1+...+x_n*s_n` for G1 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_MULTIEXP
```
#### `F93015` BLS\_G1\_ZERO [#f93015-bls_g1_zero]
Pushes zero point in G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_ZERO
```
#### `F93016` BLS\_MAP\_TO\_G1 [#f93016-bls_map_to_g1]
Converts FP element `f` to a G1 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_MAP_TO_G1
```
#### `F93017` BLS\_G1\_INGROUP [#f93017-bls_g1_ingroup]
Checks that slice `x` represents a valid element of G1.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_INGROUP
```
#### `F93018` BLS\_G1\_ISZERO [#f93018-bls_g1_iszero]
Checks that G1 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G1_ISZERO
```
#### `F93020` BLS\_G2\_ADD [#f93020-bls_g2_add]
Addition on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_ADD
```
#### `F93021` BLS\_G2\_SUB [#f93021-bls_g2_sub]
Subtraction on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_SUB
```
#### `F93022` BLS\_G2\_NEG [#f93022-bls_g2_neg]
Negation on G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_NEG
```
#### `F93023` BLS\_G2\_MUL [#f93023-bls_g2_mul]
Multiplies G2 point `x` by scalar `s`. Any `s` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_MUL
```
#### `F93024` BLS\_G2\_MULTIEXP [#f93024-bls_g2_multiexp]
Calculates `x_1*s_1+...+x_n*s_n` for G2 points `x_i` and scalars `s_i`. Returns zero point if `n=0`. Any `s_i` is valid, including negative.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_MULTIEXP
```
#### `F93025` BLS\_G2\_ZERO [#f93025-bls_g2_zero]
Pushes zero point in G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_ZERO
```
#### `F93026` BLS\_MAP\_TO\_G2 [#f93026-bls_map_to_g2]
Converts FP2 element `f` to a G2 point.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_MAP_TO_G2
```
#### `F93027` BLS\_G2\_INGROUP [#f93027-bls_g2_ingroup]
Checks that slice `x` represents a valid element of G2.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_INGROUP
```
#### `F93028` BLS\_G2\_ISZERO [#f93028-bls_g2_iszero]
Checks that G2 point `x` is equal to zero.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_G2_ISZERO
```
#### `F93030` BLS\_PAIRING [#f93030-bls_pairing]
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`.
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_PAIRING
```
#### `F93031` BLS\_PUSHR [#f93031-bls_pushr]
Pushes the order of G1 and G2 (approx. `2^255`).
**Category:** App Crypto (app\_crypto)
```fift title="Fift"
BLS_PUSHR
```
#### `F940` CDATASIZEQ [#f940-cdatasizeq]
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`.
**Category:** App Misc (app\_misc)
```fift title="Fift"
CDATASIZEQ
```
#### `F941` CDATASIZE [#f941-cdatasize]
A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift"
CDATASIZE
```
#### `F942` SDATASIZEQ [#f942-sdatasizeq]
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`.
**Category:** App Misc (app\_misc)
```fift title="Fift"
SDATASIZEQ
```
#### `F943` SDATASIZE [#f943-sdatasize]
A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.
**Category:** App Misc (app\_misc)
```fift title="Fift"
SDATASIZE
```
#### `FA00` LDGRAMS [#fa00-ldgrams]
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`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
LDGRAMS
LDVARUINT16
```
#### `FA01` LDVARINT16 [#fa01-ldvarint16]
Similar to `LDVARUINT16`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
LDVARINT16
```
#### `FA02` STGRAMS [#fa02-stgrams]
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.
**Category:** App Currency (app\_currency)
```fift title="Fift"
STGRAMS
STVARUINT16
```
#### `FA03` STVARINT16 [#fa03-stvarint16]
Similar to `STVARUINT16`, but serializes a *signed* *Integer* `x` in the range `-2^119...2^119-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
STVARINT16
```
#### `FA04` LDVARUINT32 [#fa04-ldvaruint32]
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`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
LDVARUINT32
```
#### `FA05` LDVARINT32 [#fa05-ldvarint32]
Similar to `LDVARUINT32`, but loads a *signed* *Integer* `x`.
Approximately equivalent to `5 LDU` `SWAP` `3 LSHIFT#` `LDIX`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
LDVARINT32
```
#### `FA06` STVARUINT32 [#fa06-stvaruint32]
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.
**Category:** App Currency (app\_currency)
```fift title="Fift"
STVARUINT32
```
#### `FA07` STVARINT32 [#fa07-stvarint32]
Similar to `STVARUINT32`, but serializes a *signed* *Integer* `x` in the range `-2^247...2^247-1`.
**Category:** App Currency (app\_currency)
```fift title="Fift"
STVARINT32
```
#### `FA40` LDMSGADDR [#fa40-ldmsgaddr]
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.
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDMSGADDR
```
#### `FA41` LDMSGADDRQ [#fa41-ldmsgaddrq]
A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDMSGADDRQ
```
#### `FA42` PARSEMSGADDR [#fa42-parsemsgaddr]
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.
**Category:** App Addr (app\_addr)
```fift title="Fift"
PARSEMSGADDR
```
#### `FA43` PARSEMSGADDRQ [#fa43-parsemsgaddrq]
A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.
**Category:** App Addr (app\_addr)
```fift title="Fift"
PARSEMSGADDRQ
```
#### `FA44` REWRITESTDADDR [#fa44-rewritestdaddr]
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.
**Category:** App Addr (app\_addr)
```fift title="Fift"
REWRITESTDADDR
```
#### `FA45` REWRITESTDADDRQ [#fa45-rewritestdaddrq]
A quiet version of primitive `REWRITESTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
REWRITESTDADDRQ
```
#### `FA46` REWRITEVARADDR [#fa46-rewritevaraddr]
`msg_addr_var` not allowed since TVM v10, so it behaves like `REWRITESTDADDR`, but returns account id in `Slice`, not `Integer`: parses address `s` into workchain `x` and account id `s`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
REWRITEVARADDR
```
#### `FA47` REWRITEVARADDRQ [#fa47-rewritevaraddrq]
A quiet version of primitive `REWRITEVARADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
REWRITEVARADDRQ
```
#### `FA48` LDSTDADDR [#fa48-ldstdaddr]
Loads `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDSTDADDR
```
#### `FA49` LDSTDADDRQ [#fa49-ldstdaddrq]
A quiet version of primitive `LDSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDSTDADDRQ
```
#### `FA50` LDOPTSTDADDR [#fa50-ldoptstdaddr]
Loads `addr_std$10` or `addr_none$00`, if address is `addr_none$00` pushes a Null, if address is not `addr_std` or `addr_none`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDOPTSTDADDR
```
#### `FA51` LDOPTSTDADDRQ [#fa51-ldoptstdaddrq]
A quiet version of primitive `LDOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
LDOPTSTDADDRQ
```
#### `FA52` STSTDADDR [#fa52-ststdaddr]
Stores `addr_std$10`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift"
STSTDADDR
```
#### `FA53` STSTDADDRQ [#fa53-ststdaddrq]
A quiet version of primitive `STSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
STSTDADDRQ
```
#### `FA54` STOPTSTDADDR [#fa54-stoptstdaddr]
stores `addr_std$10` or Null. Null is stored as `addr_none$00`, if address is not `addr_std`, throws an error 9 (`cannot load a MsgAddressInt`).
**Category:** App Addr (app\_addr)
```fift title="Fift"
STOPTSTDADDR
```
#### `FA55` STOPTSTDADDRQ [#fa55-stoptstdaddrq]
A quiet version of primitive `STOPTSTDADDR`.
**Category:** App Addr (app\_addr)
```fift title="Fift"
STOPTSTDADDRQ
```
#### `FB00` SENDRAWMSG [#fb00-sendrawmsg]
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`.
**Category:** App Actions (app\_actions)
```fift title="Fift"
SENDRAWMSG
```
#### `FB02` RAWRESERVE [#fb02-rawreserve]
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`.
**Category:** App Actions (app\_actions)
```fift title="Fift"
RAWRESERVE
```
#### `FB03` RAWRESERVEX [#fb03-rawreservex]
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.
**Category:** App Actions (app\_actions)
```fift title="Fift"
RAWRESERVEX
```
#### `FB04` SETCODE [#fb04-setcode]
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.
**Category:** App Actions (app\_actions)
```fift title="Fift"
SETCODE
```
#### `FB06` SETLIBCODE [#fb06-setlibcode]
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.
**Category:** App Actions (app\_actions)
```fift title="Fift"
SETLIBCODE
```
#### `FB07` CHANGELIB [#fb07-changelib]
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.
**Category:** App Actions (app\_actions)
```fift title="Fift"
CHANGELIB
```
#### `FB08` SENDMSG [#fb08-sendmsg]
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).
**Category:** App Actions (app\_actions)
```fift title="Fift"
SENDMSG
```
#### `FEij` DEBUG [#feij-debug]
**Category:** Debug (debug)
```fift title="Fift"
{i*16+j} DEBUG
```
**Aliases**:
* `DUMPSTK`
Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM.
* `STRDUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.
* `DUMP`
Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.
#### `FEFnssss` DEBUGSTR [#fefnssss-debugstr]
`0 <= n < 16`. Length of `ssss` is `n+1` bytes.
`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).
`DEBUGSTR`: `ssss` is the given string.
`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.
**Category:** Debug (debug)
```fift title="Fift"
{string} DEBUGSTR
{string} {x} DEBUGSTRI
```
#### `FFnn` SETCP [#ffnn-setcp]
Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.
**Category:** Codepage (codepage)
```fift title="Fift"
[nn] SETCP
```
**Aliases**:
* `SETCP0`
Selects TVM (test) codepage zero as described in this document.
#### `FFFz` SETCP\_SPECIAL [#fffz-setcp_special]
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.
**Category:** Codepage (codepage)
```fift title="Fift"
[z-16] SETCP
```
#### `FFF0` SETCPX [#fff0-setcpx]
Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.
**Category:** Codepage (codepage)
```fift title="Fift"
SETCPX
```
{/* STATIC_END tvm_instructions */}