From fab8588aa67b44b2872a4162b31c2b8cb7232887 Mon Sep 17 00:00:00 2001 From: Vladimir Lebedev Date: Mon, 4 Dec 2023 05:12:25 +0700 Subject: [PATCH] Implement value flow specification (#1) --- README.md | 156 +- cp0.json | 46494 ++++++++++++++++++++++++++++++++++---------------- schema.json | 788 +- 3 files changed, 32747 insertions(+), 14691 deletions(-) diff --git a/README.md b/README.md index 86b2a49..9a741c1 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ This repo's goal is to provide machine-readable (JSON) description of TVM instru | -------- | ------------- | 0 | [cp0.json](./cp0.json) -JSON Schema of specifications is available in [schema.json](./schema.json). [quicktype.io](https://app.quicktype.io/) can be used to generate wrappers for specific programming language. +JSON Schema of specifications is available in [schema.json](./schema.json). Generators such as [quicktype.io](https://app.quicktype.io/) can be used to generate wrappers for specific programming language. Based on [instructions.csv](https://github.com/ton-community/ton-docs/blob/main/docs/learn/tvm-instructions/instructions.csv). @@ -16,42 +16,63 @@ Based on [instructions.csv](https://github.com/ton-community/ton-docs/blob/main/ | ------------ | ----------- | ----------- | doc | ✅ Implemented | Provides human-readable information about instructions. Can be useful to provide integrated docs to user, for example, in disassembler. | bytecode | ✅ Implemented | Describes instruction encoding. It contains information to determine, which instruction we are currently decoding and how to parse its operands. -| value_flow | ❌ Not implemented | Describes how instruction changes stack and registers. This part of specification allows to analyze how instructions interact with each other, so it becomes possible to implement high-level tools such as decompilers. +| value_flow | ✅ Implemented | Describes how instruction changes current stack. This part of specification allows to analyze how instructions interact with each other, so it becomes possible to implement high-level tools such as decompilers. | control_flow | ❌ Not implemented | Describes code flow. It helps to reconstruct a control flow graph. This part mainly contains semantics of cont_* category instructions. For example, both JMPX and CALLX transfers execution to continuation on stack, but only CALLX returns and JMPX is not. | aliases | ✅ Implemented | Specifies instruction aliases. Can be used to provide to user information about special cases (for example, SWAP is a special case of XCHG_0i with i = 1). +## Projects based on tvm-spec +1. [tvm-spec-example](https://github.com/hacker-volodya/tvm-spec-example), tiny TVM disassembler + ## Instruction Specification ### Example ```json { - "mnemonic": "XCHG_0I", + "mnemonic": "LDU", "doc": { - "category": "stack_basic", - "description": "Interchanges `s0` with `s[i]`, `1 <= i <= 15`.", - "gas": "18", - "fift": "s[i] XCHG0" + "category": "cell_parse", + "description": "Loads an unsigned `cc+1`-bit integer `x` from _Slice_ `s`.", + "gas": "26", + "fift": "[cc+1] LDU" }, "bytecode": { - "doc_opcode": "0i", - "tlb": "#0 i:(## 4) {1 <= i}", - "prefix": "0", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, + "doc_opcode": "D3cc", + "tlb": "#D3 cc:uint8", + "prefix": "D3", "operands": [ { - "name": "i", + "name": "c", "loader": "uint", "loader_args": { - "size": 4 + "size": 8 } } ] }, "value_flow": { - "doc_stack": "" + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } } } ``` @@ -77,8 +98,14 @@ Based on [instructions.csv](https://github.com/ton-community/ton-docs/blob/main/ | bytecode.operands[i].loader_args | Arguments for loader function, specified below. Optional, no arguments in case of absence. | value_flow | Information related to usage of stack and registers by instruction. Optional. | value_flow.doc_stack | Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value). Optional. +| value_flow.inputs | Incoming values constraints. Input is unconstrained if absent. +| value_flow.inputs.stack | Defines how current stack is used by instruction. Instruction must not operate on stack entries other than defined here. Required. +| value_flow.inputs.stack[i] | Stack entry or group of stack entries. +| value_flow.inputs.stack[i].type | Type of stack entry. Can be one of "simple", "const", "conditional", "tuple". Required. +| value_flow.inputs.stack[i].* | Properties for stack entries of each type are described below. +| value_flow.outputs | Outgoing values constraints. Output is unconstrained if absent. Identical to value_flow.inputs. -### Loaders specification and examples +### Loaders Specification and Examples #### uint ```json { @@ -158,6 +185,97 @@ Loads subslice of bit length `{bits_length_var} * 8 + bits_padding` and ref coun | refs_add | Constant integer value to add to ref count. Optional, assuming 1 if absent. | completion_tag | Boolean flag, tells to remove trailing `'1' + '0' * x` from bitstring if true. Optional, assuming false if absent. +### Stack Entry Specification and Examples + +#### Simple +```json +{ + "type": "simple", + "name": "c", + "value_types": ["Continuation"] +} +``` +Specifies a single stack entry, attaches `name` to it and optionally constraints its type by `value_types`. Possible types are `Integer`, `Cell`, `Builder`, `Slice`, `Tuple`, `Continuation`, `Null`. For example, dict is actually `"value_types": ["Slice", "Null"]` as it can be either Slice or Null. Absence of `value_types` means that this stack entry may be of any type. + +#### Const +```json +{ + "type": "const", + "value": 32, + "value_type": "Integer" +} +``` +Specifies a constant value on stack. `value_type` is either `Integer` or `Null`, with `number` type value for `Integer` and `null` value for `Null`. + +#### Conditional +```json +[ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } +] +``` +```json +[ + { + "type": "conditional", + "name": "x", + "match": [ + {"value": 0, "stack": []} + ], + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } +] +``` +Depending on `value` of variable specified in `name`, put values specified in corresponding arm of `match`. If `else` arm is not present, then input for this conditional may be only of specified values. + +#### Tuple +```json +{ + "type": "tuple", + "name": "x", + "length_var": "n" +} +``` +Specifies a bunch of stack entries with length from variable `length_var`, usually noted as `x_1 ... x_n`. Used in tuple and continuation arguments operations. + +#### Notes +1. Each variable name is unique across `operands` and `stack` sections of each instruction. Assumed that variables are immutable, so if variable `x` is defined both in inputs and outputs, it goes to output without any modification. +2. Value flow describes only `cc` stack usage before the actual jump or call. Subsequent continuations may have a separate stack, so this will be defined in control flow section of this spec. + ## Alias Specification ### Example ```json diff --git a/cp0.json b/cp0.json index f9fe34a..1479b5a 100644 --- a/cp0.json +++ b/cp0.json @@ -1,14395 +1,32101 @@ -{ - "$schema": "./schema.json", - "instructions": [ - { - "mnemonic": "NOP", - "doc": { - "category": "stack_basic", - "description": "Does nothing.", - "gas": "18", - "fift": "NOP" - }, - "bytecode": { - "doc_opcode": "00", - "tlb": "#00", - "prefix": "00", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "XCHG_0I", - "doc": { - "category": "stack_basic", - "description": "Interchanges `s0` with `s[i]`, `1 <= i <= 15`.", - "gas": "18", - "fift": "s[i] XCHG0" - }, - "bytecode": { - "doc_opcode": "0i", - "tlb": "#0 i:(## 4) {1 <= i}", - "prefix": "0", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG_IJ", - "doc": { - "category": "stack_basic", - "description": "Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.", - "gas": "26", - "fift": "s[i] s[j] XCHG" - }, - "bytecode": { - "doc_opcode": "10ij", - "tlb": "#10 i:(## 4) j:(## 4) {1 <= i} {i + 1 <= j}", - "prefix": "10", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG_0I_LONG", - "doc": { - "category": "stack_basic", - "description": "Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.", - "gas": "26", - "fift": "s0 [ii] s() XCHG" - }, - "bytecode": { - "doc_opcode": "11ii", - "tlb": "#11 ii:uint8", - "prefix": "11", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG_1I", - "doc": { - "category": "stack_basic", - "description": "Interchanges `s1` with `s[i]`, `2 <= i <= 15`.", - "gas": "18", - "fift": "s1 s[i] XCHG" - }, - "bytecode": { - "doc_opcode": "1i", - "tlb": "#1 i:(## 4) {2 <= i}", - "prefix": "1", - "operands_range_check": { - "length": 4, - "from": 2, - "to": 15 - }, - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUSH", - "doc": { - "category": "stack_basic", - "description": "Pushes a copy of the old `s[i]` into the stack.", - "gas": "18", - "fift": "s[i] PUSH" - }, - "bytecode": { - "doc_opcode": "2i", - "tlb": "#2 i:uint4", - "prefix": "2", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "POP", - "doc": { - "category": "stack_basic", - "description": "Pops the old `s0` value into the old `s[i]`.", - "gas": "18", - "fift": "s[i] POP" - }, - "bytecode": { - "doc_opcode": "3i", - "tlb": "#3 i:uint4", - "prefix": "3", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG3", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.", - "gas": "26", - "fift": "s[i] s[j] s[k] XCHG3" - }, - "bytecode": { - "doc_opcode": "4ijk", - "tlb": "#4 i:uint4 j:uint4 k:uint4", - "prefix": "4", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.", - "gas": "26", - "fift": "s[i] s[j] XCHG2" - }, - "bytecode": { - "doc_opcode": "50ij", - "tlb": "#50 i:uint4 j:uint4", - "prefix": "50", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCPU", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] XCHG0` `s[j] PUSH`.", - "gas": "26", - "fift": "s[i] s[j] XCPU" - }, - "bytecode": { - "doc_opcode": "51ij", - "tlb": "#51 i:uint4 j:uint4", - "prefix": "51", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUXC", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.", - "gas": "26", - "fift": "s[i] s[j-1] PUXC" - }, - "bytecode": { - "doc_opcode": "52ij", - "tlb": "#52 i:uint4 j:uint4", - "prefix": "52", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUSH2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] PUSH` `s[j+1] PUSH`.", - "gas": "26", - "fift": "s[i] s[j] PUSH2" - }, - "bytecode": { - "doc_opcode": "53ij", - "tlb": "#53 i:uint4 j:uint4", - "prefix": "53", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCHG3_ALT", - "doc": { - "category": "stack_complex", - "description": "Long form of `XCHG3`.", - "gas": "34", - "fift": "s[i] s[j] s[k] XCHG3_l" - }, - "bytecode": { - "doc_opcode": "540ijk", - "tlb": "#540 i:uint4 j:uint4 k:uint4", - "prefix": "540", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XC2PU", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.", - "gas": "34", - "fift": "s[i] s[j] s[k] XC2PU" - }, - "bytecode": { - "doc_opcode": "541ijk", - "tlb": "#541 i:uint4 j:uint4 k:uint4", - "prefix": "541", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCPUXC", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.", - "gas": "34", - "fift": "s[i] s[j] s[k-1] XCPUXC" - }, - "bytecode": { - "doc_opcode": "542ijk", - "tlb": "#542 i:uint4 j:uint4 k:uint4", - "prefix": "542", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "XCPU2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.", - "gas": "34", - "fift": "s[i] s[j] s[k] XCPU2" - }, - "bytecode": { - "doc_opcode": "543ijk", - "tlb": "#543 i:uint4 j:uint4 k:uint4", - "prefix": "543", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUXC2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.", - "gas": "34", - "fift": "s[i] s[j-1] s[k-1] PUXC2" - }, - "bytecode": { - "doc_opcode": "544ijk", - "tlb": "#544 i:uint4 j:uint4 k:uint4", - "prefix": "544", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUXCPU", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.", - "gas": "34", - "fift": "s[i] s[j-1] s[k-1] PUXCPU" - }, - "bytecode": { - "doc_opcode": "545ijk", - "tlb": "#545 i:uint4 j:uint4 k:uint4", - "prefix": "545", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PU2XC", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.", - "gas": "34", - "fift": "s[i] s[j-1] s[k-2] PU2XC" - }, - "bytecode": { - "doc_opcode": "546ijk", - "tlb": "#546 i:uint4 j:uint4 k:uint4", - "prefix": "546", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUSH3", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.", - "gas": "34", - "fift": "s[i] s[j] s[k] PUSH3" - }, - "bytecode": { - "doc_opcode": "547ijk", - "tlb": "#547 i:uint4 j:uint4 k:uint4", - "prefix": "547", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BLKSWAP", - "doc": { - "category": "stack_complex", - "description": "Permutes two blocks `s[j+i+1] \u0432\u0402\u00a6 s[j+1]` and `s[j] \u0432\u0402\u00a6 s0`.\n`0 <= i,j <= 15`\nEquivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.", - "gas": "26", - "fift": "[i+1] [j+1] BLKSWAP" - }, - "bytecode": { - "doc_opcode": "55ij", - "tlb": "#55 i:uint4 j:uint4", - "prefix": "55", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUSH_LONG", - "doc": { - "category": "stack_complex", - "description": "Pushes a copy of the old `s[ii]` into the stack.\n`0 <= ii <= 255`", - "gas": "26", - "fift": "[ii] s() PUSH" - }, - "bytecode": { - "doc_opcode": "56ii", - "tlb": "#56 ii:uint8", - "prefix": "56", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "POP_LONG", - "doc": { - "category": "stack_complex", - "description": "Pops the old `s0` value into the old `s[ii]`.\n`0 <= ii <= 255`", - "gas": "26", - "fift": "[ii] s() POP" - }, - "bytecode": { - "doc_opcode": "57ii", - "tlb": "#57 ii:uint8", - "prefix": "57", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "ROT", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.", - "gas": "18", - "fift": "ROT" - }, - "bytecode": { - "doc_opcode": "58", - "tlb": "#58", - "prefix": "58", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b c - b c a" - } - }, - { - "mnemonic": "ROTREV", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.", - "gas": "18", - "fift": "ROTREV\n-ROT" - }, - "bytecode": { - "doc_opcode": "59", - "tlb": "#59", - "prefix": "59", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b c - c a b" - } - }, - { - "mnemonic": "SWAP2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.", - "gas": "18", - "fift": "SWAP2\n2SWAP" - }, - "bytecode": { - "doc_opcode": "5A", - "tlb": "#5A", - "prefix": "5A", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b c d - c d a b" - } - }, - { - "mnemonic": "DROP2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `DROP` `DROP`.", - "gas": "18", - "fift": "DROP2\n2DROP" - }, - "bytecode": { - "doc_opcode": "5B", - "tlb": "#5B", - "prefix": "5B", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b - " - } - }, - { - "mnemonic": "DUP2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s1 s0 PUSH2`.", - "gas": "18", - "fift": "DUP2\n2DUP" - }, - "bytecode": { - "doc_opcode": "5C", - "tlb": "#5C", - "prefix": "5C", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b - a b a b" - } - }, - { - "mnemonic": "OVER2", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `s3 s2 PUSH2`.", - "gas": "18", - "fift": "OVER2\n2OVER" - }, - "bytecode": { - "doc_opcode": "5D", - "tlb": "#5D", - "prefix": "5D", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b c d - a b c d a b" - } - }, - { - "mnemonic": "REVERSE", - "doc": { - "category": "stack_complex", - "description": "Reverses the order of `s[j+i+1] \u0432\u0402\u00a6 s[j]`.", - "gas": "26", - "fift": "[i+2] [j] REVERSE" - }, - "bytecode": { - "doc_opcode": "5Eij", - "tlb": "#5E i:uint4 j:uint4", - "prefix": "5E", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BLKDROP", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `DROP` performed `i` times.", - "gas": "26", - "fift": "[i] BLKDROP" - }, - "bytecode": { - "doc_opcode": "5F0i", - "tlb": "#5F0 i:uint4", - "prefix": "5F0", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BLKPUSH", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `PUSH s(j)` performed `i` times.\n`1 <= i <= 15`, `0 <= j <= 15`.", - "gas": "26", - "fift": "[i] [j] BLKPUSH" - }, - "bytecode": { - "doc_opcode": "5Fij", - "tlb": "#5F i:(## 4) j:uint4 {1 <= i}", - "prefix": "5F", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PICK", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then performs `s[i] PUSH`.", - "gas": "18", - "fift": "PICK\nPUSHX" - }, - "bytecode": { - "doc_opcode": "60", - "tlb": "#60", - "prefix": "60", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "ROLLX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.", - "gas": "18", - "fift": "ROLLX" - }, - "bytecode": { - "doc_opcode": "61", - "tlb": "#61", - "prefix": "61", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "-ROLLX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.", - "gas": "18", - "fift": "-ROLLX\nROLLREVX" - }, - "bytecode": { - "doc_opcode": "62", - "tlb": "#62", - "prefix": "62", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BLKSWX", - "doc": { - "category": "stack_complex", - "description": "Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.", - "gas": "18", - "fift": "BLKSWX" - }, - "bytecode": { - "doc_opcode": "63", - "tlb": "#63", - "prefix": "63", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "REVX", - "doc": { - "category": "stack_complex", - "description": "Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.", - "gas": "18", - "fift": "REVX" - }, - "bytecode": { - "doc_opcode": "64", - "tlb": "#64", - "prefix": "64", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "DROPX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then performs `[i] BLKDROP`.", - "gas": "18", - "fift": "DROPX" - }, - "bytecode": { - "doc_opcode": "65", - "tlb": "#65", - "prefix": "65", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "TUCK", - "doc": { - "category": "stack_complex", - "description": "Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.", - "gas": "18", - "fift": "TUCK" - }, - "bytecode": { - "doc_opcode": "66", - "tlb": "#66", - "prefix": "66", - "operands": [] - }, - "value_flow": { - "doc_stack": "a b - b a b" - } - }, - { - "mnemonic": "XCHGX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then performs `s[i] XCHG`.", - "gas": "18", - "fift": "XCHGX" - }, - "bytecode": { - "doc_opcode": "67", - "tlb": "#67", - "prefix": "67", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "DEPTH", - "doc": { - "category": "stack_complex", - "description": "Pushes the current depth of the stack.", - "gas": "18", - "fift": "DEPTH" - }, - "bytecode": { - "doc_opcode": "68", - "tlb": "#68", - "prefix": "68", - "operands": [] - }, - "value_flow": { - "doc_stack": "- depth" - } - }, - { - "mnemonic": "CHKDEPTH", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.", - "gas": "18/58", - "fift": "CHKDEPTH" - }, - "bytecode": { - "doc_opcode": "69", - "tlb": "#69", - "prefix": "69", - "operands": [] - }, - "value_flow": { - "doc_stack": "i -" - } - }, - { - "mnemonic": "ONLYTOPX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then removes all but the top `i` elements.", - "gas": "18", - "fift": "ONLYTOPX" - }, - "bytecode": { - "doc_opcode": "6A", - "tlb": "#6A", - "prefix": "6A", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "ONLYX", - "doc": { - "category": "stack_complex", - "description": "Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.", - "gas": "18", - "fift": "ONLYX" - }, - "bytecode": { - "doc_opcode": "6B", - "tlb": "#6B", - "prefix": "6B", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BLKDROP2", - "doc": { - "category": "stack_complex", - "description": "Drops `i` stack elements under the top `j` elements.\n`1 <= i <= 15`, `0 <= j <= 15`\nEquivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.", - "gas": "26", - "fift": "[i] [j] BLKDROP2" - }, - "bytecode": { - "doc_opcode": "6Cij", - "tlb": "#6C i:(## 4) j:uint4 {1 <= i}", - "prefix": "6C", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "NULL", - "doc": { - "category": "tuple", - "description": "Pushes the only value of type _Null_.", - "gas": "18", - "fift": "NULL\nPUSHNULL" - }, - "bytecode": { - "doc_opcode": "6D", - "tlb": "#6D", - "prefix": "6D", - "operands": [] - }, - "value_flow": { - "doc_stack": " - null" - } - }, - { - "mnemonic": "ISNULL", - "doc": { - "category": "tuple", - "description": "Checks whether `x` is a _Null_, and returns `-1` or `0` accordingly.", - "gas": "18", - "fift": "ISNULL" - }, - "bytecode": { - "doc_opcode": "6E", - "tlb": "#6E", - "prefix": "6E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - ?" - } - }, - { - "mnemonic": "TUPLE", - "doc": { - "category": "tuple", - "description": "Creates a new _Tuple_ `t=(x_1, \u0432\u0402\u00a6 ,x_n)` containing `n` values `x_1`,..., `x_n`.\n`0 <= n <= 15`", - "gas": "26+n", - "fift": "[n] TUPLE" - }, - "bytecode": { - "doc_opcode": "6F0n", - "tlb": "#6F0 n:uint4", - "prefix": "6F0", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x_1 ... x_n - t" - } - }, - { - "mnemonic": "INDEX", - "doc": { - "category": "tuple", - "description": "Returns the `k`-th element of a _Tuple_ `t`.\n`0 <= k <= 15`.", - "gas": "26", - "fift": "[k] INDEX" - }, - "bytecode": { - "doc_opcode": "6F1k", - "tlb": "#6F1 k:uint4", - "prefix": "6F1", - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "t - x" - } - }, - { - "mnemonic": "UNTUPLE", - "doc": { - "category": "tuple", - "description": "Unpacks a _Tuple_ `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`.\nIf `t` is not a _Tuple_, or if `|t| != n`, a type check exception is thrown.", - "gas": "26+n", - "fift": "[n] UNTUPLE" - }, - "bytecode": { - "doc_opcode": "6F2n", - "tlb": "#6F2 n:uint4", - "prefix": "6F2", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "t - x_1 ... x_n" - } - }, - { - "mnemonic": "UNPACKFIRST", - "doc": { - "category": "tuple", - "description": "Unpacks first `0 <= k <= 15` elements of a _Tuple_ `t`.\nIf `|t|= |t|`, throws a range check exception.", - "gas": "26+|t|", - "fift": "[k] SETINDEX" - }, - "bytecode": { - "doc_opcode": "6F5k", - "tlb": "#6F5 k:uint4", - "prefix": "6F5", - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "t x - t'" - } - }, - { - "mnemonic": "INDEXQ", - "doc": { - "category": "tuple", - "description": "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`.", - "gas": "26", - "fift": "[k] INDEXQ" - }, - "bytecode": { - "doc_opcode": "6F6k", - "tlb": "#6F6 k:uint4", - "prefix": "6F6", - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "t - x" - } - }, - { - "mnemonic": "SETINDEXQ", - "doc": { - "category": "tuple", - "description": "Sets the `k`-th component of _Tuple_ `t` to `x`, where `0 <= k < 16`, and returns the resulting _Tuple_ `t'`.\nIf `|t| <= k`, first extends the original _Tuple_ to length `n\u0432\u0402\u2122=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).", - "gas": "26+|t\u0432\u0402\u2122|", - "fift": "[k] SETINDEXQ" - }, - "bytecode": { - "doc_opcode": "6F7k", - "tlb": "#6F7 k:uint4", - "prefix": "6F7", - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "t x - t'" - } - }, - { - "mnemonic": "TUPLEVAR", - "doc": { - "category": "tuple", - "description": "Creates a new _Tuple_ `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.", - "gas": "26+n", - "fift": "TUPLEVAR" - }, - "bytecode": { - "doc_opcode": "6F80", - "tlb": "#6F80", - "prefix": "6F80", - "operands": [] - }, - "value_flow": { - "doc_stack": "x_1 ... x_n n - t" - } - }, - { - "mnemonic": "INDEXVAR", - "doc": { - "category": "tuple", - "description": "Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.", - "gas": "26", - "fift": "INDEXVAR" - }, - "bytecode": { - "doc_opcode": "6F81", - "tlb": "#6F81", - "prefix": "6F81", - "operands": [] - }, - "value_flow": { - "doc_stack": "t k - x" - } - }, - { - "mnemonic": "UNTUPLEVAR", - "doc": { - "category": "tuple", - "description": "Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.", - "gas": "26+n", - "fift": "UNTUPLEVAR" - }, - "bytecode": { - "doc_opcode": "6F82", - "tlb": "#6F82", - "prefix": "6F82", - "operands": [] - }, - "value_flow": { - "doc_stack": "t n - x_1 ... x_n" - } - }, - { - "mnemonic": "UNPACKFIRSTVAR", - "doc": { - "category": "tuple", - "description": "Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.", - "gas": "26+n", - "fift": "UNPACKFIRSTVAR" - }, - "bytecode": { - "doc_opcode": "6F83", - "tlb": "#6F83", - "prefix": "6F83", - "operands": [] - }, - "value_flow": { - "doc_stack": "t n - x_1 ... x_n" - } - }, - { - "mnemonic": "EXPLODEVAR", - "doc": { - "category": "tuple", - "description": "Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.", - "gas": "26+m", - "fift": "EXPLODEVAR" - }, - "bytecode": { - "doc_opcode": "6F84", - "tlb": "#6F84", - "prefix": "6F84", - "operands": [] - }, - "value_flow": { - "doc_stack": "t n - x_1 ... x_m m" - } - }, - { - "mnemonic": "SETINDEXVAR", - "doc": { - "category": "tuple", - "description": "Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.", - "gas": "26+|t\u0432\u0402\u2122|", - "fift": "SETINDEXVAR" - }, - "bytecode": { - "doc_opcode": "6F85", - "tlb": "#6F85", - "prefix": "6F85", - "operands": [] - }, - "value_flow": { - "doc_stack": "t x k - t'" - } - }, - { - "mnemonic": "INDEXVARQ", - "doc": { - "category": "tuple", - "description": "Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.", - "gas": "26", - "fift": "INDEXVARQ" - }, - "bytecode": { - "doc_opcode": "6F86", - "tlb": "#6F86", - "prefix": "6F86", - "operands": [] - }, - "value_flow": { - "doc_stack": "t k - x" - } - }, - { - "mnemonic": "SETINDEXVARQ", - "doc": { - "category": "tuple", - "description": "Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.", - "gas": "26+|t\u0432\u0402\u2122|", - "fift": "SETINDEXVARQ" - }, - "bytecode": { - "doc_opcode": "6F87", - "tlb": "#6F87", - "prefix": "6F87", - "operands": [] - }, - "value_flow": { - "doc_stack": "t x k - t'" - } - }, - { - "mnemonic": "TLEN", - "doc": { - "category": "tuple", - "description": "Returns the length of a _Tuple_.", - "gas": "26", - "fift": "TLEN" - }, - "bytecode": { - "doc_opcode": "6F88", - "tlb": "#6F88", - "prefix": "6F88", - "operands": [] - }, - "value_flow": { - "doc_stack": "t - n" - } - }, - { - "mnemonic": "QTLEN", - "doc": { - "category": "tuple", - "description": "Similar to `TLEN`, but returns `-1` if `t` is not a _Tuple_.", - "gas": "26", - "fift": "QTLEN" - }, - "bytecode": { - "doc_opcode": "6F89", - "tlb": "#6F89", - "prefix": "6F89", - "operands": [] - }, - "value_flow": { - "doc_stack": "t - n or -1" - } - }, - { - "mnemonic": "ISTUPLE", - "doc": { - "category": "tuple", - "description": "Returns `-1` or `0` depending on whether `t` is a _Tuple_.", - "gas": "26", - "fift": "ISTUPLE" - }, - "bytecode": { - "doc_opcode": "6F8A", - "tlb": "#6F8A", - "prefix": "6F8A", - "operands": [] - }, - "value_flow": { - "doc_stack": "t - ?" - } - }, - { - "mnemonic": "LAST", - "doc": { - "category": "tuple", - "description": "Returns the last element of a non-empty _Tuple_ `t`.", - "gas": "26", - "fift": "LAST" - }, - "bytecode": { - "doc_opcode": "6F8B", - "tlb": "#6F8B", - "prefix": "6F8B", - "operands": [] - }, - "value_flow": { - "doc_stack": "t - x" - } - }, - { - "mnemonic": "TPUSH", - "doc": { - "category": "tuple", - "description": "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.", - "gas": "26+|t\u0432\u0402\u2122|", - "fift": "TPUSH\nCOMMA" - }, - "bytecode": { - "doc_opcode": "6F8C", - "tlb": "#6F8C", - "prefix": "6F8C", - "operands": [] - }, - "value_flow": { - "doc_stack": "t x - t'" - } - }, - { - "mnemonic": "TPOP", - "doc": { - "category": "tuple", - "description": "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`.", - "gas": "26+|t\u0432\u0402\u2122|", - "fift": "TPOP" - }, - "bytecode": { - "doc_opcode": "6F8D", - "tlb": "#6F8D", - "prefix": "6F8D", - "operands": [] - }, - "value_flow": { - "doc_stack": "t - t' x" - } - }, - { - "mnemonic": "NULLSWAPIF", - "doc": { - "category": "tuple", - "description": "Pushes a _Null_ under the topmost _Integer_ `x`, but only if `x!=0`.", - "gas": "26", - "fift": "NULLSWAPIF" - }, - "bytecode": { - "doc_opcode": "6FA0", - "tlb": "#6FA0", - "prefix": "6FA0", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x or null x" - } - }, - { - "mnemonic": "NULLSWAPIFNOT", - "doc": { - "category": "tuple", - "description": "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`.", - "gas": "26", - "fift": "NULLSWAPIFNOT" - }, - "bytecode": { - "doc_opcode": "6FA1", - "tlb": "#6FA1", - "prefix": "6FA1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x or null x" - } - }, - { - "mnemonic": "NULLROTRIF", - "doc": { - "category": "tuple", - "description": "Pushes a _Null_ under the second stack entry from the top, but only if the topmost _Integer_ `y` is non-zero.", - "gas": "26", - "fift": "NULLROTRIF" - }, - "bytecode": { - "doc_opcode": "6FA2", - "tlb": "#6FA2", - "prefix": "6FA2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x y or null x y" - } - }, - { - "mnemonic": "NULLROTRIFNOT", - "doc": { - "category": "tuple", - "description": "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`.", - "gas": "26", - "fift": "NULLROTRIFNOT" - }, - "bytecode": { - "doc_opcode": "6FA3", - "tlb": "#6FA3", - "prefix": "6FA3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x y or null x y" - } - }, - { - "mnemonic": "NULLSWAPIF2", - "doc": { - "category": "tuple", - "description": "Pushes two nulls under the topmost _Integer_ `x`, but only if `x!=0`.\nEquivalent to `NULLSWAPIF` `NULLSWAPIF`.", - "gas": "26", - "fift": "NULLSWAPIF2" - }, - "bytecode": { - "doc_opcode": "6FA4", - "tlb": "#6FA4", - "prefix": "6FA4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x or null null x" - } - }, - { - "mnemonic": "NULLSWAPIFNOT2", - "doc": { - "category": "tuple", - "description": "Pushes two nulls under the topmost _Integer_ `x`, but only if `x=0`.\nEquivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.", - "gas": "26", - "fift": "NULLSWAPIFNOT2" - }, - "bytecode": { - "doc_opcode": "6FA5", - "tlb": "#6FA5", - "prefix": "6FA5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x or null null x" - } - }, - { - "mnemonic": "NULLROTRIF2", - "doc": { - "category": "tuple", - "description": "Pushes two nulls under the second stack entry from the top, but only if the topmost _Integer_ `y` is non-zero.\nEquivalent to `NULLROTRIF` `NULLROTRIF`.", - "gas": "26", - "fift": "NULLROTRIF2" - }, - "bytecode": { - "doc_opcode": "6FA6", - "tlb": "#6FA6", - "prefix": "6FA6", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x y or null null x y" - } - }, - { - "mnemonic": "NULLROTRIFNOT2", - "doc": { - "category": "tuple", - "description": "Pushes two nulls under the second stack entry from the top, but only if the topmost _Integer_ `y` is zero.\nEquivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.", - "gas": "26", - "fift": "NULLROTRIFNOT2" - }, - "bytecode": { - "doc_opcode": "6FA7", - "tlb": "#6FA7", - "prefix": "6FA7", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x y or null null x y" - } - }, - { - "mnemonic": "INDEX2", - "doc": { - "category": "tuple", - "description": "Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.\nEquivalent to `[i] INDEX` `[j] INDEX`.", - "gas": "26", - "fift": "[i] [j] INDEX2" - }, - "bytecode": { - "doc_opcode": "6FBij", - "tlb": "#6FB i:uint2 j:uint2", - "prefix": "6FB", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 2 - } - } - ] - }, - "value_flow": { - "doc_stack": "t - x" - } - }, - { - "mnemonic": "INDEX3", - "doc": { - "category": "tuple", - "description": "Recovers `x=t_{i+1}_{j+1}_{k+1}`.\n`0 <= i,j,k <= 3`\nEquivalent to `[i] [j] INDEX2` `[k] INDEX`.", - "gas": "26", - "fift": "[i] [j] [k] INDEX3" - }, - "bytecode": { - "doc_opcode": "6FE_ijk", - "tlb": "#6FE_ i:uint2 j:uint2 k:uint2", - "prefix": "6FE_", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "j", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 2 - } - } - ] - }, - "value_flow": { - "doc_stack": "t - x" - } - }, - { - "mnemonic": "PUSHINT_4", - "doc": { - "category": "const_int", - "description": "Pushes integer `x` into the stack. `-5 <= x <= 10`.\nHere `i` equals four lower-order bits of `x` (`i=x mod 16`).", - "gas": "18", - "fift": "[x] PUSHINT\n[x] INT" - }, - "bytecode": { - "doc_opcode": "7i", - "tlb": "#7 i:uint4", - "prefix": "7", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "- x" - } - }, - { - "mnemonic": "PUSHINT_8", - "doc": { - "category": "const_int", - "description": "Pushes integer `xx`. `-128 <= xx <= 127`.", - "gas": "26", - "fift": "[xx] PUSHINT\n[xx] INT" - }, - "bytecode": { - "doc_opcode": "80xx", - "tlb": "#80 xx:int8", - "prefix": "80", - "operands": [ - { - "name": "x", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "- xx" - } - }, - { - "mnemonic": "PUSHINT_16", - "doc": { - "category": "const_int", - "description": "Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.", - "gas": "34", - "fift": "[xxxx] PUSHINT\n[xxxx] INT" - }, - "bytecode": { - "doc_opcode": "81xxxx", - "tlb": "#81 xxxx:int16", - "prefix": "81", - "operands": [ - { - "name": "x", - "loader": "int", - "loader_args": { - "size": 16 - } - } - ] - }, - "value_flow": { - "doc_stack": "- xxxx" - } - }, - { - "mnemonic": "PUSHINT_LONG", - "doc": { - "category": "const_int", - "description": "Pushes integer `xxx`.\n_Details:_ 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`.\nThe total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.", - "gas": "23", - "fift": "[xxx] PUSHINT\n[xxx] INT" - }, - "bytecode": { - "doc_opcode": "82lxxx", - "tlb": "#82 l:(## 5) xxx:(int (8 * l + 19))", - "prefix": "82", - "operands_range_check": { - "length": 5, - "from": 0, - "to": 30 - }, - "operands": [ - { - "name": "x", - "loader": "pushint_long", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "- xxx" - } - }, - { - "mnemonic": "PUSHPOW2", - "doc": { - "category": "const_int", - "description": "(Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.\n`2^256` is a `NaN`.", - "gas": "26", - "fift": "[xx+1] PUSHPOW2" - }, - "bytecode": { - "doc_opcode": "83xx", - "tlb": "#83 xx:uint8", - "prefix": "83", - "operands_range_check": { - "length": 8, - "from": 0, - "to": 255 - }, - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "- 2^(xx+1)" - } - }, - { - "mnemonic": "PUSHNAN", - "doc": { - "category": "const_int", - "description": "Pushes a `NaN`.", - "gas": "26", - "fift": "PUSHNAN" - }, - "bytecode": { - "doc_opcode": "83FF", - "tlb": "#83FF", - "prefix": "83FF", - "operands": [] - }, - "value_flow": { - "doc_stack": "- NaN" - } - }, - { - "mnemonic": "PUSHPOW2DEC", - "doc": { - "category": "const_int", - "description": "Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.", - "gas": "26", - "fift": "[xx+1] PUSHPOW2DEC" - }, - "bytecode": { - "doc_opcode": "84xx", - "tlb": "#84 xx:uint8", - "prefix": "84", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "- 2^(xx+1)-1" - } - }, - { - "mnemonic": "PUSHNEGPOW2", - "doc": { - "category": "const_int", - "description": "Pushes `-2^(xx+1)` for `0 <= xx <= 255`.", - "gas": "26", - "fift": "[xx+1] PUSHNEGPOW2" - }, - "bytecode": { - "doc_opcode": "85xx", - "tlb": "#85 xx:uint8", - "prefix": "85", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "- -2^(xx+1)" - } - }, - { - "mnemonic": "PUSHREF", - "doc": { - "category": "const_data", - "description": "Pushes the reference `ref` into the stack.\n_Details:_ Pushes the first reference of `cc.code` into the stack as a _Cell_ (and removes this reference from the current continuation).", - "gas": "18", - "fift": "[ref] PUSHREF" - }, - "bytecode": { - "doc_opcode": "88", - "tlb": "#88 c:^Cell", - "prefix": "88", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "- c" - } - }, - { - "mnemonic": "PUSHREFSLICE", - "doc": { - "category": "const_data", - "description": "Similar to `PUSHREF`, but converts the cell into a _Slice_.", - "gas": "118/43", - "fift": "[ref] PUSHREFSLICE" - }, - "bytecode": { - "doc_opcode": "89", - "tlb": "#89 c:^Cell", - "prefix": "89", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "- s" - } - }, - { - "mnemonic": "PUSHREFCONT", - "doc": { - "category": "const_data", - "description": "Similar to `PUSHREFSLICE`, but makes a simple ordinary _Continuation_ out of the cell.", - "gas": "118/43", - "fift": "[ref] PUSHREFCONT" - }, - "bytecode": { - "doc_opcode": "8A", - "tlb": "#8A c:^Cell", - "prefix": "8A", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "- cont" - } - }, - { - "mnemonic": "PUSHSLICE", - "doc": { - "category": "const_data", - "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.\nIf the original bitstring consists only of zeroes, an empty slice will be pushed.", - "gas": "22", - "fift": "[slice] PUSHSLICE\n[slice] SLICE" - }, - "bytecode": { - "doc_opcode": "8Bxsss", - "tlb": "#8B x:(## 4) sss:((8 * x + 4) * Bit)", - "prefix": "8B", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 4, - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "- s" - } - }, - { - "mnemonic": "PUSHSLICE_REFS", - "doc": { - "category": "const_data", - "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is also assumed.", - "gas": "25", - "fift": "[slice] PUSHSLICE\n[slice] SLICE" - }, - "bytecode": { - "doc_opcode": "8Crxxssss", - "tlb": "#8C r:(## 2) xx:(## 5) c:((r + 1) * ^Cell) ssss:((8 * xx + 1) * Bit)", - "prefix": "8C", - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 5 - } - }, - { - "name": "slice", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 1, - "refs_length_var": "r", - "refs_add": 1, - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "- s" - } - }, - { - "mnemonic": "PUSHSLICE_LONG", - "doc": { - "category": "const_data", - "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is assumed.", - "gas": "28", - "fift": "[slice] PUSHSLICE\n[slice] SLICE", - "fift_examples": [ - { - "fift": "x{} PUSHSLICE x{ABCD1234} PUSHSLICE b{01101} PUSHSLICE", - "description": "Examples of `PUSHSLICE`. `x{}` is an empty slice. `x{...}` is a hexadecimal literal. `b{...}` is a binary literal. More on slice literals [here](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-51-slice-literals). Note that the assembler can replace `PUSHSLICE` with `PUSHREFSLICE` in certain situations (e.g. if there’s not enough space in the current continuation)." - }, - { - "fift": " PUSHREF PUSHREFSLICE", - "description": "Examples of `PUSHREF` and `PUSHREFSLICE`. More on building cells in fift [here](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-52-builder-primitives)." - } - ] - }, - "bytecode": { - "doc_opcode": "8Drxxsssss", - "tlb": "#8D r:(#<= 4) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx + 6) * Bit)", - "prefix": "8D", - "operands_range_check": { - "length": 3, - "from": 0, - "to": 4 - }, - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 3 - } - }, - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 7 - } - }, - { - "name": "slice", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 6, - "refs_length_var": "r", - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "- s" - } - }, - { - "mnemonic": "PUSHCONT", - "doc": { - "category": "const_data", - "description": "Pushes a continuation made from `builder`.\n_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`.", - "gas": "26", - "fift": "[builder] PUSHCONT\n[builder] CONT" - }, - "bytecode": { - "doc_opcode": "8F_rxxcccc", - "tlb": "#8F_ r:(## 2) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx) * Bit)", - "prefix": "8F_", - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 7 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "xx", - "bits_padding": 0, - "refs_length_var": "r" - } - } - ] - }, - "value_flow": { - "doc_stack": "- c" - } - }, - { - "mnemonic": "PUSHCONT_SHORT", - "doc": { - "category": "const_data", - "description": "Pushes a continuation made from `builder`.\n_Details:_ Pushes an `x`-byte continuation for `0 <= x <= 15`.", - "gas": "18", - "fift": "[builder] PUSHCONT\n[builder] CONT", - "fift_examples": [ - { - "fift": "<{ code }> PUSHCONT <{ code }> CONT CONT:<{ code }>", - "description": "Pushes a continuation with code `code`. Note that the assembler can replace `PUSHCONT` with `PUSHREFCONT` in certain situations (e.g. if there’s not enough space in the current continuation)." - } - ] - }, - "bytecode": { - "doc_opcode": "9xccc", - "tlb": "#9 x:(## 4) ssss:((8 * x) * Bit)", - "prefix": "9", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 0 - } - } - ] - }, - "value_flow": { - "doc_stack": "- c" - } - }, - { - "mnemonic": "ADD", - "doc": { - "category": "arithm_basic", - "description": "", - "gas": "18", - "fift": "ADD" - }, - "bytecode": { - "doc_opcode": "A0", - "tlb": "#A0", - "prefix": "A0", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x+y" - } - }, - { - "mnemonic": "SUB", - "doc": { - "category": "arithm_basic", - "description": "", - "gas": "18", - "fift": "SUB" - }, - "bytecode": { - "doc_opcode": "A1", - "tlb": "#A1", - "prefix": "A1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x-y" - } - }, - { - "mnemonic": "SUBR", - "doc": { - "category": "arithm_basic", - "description": "Equivalent to `SWAP` `SUB`.", - "gas": "18", - "fift": "SUBR" - }, - "bytecode": { - "doc_opcode": "A2", - "tlb": "#A2", - "prefix": "A2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - y-x" - } - }, - { - "mnemonic": "NEGATE", - "doc": { - "category": "arithm_basic", - "description": "Equivalent to `-1 MULCONST` or to `ZERO SUBR`.\nNotice that it triggers an integer overflow exception if `x=-2^256`.", - "gas": "18", - "fift": "NEGATE" - }, - "bytecode": { - "doc_opcode": "A3", - "tlb": "#A3", - "prefix": "A3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - -x" - } - }, - { - "mnemonic": "INC", - "doc": { - "category": "arithm_basic", - "description": "Equivalent to `1 ADDCONST`.", - "gas": "18", - "fift": "INC" - }, - "bytecode": { - "doc_opcode": "A4", - "tlb": "#A4", - "prefix": "A4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x+1" - } - }, - { - "mnemonic": "DEC", - "doc": { - "category": "arithm_basic", - "description": "Equivalent to `-1 ADDCONST`.", - "gas": "18", - "fift": "DEC" - }, - "bytecode": { - "doc_opcode": "A5", - "tlb": "#A5", - "prefix": "A5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x-1" - } - }, - { - "mnemonic": "ADDCONST", - "doc": { - "category": "arithm_basic", - "description": "`-128 <= cc <= 127`.", - "gas": "26", - "fift": "[cc] ADDCONST\n[cc] ADDINT\n[-cc] SUBCONST\n[-cc] SUBINT" - }, - "bytecode": { - "doc_opcode": "A6cc", - "tlb": "#A6 cc:int8", - "prefix": "A6", - "operands": [ - { - "name": "c", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x+cc" - } - }, - { - "mnemonic": "MULCONST", - "doc": { - "category": "arithm_basic", - "description": "`-128 <= cc <= 127`.", - "gas": "26", - "fift": "[cc] MULCONST\n[cc] MULINT" - }, - "bytecode": { - "doc_opcode": "A7cc", - "tlb": "#A7 cc:int8", - "prefix": "A7", - "operands": [ - { - "name": "c", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x*cc" - } - }, - { - "mnemonic": "MUL", - "doc": { - "category": "arithm_basic", - "description": "", - "gas": "18", - "fift": "MUL" - }, - "bytecode": { - "doc_opcode": "A8", - "tlb": "#A8", - "prefix": "A8", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x*y" - } - }, - { - "mnemonic": "DIV", - "doc": { - "category": "arithm_div", - "description": "`q=floor(x/y)`, `r=x-y*q`", - "gas": "26", - "fift": "DIV" - }, - "bytecode": { - "doc_opcode": "A904", - "tlb": "#A904", - "prefix": "A904", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q" - } - }, - { - "mnemonic": "DIVR", - "doc": { - "category": "arithm_div", - "description": "`q\u0432\u0402\u2122=round(x/y)`, `r\u0432\u0402\u2122=x-y*q\u0432\u0402\u2122`", - "gas": "26", - "fift": "DIVR" - }, - "bytecode": { - "doc_opcode": "A905", - "tlb": "#A905", - "prefix": "A905", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q\u0432\u0402\u2122" - } - }, - { - "mnemonic": "DIVC", - "doc": { - "category": "arithm_div", - "description": "`q\u0432\u0402\u2122\u0432\u0402\u2122=ceil(x/y)`, `r\u0432\u0402\u2122\u0432\u0402\u2122=x-y*q\u0432\u0402\u2122\u0432\u0402\u2122`", - "gas": "26", - "fift": "DIVC" - }, - "bytecode": { - "doc_opcode": "A906", - "tlb": "#A906", - "prefix": "A906", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q''" - } - }, - { - "mnemonic": "MOD", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "MOD" - }, - "bytecode": { - "doc_opcode": "A908", - "tlb": "#A908", - "prefix": "A908", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - r" - } - }, - { - "mnemonic": "DIVMOD", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "DIVMOD" - }, - "bytecode": { - "doc_opcode": "A90C", - "tlb": "#A90C", - "prefix": "A90C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q r" - } - }, - { - "mnemonic": "DIVMODR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "DIVMODR" - }, - "bytecode": { - "doc_opcode": "A90D", - "tlb": "#A90D", - "prefix": "A90D", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q' r'" - } - }, - { - "mnemonic": "DIVMODC", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "DIVMODC" - }, - "bytecode": { - "doc_opcode": "A90E", - "tlb": "#A90E", - "prefix": "A90E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q'' r''" - } - }, - { - "mnemonic": "RSHIFTR_VAR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "RSHIFTR" - }, - "bytecode": { - "doc_opcode": "A925", - "tlb": "#A925", - "prefix": "A925", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - round(x/2^y)" - } - }, - { - "mnemonic": "RSHIFTC_VAR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "RSHIFTC" - }, - "bytecode": { - "doc_opcode": "A926", - "tlb": "#A926", - "prefix": "A926", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - ceil(x/2^y)" - } - }, - { - "mnemonic": "RSHIFTR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] RSHIFTR#" - }, - "bytecode": { - "doc_opcode": "A935tt", - "tlb": "#A935 tt:uint8", - "prefix": "A935", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - round(x/2^(tt+1))" - } - }, - { - "mnemonic": "RSHIFTC", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] RSHIFTC#" - }, - "bytecode": { - "doc_opcode": "A936tt", - "tlb": "#A936 tt:uint8", - "prefix": "A936", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - ceil(x/2^(tt+1))" - } - }, - { - "mnemonic": "MODPOW2", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "[tt+1] MODPOW2#" - }, - "bytecode": { - "doc_opcode": "A938tt", - "tlb": "#A938 tt:uint8", - "prefix": "A938", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x mod 2^(tt+1)" - } - }, - { - "mnemonic": "MULDIV", - "doc": { - "category": "arithm_div", - "description": "`q=floor(x*y/z)`", - "gas": "26", - "fift": "MULDIV" - }, - "bytecode": { - "doc_opcode": "A98", - "tlb": "#A984", - "prefix": "A984", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - q" - } - }, - { - "mnemonic": "MULDIVR", - "doc": { - "category": "arithm_div", - "description": "`q'=round(x*y/z)`", - "gas": "26", - "fift": "MULDIVR" - }, - "bytecode": { - "doc_opcode": "A985", - "tlb": "#A985", - "prefix": "A985", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - q'" - } - }, - { - "mnemonic": "MULDIVMOD", - "doc": { - "category": "arithm_div", - "description": "`q=floor(x*y/z)`, `r=x*y-z*q`", - "gas": "26", - "fift": "MULDIVMOD" - }, - "bytecode": { - "doc_opcode": "A98C", - "tlb": "#A98C", - "prefix": "A98C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - q r" - } - }, - { - "mnemonic": "MULRSHIFT_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "26", - "fift": "MULRSHIFT" - }, - "bytecode": { - "doc_opcode": "A9A4", - "tlb": "#A9A4", - "prefix": "A9A4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - floor(x*y/2^z)" - } - }, - { - "mnemonic": "MULRSHIFTR_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "26", - "fift": "MULRSHIFTR" - }, - "bytecode": { - "doc_opcode": "A9A5", - "tlb": "#A9A5", - "prefix": "A9A5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - round(x*y/2^z)" - } - }, - { - "mnemonic": "MULRSHIFTC_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "34", - "fift": "MULRSHIFTC" - }, - "bytecode": { - "doc_opcode": "A9A6", - "tlb": "#A9A6", - "prefix": "A9A6", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - ceil(x*y/2^z)" - } - }, - { - "mnemonic": "MULRSHIFT", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] MULRSHIFT#" - }, - "bytecode": { - "doc_opcode": "A9B4tt", - "tlb": "#A9B4 tt:uint8", - "prefix": "A9B4", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - floor(x*y/2^(tt+1))" - } - }, - { - "mnemonic": "MULRSHIFTR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] MULRSHIFTR#" - }, - "bytecode": { - "doc_opcode": "A9B5tt", - "tlb": "#A9B5 tt:uint8", - "prefix": "A9B5", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - round(x*y/2^(tt+1))" - } - }, - { - "mnemonic": "MULRSHIFTC", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "[tt+1] MULRSHIFTC#" - }, - "bytecode": { - "doc_opcode": "A9B6tt", - "tlb": "#A9B6 tt:uint8", - "prefix": "A9B6", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - ceil(x*y/2^(tt+1))" - } - }, - { - "mnemonic": "LSHIFTDIV_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "26", - "fift": "LSHIFTDIV" - }, - "bytecode": { - "doc_opcode": "A9C4", - "tlb": "#A9C4", - "prefix": "A9C4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - floor(2^z*x/y)" - } - }, - { - "mnemonic": "LSHIFTDIVR_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "26", - "fift": "LSHIFTDIVR" - }, - "bytecode": { - "doc_opcode": "A9C5", - "tlb": "#A9C5", - "prefix": "A9C5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - round(2^z*x/y)" - } - }, - { - "mnemonic": "LSHIFTDIVC_VAR", - "doc": { - "category": "arithm_div", - "description": "`0 <= z <= 256`", - "gas": "34", - "fift": "LSHIFTDIVC" - }, - "bytecode": { - "doc_opcode": "A9C6", - "tlb": "#A9C6", - "prefix": "A9C6", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - ceil(2^z*x/y)" - } - }, - { - "mnemonic": "LSHIFTDIV", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] LSHIFT#DIV" - }, - "bytecode": { - "doc_opcode": "A9D4tt", - "tlb": "#A9D4 tt:uint8", - "prefix": "A9D4", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - floor(2^(tt+1)*x/y)" - } - }, - { - "mnemonic": "LSHIFTDIVR", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "34", - "fift": "[tt+1] LSHIFT#DIVR" - }, - "bytecode": { - "doc_opcode": "A9D5tt", - "tlb": "#A9D5 tt:uint8", - "prefix": "A9D5", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - round(2^(tt+1)*x/y)" - } - }, - { - "mnemonic": "LSHIFTDIVC", - "doc": { - "category": "arithm_div", - "description": "", - "gas": "26", - "fift": "[tt+1] LSHIFT#DIVC" - }, - "bytecode": { - "doc_opcode": "A9D6tt", - "tlb": "#A9D6 tt:uint8", - "prefix": "A9D6", - "operands": [ - { - "name": "t", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x y - ceil(2^(tt+1)*x/y)" - } - }, - { - "mnemonic": "LSHIFT", - "doc": { - "category": "arithm_logical", - "description": "`0 <= cc <= 255`", - "gas": "26", - "fift": "[cc+1] LSHIFT#" - }, - "bytecode": { - "doc_opcode": "AAcc", - "tlb": "#AA cc:uint8", - "prefix": "AA", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x*2^(cc+1)" - } - }, - { - "mnemonic": "RSHIFT", - "doc": { - "category": "arithm_logical", - "description": "`0 <= cc <= 255`", - "gas": "18", - "fift": "[cc+1] RSHIFT#" - }, - "bytecode": { - "doc_opcode": "ABcc", - "tlb": "#AB cc:uint8", - "prefix": "AB", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - floor(x/2^(cc+1))" - } - }, - { - "mnemonic": "LSHIFT_VAR", - "doc": { - "category": "arithm_logical", - "description": "`0 <= y <= 1023`", - "gas": "18", - "fift": "LSHIFT" - }, - "bytecode": { - "doc_opcode": "AC", - "tlb": "#AC", - "prefix": "AC", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x*2^y" - } - }, - { - "mnemonic": "RSHIFT_VAR", - "doc": { - "category": "arithm_logical", - "description": "`0 <= y <= 1023`", - "gas": "18", - "fift": "RSHIFT" - }, - "bytecode": { - "doc_opcode": "AD", - "tlb": "#AD", - "prefix": "AD", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - floor(x/2^y)" - } - }, - { - "mnemonic": "POW2", - "doc": { - "category": "arithm_logical", - "description": "`0 <= y <= 1023`\nEquivalent to `ONE` `SWAP` `LSHIFT`.", - "gas": "18", - "fift": "POW2" - }, - "bytecode": { - "doc_opcode": "AE", - "tlb": "#AE", - "prefix": "AE", - "operands": [] - }, - "value_flow": { - "doc_stack": "y - 2^y" - } - }, - { - "mnemonic": "AND", - "doc": { - "category": "arithm_logical", - "description": "Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.", - "gas": "18", - "fift": "AND" - }, - "bytecode": { - "doc_opcode": "B0", - "tlb": "#B0", - "prefix": "B0", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x&y" - } - }, - { - "mnemonic": "OR", - "doc": { - "category": "arithm_logical", - "description": "Bitwise or of two integers.", - "gas": "18", - "fift": "OR" - }, - "bytecode": { - "doc_opcode": "B1", - "tlb": "#B1", - "prefix": "B1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x|y" - } - }, - { - "mnemonic": "XOR", - "doc": { - "category": "arithm_logical", - "description": "Bitwise xor of two integers.", - "gas": "18", - "fift": "XOR" - }, - "bytecode": { - "doc_opcode": "B2", - "tlb": "#B2", - "prefix": "B2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x xor y" - } - }, - { - "mnemonic": "NOT", - "doc": { - "category": "arithm_logical", - "description": "Bitwise not of an integer.", - "gas": "26", - "fift": "NOT" - }, - "bytecode": { - "doc_opcode": "B3", - "tlb": "#B3", - "prefix": "B3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - ~x" - } - }, - { - "mnemonic": "FITS", - "doc": { - "category": "arithm_logical", - "description": "Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`).\nIf not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).", - "gas": "26/76", - "fift": "[cc+1] FITS" - }, - "bytecode": { - "doc_opcode": "B4cc", - "tlb": "#B4 cc:uint8", - "prefix": "B4", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "UFITS", - "doc": { - "category": "arithm_logical", - "description": "Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).", - "gas": "26/76", - "fift": "[cc+1] UFITS" - }, - "bytecode": { - "doc_opcode": "B5cc", - "tlb": "#B5 cc:uint8", - "prefix": "B5", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "FITSX", - "doc": { - "category": "arithm_logical", - "description": "Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.", - "gas": "26/76", - "fift": "FITSX" - }, - "bytecode": { - "doc_opcode": "B600", - "tlb": "#B600", - "prefix": "B600", - "operands": [] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "UFITSX", - "doc": { - "category": "arithm_logical", - "description": "Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.", - "gas": "26/76", - "fift": "UFITSX" - }, - "bytecode": { - "doc_opcode": "B601", - "tlb": "#B601", - "prefix": "B601", - "operands": [] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "BITSIZE", - "doc": { - "category": "arithm_logical", - "description": "Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).", - "gas": "26", - "fift": "BITSIZE" - }, - "bytecode": { - "doc_opcode": "B602", - "tlb": "#B602", - "prefix": "B602", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - c" - } - }, - { - "mnemonic": "UBITSIZE", - "doc": { - "category": "arithm_logical", - "description": "Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.", - "gas": "26", - "fift": "UBITSIZE" - }, - "bytecode": { - "doc_opcode": "B603", - "tlb": "#B603", - "prefix": "B603", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - c" - } - }, - { - "mnemonic": "MIN", - "doc": { - "category": "arithm_logical", - "description": "Computes the minimum of two integers `x` and `y`.", - "gas": "26", - "fift": "MIN" - }, - "bytecode": { - "doc_opcode": "B608", - "tlb": "#B608", - "prefix": "B608", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x or y" - } - }, - { - "mnemonic": "MAX", - "doc": { - "category": "arithm_logical", - "description": "Computes the maximum of two integers `x` and `y`.", - "gas": "26", - "fift": "MAX" - }, - "bytecode": { - "doc_opcode": "B609", - "tlb": "#B609", - "prefix": "B609", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x or y" - } - }, - { - "mnemonic": "MINMAX", - "doc": { - "category": "arithm_logical", - "description": "Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.", - "gas": "26", - "fift": "MINMAX\nINTSORT2" - }, - "bytecode": { - "doc_opcode": "B60A", - "tlb": "#B60A", - "prefix": "B60A", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x y or y x" - } - }, - { - "mnemonic": "ABS", - "doc": { - "category": "arithm_logical", - "description": "Computes the absolute value of an integer `x`.", - "gas": "26", - "fift": "ABS" - }, - "bytecode": { - "doc_opcode": "B60B", - "tlb": "#B60B", - "prefix": "B60B", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - |x|" - } - }, - { - "mnemonic": "QADD", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QADD" - }, - "bytecode": { - "doc_opcode": "B7A0", - "tlb": "#B7A0", - "prefix": "B7A0", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x+y" - } - }, - { - "mnemonic": "QSUB", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QSUB" - }, - "bytecode": { - "doc_opcode": "B7A1", - "tlb": "#B7A1", - "prefix": "B7A1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x-y" - } - }, - { - "mnemonic": "QSUBR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QSUBR" - }, - "bytecode": { - "doc_opcode": "B7A2", - "tlb": "#B7A2", - "prefix": "B7A2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - y-x" - } - }, - { - "mnemonic": "QNEGATE", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QNEGATE" - }, - "bytecode": { - "doc_opcode": "B7A3", - "tlb": "#B7A3", - "prefix": "B7A3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - -x" - } - }, - { - "mnemonic": "QINC", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QINC" - }, - "bytecode": { - "doc_opcode": "B7A4", - "tlb": "#B7A4", - "prefix": "B7A4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x+1" - } - }, - { - "mnemonic": "QDEC", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QDEC" - }, - "bytecode": { - "doc_opcode": "B7A5", - "tlb": "#B7A5", - "prefix": "B7A5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x-1" - } - }, - { - "mnemonic": "QMUL", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QMUL" - }, - "bytecode": { - "doc_opcode": "B7A8", - "tlb": "#B7A8", - "prefix": "B7A8", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x*y" - } - }, - { - "mnemonic": "QDIV", - "doc": { - "category": "arithm_quiet", - "description": "Division returns `NaN` if `y=0`.", - "gas": "34", - "fift": "QDIV" - }, - "bytecode": { - "doc_opcode": "B7A904", - "tlb": "#B7A904", - "prefix": "B7A904", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q" - } - }, - { - "mnemonic": "QDIVR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QDIVR" - }, - "bytecode": { - "doc_opcode": "B7A905", - "tlb": "#B7A905", - "prefix": "B7A905", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q\u0432\u0402\u2122" - } - }, - { - "mnemonic": "QDIVC", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QDIVC" - }, - "bytecode": { - "doc_opcode": "B7A906", - "tlb": "#B7A906", - "prefix": "B7A906", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q''" - } - }, - { - "mnemonic": "QMOD", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QMOD" - }, - "bytecode": { - "doc_opcode": "B7A908", - "tlb": "#B7A908", - "prefix": "B7A908", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - r" - } - }, - { - "mnemonic": "QDIVMOD", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QDIVMOD" - }, - "bytecode": { - "doc_opcode": "B7A90C", - "tlb": "#B7A90C", - "prefix": "B7A90C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q r" - } - }, - { - "mnemonic": "QDIVMODR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QDIVMODR" - }, - "bytecode": { - "doc_opcode": "B7A90D", - "tlb": "#B7A90D", - "prefix": "B7A90D", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q' r'" - } - }, - { - "mnemonic": "QDIVMODC", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QDIVMODC" - }, - "bytecode": { - "doc_opcode": "B7A90E", - "tlb": "#B7A90E", - "prefix": "B7A90E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - q'' r''" - } - }, - { - "mnemonic": "QMULDIVR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QMULDIVR" - }, - "bytecode": { - "doc_opcode": "B7A985", - "tlb": "#B7A985", - "prefix": "B7A985", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - q'" - } - }, - { - "mnemonic": "QMULDIVMOD", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "34", - "fift": "QMULDIVMOD" - }, - "bytecode": { - "doc_opcode": "B7A98C", - "tlb": "#B7A98C", - "prefix": "B7A98C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y z - q r" - } - }, - { - "mnemonic": "QLSHIFT", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QLSHIFT" - }, - "bytecode": { - "doc_opcode": "B7AC", - "tlb": "#B7AC", - "prefix": "B7AC", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x*2^y" - } - }, - { - "mnemonic": "QRSHIFT", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QRSHIFT" - }, - "bytecode": { - "doc_opcode": "B7AD", - "tlb": "#B7AD", - "prefix": "B7AD", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - floor(x/2^y)" - } - }, - { - "mnemonic": "QPOW2", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QPOW2" - }, - "bytecode": { - "doc_opcode": "B7AE", - "tlb": "#B7AE", - "prefix": "B7AE", - "operands": [] - }, - "value_flow": { - "doc_stack": "y - 2^y" - } - }, - { - "mnemonic": "QAND", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QAND" - }, - "bytecode": { - "doc_opcode": "B7B0", - "tlb": "#B7B0", - "prefix": "B7B0", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x&y" - } - }, - { - "mnemonic": "QOR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QOR" - }, - "bytecode": { - "doc_opcode": "B7B1", - "tlb": "#B7B1", - "prefix": "B7B1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x|y" - } - }, - { - "mnemonic": "QXOR", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QXOR" - }, - "bytecode": { - "doc_opcode": "B7B2", - "tlb": "#B7B2", - "prefix": "B7B2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x xor y" - } - }, - { - "mnemonic": "QNOT", - "doc": { - "category": "arithm_quiet", - "description": "", - "gas": "26", - "fift": "QNOT" - }, - "bytecode": { - "doc_opcode": "B7B3", - "tlb": "#B7B3", - "prefix": "B7B3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - ~x" - } - }, - { - "mnemonic": "QFITS", - "doc": { - "category": "arithm_quiet", - "description": "Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.", - "gas": "34", - "fift": "[cc+1] QFITS" - }, - "bytecode": { - "doc_opcode": "B7B4cc", - "tlb": "#B7B4 cc:uint8", - "prefix": "B7B4", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "QUFITS", - "doc": { - "category": "arithm_quiet", - "description": "Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.", - "gas": "34", - "fift": "[cc+1] QUFITS" - }, - "bytecode": { - "doc_opcode": "B7B5cc", - "tlb": "#B7B5 cc:uint8", - "prefix": "B7B5", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "QFITSX", - "doc": { - "category": "arithm_quiet", - "description": "Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.", - "gas": "34", - "fift": "QFITSX" - }, - "bytecode": { - "doc_opcode": "B7B600", - "tlb": "#B7B600", - "prefix": "B7B600", - "operands": [] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "QUFITSX", - "doc": { - "category": "arithm_quiet", - "description": "Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.", - "gas": "34", - "fift": "QUFITSX" - }, - "bytecode": { - "doc_opcode": "B7B601", - "tlb": "#B7B601", - "prefix": "B7B601", - "operands": [] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "SGN", - "doc": { - "category": "compare_int", - "description": "Computes the sign of an integer `x`:\n`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.", - "gas": "18", - "fift": "SGN" - }, - "bytecode": { - "doc_opcode": "B8", - "tlb": "#B8", - "prefix": "B8", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - sgn(x)" - } - }, - { - "mnemonic": "LESS", - "doc": { - "category": "compare_int", - "description": "Returns `-1` if `xy" - } - }, - { - "mnemonic": "NEQ", - "doc": { - "category": "compare_int", - "description": "Equivalent to `EQUAL` `NOT`.", - "gas": "18", - "fift": "NEQ" - }, - "bytecode": { - "doc_opcode": "BD", - "tlb": "#BD", - "prefix": "BD", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x!=y" - } - }, - { - "mnemonic": "GEQ", - "doc": { - "category": "compare_int", - "description": "Equivalent to `LESS` `NOT`.", - "gas": "18", - "fift": "GEQ" - }, - "bytecode": { - "doc_opcode": "BE", - "tlb": "#BE", - "prefix": "BE", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - x>=y" - } - }, - { - "mnemonic": "CMP", - "doc": { - "category": "compare_int", - "description": "Computes the sign of `x-y`:\n`-1` if `xy`.\nNo integer overflow can occur here unless `x` or `y` is a `NaN`.", - "gas": "18", - "fift": "CMP" - }, - "bytecode": { - "doc_opcode": "BF", - "tlb": "#BF", - "prefix": "BF", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - sgn(x-y)" - } - }, - { - "mnemonic": "EQINT", - "doc": { - "category": "compare_int", - "description": "Returns `-1` if `x=yy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", - "gas": "26", - "fift": "[yy] EQINT" - }, - "bytecode": { - "doc_opcode": "C0yy", - "tlb": "#C0 yy:int8", - "prefix": "C0", - "operands": [ - { - "name": "y", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x=yy" - } - }, - { - "mnemonic": "LESSINT", - "doc": { - "category": "compare_int", - "description": "Returns `-1` if `xyy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", - "gas": "26", - "fift": "[yy] GTINT\n[yy+1] GEQINT" - }, - "bytecode": { - "doc_opcode": "C2yy", - "tlb": "#C2 yy:int8", - "prefix": "C2", - "operands": [ - { - "name": "y", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x>yy" - } - }, - { - "mnemonic": "NEQINT", - "doc": { - "category": "compare_int", - "description": "Returns `-1` if `x!=yy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", - "gas": "26", - "fift": "[yy] NEQINT" - }, - "bytecode": { - "doc_opcode": "C3yy", - "tlb": "#C3 yy:int8", - "prefix": "C3", - "operands": [ - { - "name": "y", - "loader": "int", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x!=yy" - } - }, - { - "mnemonic": "ISNAN", - "doc": { - "category": "compare_int", - "description": "Checks whether `x` is a `NaN`.", - "gas": "18", - "fift": "ISNAN" - }, - "bytecode": { - "doc_opcode": "C4", - "tlb": "#C4", - "prefix": "C4", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x=NaN" - } - }, - { - "mnemonic": "CHKNAN", - "doc": { - "category": "compare_int", - "description": "Throws an arithmetic overflow exception if `x` is a `NaN`.", - "gas": "18/68", - "fift": "CHKNAN" - }, - "bytecode": { - "doc_opcode": "C5", - "tlb": "#C5", - "prefix": "C5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "SEMPTY", - "doc": { - "category": "compare_other", - "description": "Checks whether a _Slice_ `s` is empty (i.e., contains no bits of data and no cell references).", - "gas": "26", - "fift": "SEMPTY" - }, - "bytecode": { - "doc_opcode": "C700", - "tlb": "#C700", - "prefix": "C700", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - ?" - } - }, - { - "mnemonic": "SDEMPTY", - "doc": { - "category": "compare_other", - "description": "Checks whether _Slice_ `s` has no bits of data.", - "gas": "26", - "fift": "SDEMPTY" - }, - "bytecode": { - "doc_opcode": "C701", - "tlb": "#C701", - "prefix": "C701", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - ?" - } - }, - { - "mnemonic": "SREMPTY", - "doc": { - "category": "compare_other", - "description": "Checks whether _Slice_ `s` has no references.", - "gas": "26", - "fift": "SREMPTY" - }, - "bytecode": { - "doc_opcode": "C702", - "tlb": "#C702", - "prefix": "C702", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - ?" - } - }, - { - "mnemonic": "SDFIRST", - "doc": { - "category": "compare_other", - "description": "Checks whether the first bit of _Slice_ `s` is a one.", - "gas": "26", - "fift": "SDFIRST" - }, - "bytecode": { - "doc_opcode": "C703", - "tlb": "#C703", - "prefix": "C703", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - ?" - } - }, - { - "mnemonic": "SDLEXCMP", - "doc": { - "category": "compare_other", - "description": "Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.", - "gas": "26", - "fift": "SDLEXCMP" - }, - "bytecode": { - "doc_opcode": "C704", - "tlb": "#C704", - "prefix": "C704", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - x" - } - }, - { - "mnemonic": "SDEQ", - "doc": { - "category": "compare_other", - "description": "Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.", - "gas": "26", - "fift": "SDEQ" - }, - "bytecode": { - "doc_opcode": "C705", - "tlb": "#C705", - "prefix": "C705", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPFX", - "doc": { - "category": "compare_other", - "description": "Checks whether `s` is a prefix of `s'`.", - "gas": "26", - "fift": "SDPFX" - }, - "bytecode": { - "doc_opcode": "C708", - "tlb": "#C708", - "prefix": "C708", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPFXREV", - "doc": { - "category": "compare_other", - "description": "Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.", - "gas": "26", - "fift": "SDPFXREV" - }, - "bytecode": { - "doc_opcode": "C709", - "tlb": "#C709", - "prefix": "C709", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPPFX", - "doc": { - "category": "compare_other", - "description": "Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).", - "gas": "26", - "fift": "SDPPFX" - }, - "bytecode": { - "doc_opcode": "C70A", - "tlb": "#C70A", - "prefix": "C70A", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPPFXREV", - "doc": { - "category": "compare_other", - "description": "Checks whether `s'` is a proper prefix of `s`.", - "gas": "26", - "fift": "SDPPFXREV" - }, - "bytecode": { - "doc_opcode": "C70B", - "tlb": "#C70B", - "prefix": "C70B", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDSFX", - "doc": { - "category": "compare_other", - "description": "Checks whether `s` is a suffix of `s'`.", - "gas": "26", - "fift": "SDSFX" - }, - "bytecode": { - "doc_opcode": "C70C", - "tlb": "#C70C", - "prefix": "C70C", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDSFXREV", - "doc": { - "category": "compare_other", - "description": "Checks whether `s'` is a suffix of `s`.", - "gas": "26", - "fift": "SDSFXREV" - }, - "bytecode": { - "doc_opcode": "C70D", - "tlb": "#C70D", - "prefix": "C70D", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPSFX", - "doc": { - "category": "compare_other", - "description": "Checks whether `s` is a proper suffix of `s'`.", - "gas": "26", - "fift": "SDPSFX" - }, - "bytecode": { - "doc_opcode": "C70E", - "tlb": "#C70E", - "prefix": "C70E", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDPSFXREV", - "doc": { - "category": "compare_other", - "description": "Checks whether `s'` is a proper suffix of `s`.", - "gas": "26", - "fift": "SDPSFXREV" - }, - "bytecode": { - "doc_opcode": "C70F", - "tlb": "#C70F", - "prefix": "C70F", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - ?" - } - }, - { - "mnemonic": "SDCNTLEAD0", - "doc": { - "category": "compare_other", - "description": "Returns the number of leading zeroes in `s`.", - "gas": "26", - "fift": "SDCNTLEAD0" - }, - "bytecode": { - "doc_opcode": "C710", - "tlb": "#C710", - "prefix": "C710", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n" - } - }, - { - "mnemonic": "SDCNTLEAD1", - "doc": { - "category": "compare_other", - "description": "Returns the number of leading ones in `s`.", - "gas": "26", - "fift": "SDCNTLEAD1" - }, - "bytecode": { - "doc_opcode": "C711", - "tlb": "#C711", - "prefix": "C711", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n" - } - }, - { - "mnemonic": "SDCNTTRAIL0", - "doc": { - "category": "compare_other", - "description": "Returns the number of trailing zeroes in `s`.", - "gas": "26", - "fift": "SDCNTTRAIL0" - }, - "bytecode": { - "doc_opcode": "C712", - "tlb": "#C712", - "prefix": "C712", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n" - } - }, - { - "mnemonic": "SDCNTTRAIL1", - "doc": { - "category": "compare_other", - "description": "Returns the number of trailing ones in `s`.", - "gas": "26", - "fift": "SDCNTTRAIL1" - }, - "bytecode": { - "doc_opcode": "C713", - "tlb": "#C713", - "prefix": "C713", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n" - } - }, - { - "mnemonic": "NEWC", - "doc": { - "category": "cell_build", - "description": "Creates a new empty _Builder_.", - "gas": "18", - "fift": "NEWC" - }, - "bytecode": { - "doc_opcode": "C8", - "tlb": "#C8", - "prefix": "C8", - "operands": [] - }, - "value_flow": { - "doc_stack": "- b" - } - }, - { - "mnemonic": "ENDC", - "doc": { - "category": "cell_build", - "description": "Converts a _Builder_ into an ordinary _Cell_.", - "gas": "518", - "fift": "ENDC" - }, - "bytecode": { - "doc_opcode": "C9", - "tlb": "#C9", - "prefix": "C9", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - c" - } - }, - { - "mnemonic": "STI", - "doc": { - "category": "cell_build", - "description": "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.", - "gas": "26", - "fift": "[cc+1] STI" - }, - "bytecode": { - "doc_opcode": "CAcc", - "tlb": "#CA cc:uint8", - "prefix": "CA", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STU", - "doc": { - "category": "cell_build", - "description": "Stores an unsigned `cc+1`-bit integer `x` into _Builder_ `b`. In all other respects it is similar to `STI`.", - "gas": "26", - "fift": "[cc+1] STU" - }, - "bytecode": { - "doc_opcode": "CBcc", - "tlb": "#CB cc:uint8", - "prefix": "CB", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STREF", - "doc": { - "category": "cell_build", - "description": "Stores a reference to _Cell_ `c` into _Builder_ `b`.", - "gas": "18", - "fift": "STREF" - }, - "bytecode": { - "doc_opcode": "CC", - "tlb": "#CC", - "prefix": "CC", - "operands": [] - }, - "value_flow": { - "doc_stack": "c b - b'" - } - }, - { - "mnemonic": "STBREFR", - "doc": { - "category": "cell_build", - "description": "Equivalent to `ENDC` `SWAP` `STREF`.", - "gas": "518", - "fift": "STBREFR\nENDCST" - }, - "bytecode": { - "doc_opcode": "CD", - "tlb": "#CD", - "prefix": "CD", - "operands": [] - }, - "value_flow": { - "doc_stack": "b b'' - b" - } - }, - { - "mnemonic": "STSLICE", - "doc": { - "category": "cell_build", - "description": "Stores _Slice_ `s` into _Builder_ `b`.", - "gas": "18", - "fift": "STSLICE" - }, - "bytecode": { - "doc_opcode": "CE", - "tlb": "#CE", - "prefix": "CE", - "operands": [] - }, - "value_flow": { - "doc_stack": "s b - b'" - } - }, - { - "mnemonic": "STIX", - "doc": { - "category": "cell_build", - "description": "Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.", - "gas": "26", - "fift": "STIX" - }, - "bytecode": { - "doc_opcode": "CF00", - "tlb": "#CF00", - "prefix": "CF00", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b l - b'" - } - }, - { - "mnemonic": "STUX", - "doc": { - "category": "cell_build", - "description": "Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.", - "gas": "26", - "fift": "STUX" - }, - "bytecode": { - "doc_opcode": "CF01", - "tlb": "#CF01", - "prefix": "CF01", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b l - b'" - } - }, - { - "mnemonic": "STIXR", - "doc": { - "category": "cell_build", - "description": "Similar to `STIX`, but with arguments in a different order.", - "gas": "26", - "fift": "STIXR" - }, - "bytecode": { - "doc_opcode": "CF02", - "tlb": "#CF02", - "prefix": "CF02", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x l - b'" - } - }, - { - "mnemonic": "STUXR", - "doc": { - "category": "cell_build", - "description": "Similar to `STUX`, but with arguments in a different order.", - "gas": "26", - "fift": "STUXR" - }, - "bytecode": { - "doc_opcode": "CF03", - "tlb": "#CF03", - "prefix": "CF03", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x l - b'" - } - }, - { - "mnemonic": "STIXQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`.\nIf `x` does not fit into `l` bits, sets `b'=b` and `f=1`.\nIf the operation succeeds, `b'` is the new _Builder_ and `f=0`.\nHowever, `0 <= l <= 257`, with a range check exception if this is not so.", - "gas": "26", - "fift": "STIXQ" - }, - "bytecode": { - "doc_opcode": "CF04", - "tlb": "#CF04", - "prefix": "CF04", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b l - x b f or b' 0" - } - }, - { - "mnemonic": "STUXQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STUX`.", - "gas": "26", - "fift": "STUXQ" - }, - "bytecode": { - "doc_opcode": "CF05", - "tlb": "#CF05", - "prefix": "CF05", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b l - x b f or b' 0" - } - }, - { - "mnemonic": "STIXRQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STIXR`.", - "gas": "26", - "fift": "STIXRQ" - }, - "bytecode": { - "doc_opcode": "CF06", - "tlb": "#CF06", - "prefix": "CF06", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x l - b x f or b' 0" - } - }, - { - "mnemonic": "STUXRQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STUXR`.", - "gas": "26", - "fift": "STUXRQ" - }, - "bytecode": { - "doc_opcode": "CF07", - "tlb": "#CF07", - "prefix": "CF07", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x l - b x f or b' 0" - } - }, - { - "mnemonic": "STI_ALT", - "doc": { - "category": "cell_build", - "description": "A longer version of `[cc+1] STI`.", - "gas": "34", - "fift": "[cc+1] STI_l" - }, - "bytecode": { - "doc_opcode": "CF08cc", - "tlb": "#CF08 cc:uint8", - "prefix": "CF08", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STU_ALT", - "doc": { - "category": "cell_build", - "description": "A longer version of `[cc+1] STU`.", - "gas": "34", - "fift": "[cc+1] STU_l" - }, - "bytecode": { - "doc_opcode": "CF09cc", - "tlb": "#CF09 cc:uint8", - "prefix": "CF09", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STIR", - "doc": { - "category": "cell_build", - "description": "Equivalent to `SWAP` `[cc+1] STI`.", - "gas": "34", - "fift": "[cc+1] STIR" - }, - "bytecode": { - "doc_opcode": "CF0Acc", - "tlb": "#CF0A cc:uint8", - "prefix": "CF0A", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b x - b'" - } - }, - { - "mnemonic": "STUR", - "doc": { - "category": "cell_build", - "description": "Equivalent to `SWAP` `[cc+1] STU`.", - "gas": "34", - "fift": "[cc+1] STUR" - }, - "bytecode": { - "doc_opcode": "CF0Bcc", - "tlb": "#CF0B cc:uint8", - "prefix": "CF0B", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b x - b'" - } - }, - { - "mnemonic": "STIQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STI`.", - "gas": "34", - "fift": "[cc+1] STIQ" - }, - "bytecode": { - "doc_opcode": "CF0Ccc", - "tlb": "#CF0C cc:uint8", - "prefix": "CF0C", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - x b f or b' 0" - } - }, - { - "mnemonic": "STUQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STU`.", - "gas": "34", - "fift": "[cc+1] STUQ" - }, - "bytecode": { - "doc_opcode": "CF0Dcc", - "tlb": "#CF0D cc:uint8", - "prefix": "CF0D", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "x b - x b f or b' 0" - } - }, - { - "mnemonic": "STIRQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STIR`.", - "gas": "34", - "fift": "[cc+1] STIRQ" - }, - "bytecode": { - "doc_opcode": "CF0Ecc", - "tlb": "#CF0E cc:uint8", - "prefix": "CF0E", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b x - b x f or b' 0" - } - }, - { - "mnemonic": "STURQ", - "doc": { - "category": "cell_build", - "description": "A quiet version of `STUR`.", - "gas": "34", - "fift": "[cc+1] STURQ" - }, - "bytecode": { - "doc_opcode": "CF0Fcc", - "tlb": "#CF0F cc:uint8", - "prefix": "CF0F", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b x - b x f or b' 0" - } - }, - { - "mnemonic": "STREF_ALT", - "doc": { - "category": "cell_build", - "description": "A longer version of `STREF`.", - "gas": "26", - "fift": "STREF_l" - }, - "bytecode": { - "doc_opcode": "CF10", - "tlb": "#CF10", - "prefix": "CF10", - "operands": [] - }, - "value_flow": { - "doc_stack": "c b - b'" - } - }, - { - "mnemonic": "STBREF", - "doc": { - "category": "cell_build", - "description": "Equivalent to `SWAP` `STBREFR`.", - "gas": "526", - "fift": "STBREF" - }, - "bytecode": { - "doc_opcode": "CF11", - "tlb": "#CF11", - "prefix": "CF11", - "operands": [] - }, - "value_flow": { - "doc_stack": "b' b - b''" - } - }, - { - "mnemonic": "STSLICE_ALT", - "doc": { - "category": "cell_build", - "description": "A longer version of `STSLICE`.", - "gas": "26", - "fift": "STSLICE_l" - }, - "bytecode": { - "doc_opcode": "CF12", - "tlb": "#CF12", - "prefix": "CF12", - "operands": [] - }, - "value_flow": { - "doc_stack": "s b - b'" - } - }, - { - "mnemonic": "STB", - "doc": { - "category": "cell_build", - "description": "Appends all data from _Builder_ `b'` to _Builder_ `b`.", - "gas": "26", - "fift": "STB" - }, - "bytecode": { - "doc_opcode": "CF13", - "tlb": "#CF13", - "prefix": "CF13", - "operands": [] - }, - "value_flow": { - "doc_stack": "b' b - b''" - } - }, - { - "mnemonic": "STREFR", - "doc": { - "category": "cell_build", - "description": "Equivalent to `SWAP` `STREF`.", - "gas": "26", - "fift": "STREFR" - }, - "bytecode": { - "doc_opcode": "CF14", - "tlb": "#CF14", - "prefix": "CF14", - "operands": [] - }, - "value_flow": { - "doc_stack": "b c - b'" - } - }, - { - "mnemonic": "STBREFR_ALT", - "doc": { - "category": "cell_build", - "description": "A longer encoding of `STBREFR`.", - "gas": "526", - "fift": "STBREFR_l" - }, - "bytecode": { - "doc_opcode": "CF15", - "tlb": "#CF15", - "prefix": "CF15", - "operands": [] - }, - "value_flow": { - "doc_stack": "b b' - b''" - } - }, - { - "mnemonic": "STSLICER", - "doc": { - "category": "cell_build", - "description": "Equivalent to `SWAP` `STSLICE`.", - "gas": "26", - "fift": "STSLICER" - }, - "bytecode": { - "doc_opcode": "CF16", - "tlb": "#CF16", - "prefix": "CF16", - "operands": [] - }, - "value_flow": { - "doc_stack": "b s - b'" - } - }, - { - "mnemonic": "STBR", - "doc": { - "category": "cell_build", - "description": "Concatenates two builders.\nEquivalent to `SWAP` `STB`.", - "gas": "26", - "fift": "STBR\nBCONCAT" - }, - "bytecode": { - "doc_opcode": "CF17", - "tlb": "#CF17", - "prefix": "CF17", - "operands": [] - }, - "value_flow": { - "doc_stack": "b b' - b''" - } - }, - { - "mnemonic": "STREFQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STREF`.", - "gas": "26", - "fift": "STREFQ" - }, - "bytecode": { - "doc_opcode": "CF18", - "tlb": "#CF18", - "prefix": "CF18", - "operands": [] - }, - "value_flow": { - "doc_stack": "c b - c b -1 or b' 0" - } - }, - { - "mnemonic": "STBREFQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STBREF`.", - "gas": "526", - "fift": "STBREFQ" - }, - "bytecode": { - "doc_opcode": "CF19", - "tlb": "#CF19", - "prefix": "CF19", - "operands": [] - }, - "value_flow": { - "doc_stack": "b' b - b' b -1 or b'' 0" - } - }, - { - "mnemonic": "STSLICEQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STSLICE`.", - "gas": "26", - "fift": "STSLICEQ" - }, - "bytecode": { - "doc_opcode": "CF1A", - "tlb": "#CF1A", - "prefix": "CF1A", - "operands": [] - }, - "value_flow": { - "doc_stack": "s b - s b -1 or b' 0" - } - }, - { - "mnemonic": "STBQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STB`.", - "gas": "26", - "fift": "STBQ" - }, - "bytecode": { - "doc_opcode": "CF1B", - "tlb": "#CF1B", - "prefix": "CF1B", - "operands": [] - }, - "value_flow": { - "doc_stack": "b' b - b' b -1 or b'' 0" - } - }, - { - "mnemonic": "STREFRQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STREFR`.", - "gas": "26", - "fift": "STREFRQ" - }, - "bytecode": { - "doc_opcode": "CF1C", - "tlb": "#CF1C", - "prefix": "CF1C", - "operands": [] - }, - "value_flow": { - "doc_stack": "b c - b c -1 or b' 0" - } - }, - { - "mnemonic": "STBREFRQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STBREFR`.", - "gas": "526", - "fift": "STBREFRQ" - }, - "bytecode": { - "doc_opcode": "CF1D", - "tlb": "#CF1D", - "prefix": "CF1D", - "operands": [] - }, - "value_flow": { - "doc_stack": "b b' - b b' -1 or b'' 0" - } - }, - { - "mnemonic": "STSLICERQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STSLICER`.", - "gas": "26", - "fift": "STSLICERQ" - }, - "bytecode": { - "doc_opcode": "CF1E", - "tlb": "#CF1E", - "prefix": "CF1E", - "operands": [] - }, - "value_flow": { - "doc_stack": "b s - b s -1 or b'' 0" - } - }, - { - "mnemonic": "STBRQ", - "doc": { - "category": "cell_build", - "description": "Quiet version of `STBR`.", - "gas": "26", - "fift": "STBRQ\nBCONCATQ" - }, - "bytecode": { - "doc_opcode": "CF1F", - "tlb": "#CF1F", - "prefix": "CF1F", - "operands": [] - }, - "value_flow": { - "doc_stack": "b b' - b b' -1 or b'' 0" - } - }, - { - "mnemonic": "STREFCONST", - "doc": { - "category": "cell_build", - "description": "Equivalent to `PUSHREF` `STREFR`.", - "gas": "26", - "fift": "[ref] STREFCONST" - }, - "bytecode": { - "doc_opcode": "CF20", - "tlb": "#CF20 c:^Cell", - "prefix": "CF20", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "b - b\u0432\u0402\u2122" - } - }, - { - "mnemonic": "STREF2CONST", - "doc": { - "category": "cell_build", - "description": "Equivalent to `STREFCONST` `STREFCONST`.", - "gas": "26", - "fift": "[ref] [ref] STREF2CONST" - }, - "bytecode": { - "doc_opcode": "CF21", - "tlb": "#CF21 c1:^Cell c2:^Cell", - "prefix": "CF21", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - b\u0432\u0402\u2122" - } - }, - { - "mnemonic": "ENDXC", - "doc": { - "category": "cell_build", - "description": "If `x!=0`, creates a _special_ or _exotic_ cell from _Builder_ `b`.\nThe type of the exotic cell must be stored in the first 8 bits of `b`.\nIf `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.", - "gas": "526", - "fift": "" - }, - "bytecode": { - "doc_opcode": "CF23", - "tlb": "#CF23", - "prefix": "CF23", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x - c" - } - }, - { - "mnemonic": "STILE4", - "doc": { - "category": "cell_build", - "description": "Stores a little-endian signed 32-bit integer.", - "gas": "26", - "fift": "STILE4" - }, - "bytecode": { - "doc_opcode": "CF28", - "tlb": "#CF28", - "prefix": "CF28", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STULE4", - "doc": { - "category": "cell_build", - "description": "Stores a little-endian unsigned 32-bit integer.", - "gas": "26", - "fift": "STULE4" - }, - "bytecode": { - "doc_opcode": "CF29", - "tlb": "#CF29", - "prefix": "CF29", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STILE8", - "doc": { - "category": "cell_build", - "description": "Stores a little-endian signed 64-bit integer.", - "gas": "26", - "fift": "STILE8" - }, - "bytecode": { - "doc_opcode": "CF2A", - "tlb": "#CF2A", - "prefix": "CF2A", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "STULE8", - "doc": { - "category": "cell_build", - "description": "Stores a little-endian unsigned 64-bit integer.", - "gas": "26", - "fift": "STULE8" - }, - "bytecode": { - "doc_opcode": "CF2B", - "tlb": "#CF2B", - "prefix": "CF2B", - "operands": [] - }, - "value_flow": { - "doc_stack": "x b - b'" - } - }, - { - "mnemonic": "BDEPTH", - "doc": { - "category": "cell_build", - "description": "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`.", - "gas": "26", - "fift": "BDEPTH" - }, - "bytecode": { - "doc_opcode": "CF30", - "tlb": "#CF30", - "prefix": "CF30", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - x" - } - }, - { - "mnemonic": "BBITS", - "doc": { - "category": "cell_build", - "description": "Returns the number of data bits already stored in _Builder_ `b`.", - "gas": "26", - "fift": "BBITS" - }, - "bytecode": { - "doc_opcode": "CF31", - "tlb": "#CF31", - "prefix": "CF31", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - x" - } - }, - { - "mnemonic": "BREFS", - "doc": { - "category": "cell_build", - "description": "Returns the number of cell references already stored in `b`.", - "gas": "26", - "fift": "BREFS" - }, - "bytecode": { - "doc_opcode": "CF32", - "tlb": "#CF32", - "prefix": "CF32", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - y" - } - }, - { - "mnemonic": "BBITREFS", - "doc": { - "category": "cell_build", - "description": "Returns the numbers of both data bits and cell references in `b`.", - "gas": "26", - "fift": "BBITREFS" - }, - "bytecode": { - "doc_opcode": "CF33", - "tlb": "#CF33", - "prefix": "CF33", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - x y" - } - }, - { - "mnemonic": "BREMBITS", - "doc": { - "category": "cell_build", - "description": "Returns the number of data bits that can still be stored in `b`.", - "gas": "26", - "fift": "BREMBITS" - }, - "bytecode": { - "doc_opcode": "CF35", - "tlb": "#CF35", - "prefix": "CF35", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - x'" - } - }, - { - "mnemonic": "BREMREFS", - "doc": { - "category": "cell_build", - "description": "Returns the number of references that can still be stored in `b`.", - "gas": "26", - "fift": "BREMREFS" - }, - "bytecode": { - "doc_opcode": "CF36", - "tlb": "#CF36", - "prefix": "CF36", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - y'" - } - }, - { - "mnemonic": "BREMBITREFS", - "doc": { - "category": "cell_build", - "description": "Returns the numbers of both data bits and references that can still be stored in `b`.", - "gas": "26", - "fift": "BREMBITREFS" - }, - "bytecode": { - "doc_opcode": "CF37", - "tlb": "#CF37", - "prefix": "CF37", - "operands": [] - }, - "value_flow": { - "doc_stack": "b - x' y'" - } - }, - { - "mnemonic": "BCHKBITS", - "doc": { - "category": "cell_build", - "description": "Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.", - "gas": "34/84", - "fift": "[cc+1] BCHKBITS#" - }, - "bytecode": { - "doc_opcode": "CF38cc", - "tlb": "#CF38 cc:uint8", - "prefix": "CF38", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b -" - } - }, - { - "mnemonic": "BCHKBITS_VAR", - "doc": { - "category": "cell_build", - "description": "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.", - "gas": "26/76", - "fift": "BCHKBITS" - }, - "bytecode": { - "doc_opcode": "CF39", - "tlb": "#CF39", - "prefix": "CF39", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x - " - } - }, - { - "mnemonic": "BCHKREFS", - "doc": { - "category": "cell_build", - "description": "Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.", - "gas": "26/76", - "fift": "BCHKREFS" - }, - "bytecode": { - "doc_opcode": "CF3A", - "tlb": "#CF3A", - "prefix": "CF3A", - "operands": [] - }, - "value_flow": { - "doc_stack": "b y - " - } - }, - { - "mnemonic": "BCHKBITREFS", - "doc": { - "category": "cell_build", - "description": "Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.", - "gas": "26/76", - "fift": "BCHKBITREFS" - }, - "bytecode": { - "doc_opcode": "CF3B", - "tlb": "#CF3B", - "prefix": "CF3B", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x y - " - } - }, - { - "mnemonic": "BCHKBITSQ", - "doc": { - "category": "cell_build", - "description": "Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.", - "gas": "34", - "fift": "[cc+1] BCHKBITSQ#" - }, - "bytecode": { - "doc_opcode": "CF3Ccc", - "tlb": "#CF3C cc:uint8", - "prefix": "CF3C", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "b - ?" - } - }, - { - "mnemonic": "BCHKBITSQ_VAR", - "doc": { - "category": "cell_build", - "description": "Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.", - "gas": "26", - "fift": "BCHKBITSQ" - }, - "bytecode": { - "doc_opcode": "CF3D", - "tlb": "#CF3D", - "prefix": "CF3D", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x - ?" - } - }, - { - "mnemonic": "BCHKREFSQ", - "doc": { - "category": "cell_build", - "description": "Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.", - "gas": "26", - "fift": "BCHKREFSQ" - }, - "bytecode": { - "doc_opcode": "CF3E", - "tlb": "#CF3E", - "prefix": "CF3E", - "operands": [] - }, - "value_flow": { - "doc_stack": "b y - ?" - } - }, - { - "mnemonic": "BCHKBITREFSQ", - "doc": { - "category": "cell_build", - "description": "Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.", - "gas": "26", - "fift": "BCHKBITREFSQ" - }, - "bytecode": { - "doc_opcode": "CF3F", - "tlb": "#CF3F", - "prefix": "CF3F", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x y - ?" - } - }, - { - "mnemonic": "STZEROES", - "doc": { - "category": "cell_build", - "description": "Stores `n` binary zeroes into _Builder_ `b`.", - "gas": "26", - "fift": "STZEROES" - }, - "bytecode": { - "doc_opcode": "CF40", - "tlb": "#CF40", - "prefix": "CF40", - "operands": [] - }, - "value_flow": { - "doc_stack": "b n - b'" - } - }, - { - "mnemonic": "STONES", - "doc": { - "category": "cell_build", - "description": "Stores `n` binary ones into _Builder_ `b`.", - "gas": "26", - "fift": "STONES" - }, - "bytecode": { - "doc_opcode": "CF41", - "tlb": "#CF41", - "prefix": "CF41", - "operands": [] - }, - "value_flow": { - "doc_stack": "b n - b'" - } - }, - { - "mnemonic": "STSAME", - "doc": { - "category": "cell_build", - "description": "Stores `n` binary `x`es (`0 <= x <= 1`) into _Builder_ `b`.", - "gas": "26", - "fift": "STSAME" - }, - "bytecode": { - "doc_opcode": "CF42", - "tlb": "#CF42", - "prefix": "CF42", - "operands": [] - }, - "value_flow": { - "doc_stack": "b n x - b'" - } - }, - { - "mnemonic": "STSLICECONST", - "doc": { - "category": "cell_build", - "description": "Stores a constant subslice `sss`.\n_Details:_ `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed.\nNote that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.", - "gas": "24", - "fift": "[slice] STSLICECONST" - }, - "bytecode": { - "doc_opcode": "CFC0_xysss", - "tlb": "#CFC0_ x:(## 2) y:(## 3) c:(x * ^Cell) sss:((8 * y + 2) * Bit)", - "prefix": "CFC0_", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "y", - "loader": "uint", - "loader_args": { - "size": 3 - } - }, - { - "name": "sss", - "loader": "subslice", - "loader_args": { - "bits_length_var": "y", - "bits_padding": 2, - "refs_length_var": "x", - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "b - b'" - } - }, - { - "mnemonic": "CTOS", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "118/43", - "fift": "CTOS" - }, - "bytecode": { - "doc_opcode": "D0", - "tlb": "#D0", - "prefix": "D0", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - s" - } - }, - { - "mnemonic": "ENDS", - "doc": { - "category": "cell_parse", - "description": "Removes a _Slice_ `s` from the stack, and throws an exception if it is not empty.", - "gas": "18/68", - "fift": "ENDS" - }, - "bytecode": { - "doc_opcode": "D1", - "tlb": "#D1", - "prefix": "D1", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - " - } - }, - { - "mnemonic": "LDI", - "doc": { - "category": "cell_parse", - "description": "Loads (i.e., parses) a signed `cc+1`-bit integer `x` from _Slice_ `s`, and returns the remainder of `s` as `s'`.", - "gas": "26", - "fift": "[cc+1] LDI" - }, - "bytecode": { - "doc_opcode": "D2cc", - "tlb": "#D2 cc:uint8", - "prefix": "D2", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDU", - "doc": { - "category": "cell_parse", - "description": "Loads an unsigned `cc+1`-bit integer `x` from _Slice_ `s`.", - "gas": "26", - "fift": "[cc+1] LDU" - }, - "bytecode": { - "doc_opcode": "D3cc", - "tlb": "#D3 cc:uint8", - "prefix": "D3", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDREF", - "doc": { - "category": "cell_parse", - "description": "Loads a cell reference `c` from `s`.", - "gas": "18", - "fift": "LDREF" - }, - "bytecode": { - "doc_opcode": "D4", - "tlb": "#D4", - "prefix": "D4", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - c s'" - } - }, - { - "mnemonic": "LDREFRTOS", - "doc": { - "category": "cell_parse", - "description": "Equivalent to `LDREF` `SWAP` `CTOS`.", - "gas": "118/43", - "fift": "LDREFRTOS" - }, - "bytecode": { - "doc_opcode": "D5", - "tlb": "#D5", - "prefix": "D5", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s' s''" - } - }, - { - "mnemonic": "LDSLICE", - "doc": { - "category": "cell_parse", - "description": "Cuts the next `cc+1` bits of `s` into a separate _Slice_ `s''`.", - "gas": "26", - "fift": "[cc+1] LDSLICE" - }, - "bytecode": { - "doc_opcode": "D6cc", - "tlb": "#D6 cc:uint8", - "prefix": "D6", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s'' s'" - } - }, - { - "mnemonic": "LDIX", - "doc": { - "category": "cell_parse", - "description": "Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from _Slice_ `s`, and returns the remainder of `s` as `s'`.", - "gas": "26", - "fift": "LDIX" - }, - "bytecode": { - "doc_opcode": "D700", - "tlb": "#D700", - "prefix": "D700", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x s'" - } - }, - { - "mnemonic": "LDUX", - "doc": { - "category": "cell_parse", - "description": "Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.", - "gas": "26", - "fift": "LDUX" - }, - "bytecode": { - "doc_opcode": "D701", - "tlb": "#D701", - "prefix": "D701", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x s'" - } - }, - { - "mnemonic": "PLDIX", - "doc": { - "category": "cell_parse", - "description": "Preloads a signed `l`-bit integer from _Slice_ `s`, for `0 <= l <= 257`.", - "gas": "26", - "fift": "PLDIX" - }, - "bytecode": { - "doc_opcode": "D702", - "tlb": "#D702", - "prefix": "D702", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x" - } - }, - { - "mnemonic": "PLDUX", - "doc": { - "category": "cell_parse", - "description": "Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.", - "gas": "26", - "fift": "PLDUX" - }, - "bytecode": { - "doc_opcode": "D703", - "tlb": "#D703", - "prefix": "D703", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x" - } - }, - { - "mnemonic": "LDIXQ", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "26", - "fift": "LDIXQ" - }, - "bytecode": { - "doc_opcode": "D704", - "tlb": "#D704", - "prefix": "D704", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x s' -1 or s 0" - } - }, - { - "mnemonic": "LDUXQ", - "doc": { - "category": "cell_parse", - "description": "Quiet version of `LDUX`.", - "gas": "26", - "fift": "LDUXQ" - }, - "bytecode": { - "doc_opcode": "D705", - "tlb": "#D705", - "prefix": "D705", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x s' -1 or s 0" - } - }, - { - "mnemonic": "PLDIXQ", - "doc": { - "category": "cell_parse", - "description": "Quiet version of `PLDIX`.", - "gas": "26", - "fift": "PLDIXQ" - }, - "bytecode": { - "doc_opcode": "D706", - "tlb": "#D706", - "prefix": "D706", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x -1 or 0" - } - }, - { - "mnemonic": "PLDUXQ", - "doc": { - "category": "cell_parse", - "description": "Quiet version of `PLDUX`.", - "gas": "26", - "fift": "PLDUXQ" - }, - "bytecode": { - "doc_opcode": "D707", - "tlb": "#D707", - "prefix": "D707", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - x -1 or 0" - } - }, - { - "mnemonic": "LDI_ALT", - "doc": { - "category": "cell_parse", - "description": "A longer encoding for `LDI`.", - "gas": "34", - "fift": "[cc+1] LDI_l" - }, - "bytecode": { - "doc_opcode": "D708cc", - "tlb": "#D708 cc:uint8", - "prefix": "D708", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDU_ALT", - "doc": { - "category": "cell_parse", - "description": "A longer encoding for `LDU`.", - "gas": "34", - "fift": "[cc+1] LDU_l" - }, - "bytecode": { - "doc_opcode": "D709cc", - "tlb": "#D709 cc:uint8", - "prefix": "D709", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "PLDI", - "doc": { - "category": "cell_parse", - "description": "Preloads a signed `cc+1`-bit integer from _Slice_ `s`.", - "gas": "34", - "fift": "[cc+1] PLDI" - }, - "bytecode": { - "doc_opcode": "D70Acc", - "tlb": "#D70A cc:uint8", - "prefix": "D70A", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "PLDU", - "doc": { - "category": "cell_parse", - "description": "Preloads an unsigned `cc+1`-bit integer from `s`.", - "gas": "34", - "fift": "[cc+1] PLDU" - }, - "bytecode": { - "doc_opcode": "D70Bcc", - "tlb": "#D70B cc:uint8", - "prefix": "D70B", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "LDIQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `LDI`.", - "gas": "34", - "fift": "[cc+1] LDIQ" - }, - "bytecode": { - "doc_opcode": "D70Ccc", - "tlb": "#D70C cc:uint8", - "prefix": "D70C", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "LDUQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `LDU`.", - "gas": "34", - "fift": "[cc+1] LDUQ" - }, - "bytecode": { - "doc_opcode": "D70Dcc", - "tlb": "#D70D cc:uint8", - "prefix": "D70D", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "PLDIQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `PLDI`.", - "gas": "34", - "fift": "[cc+1] PLDIQ" - }, - "bytecode": { - "doc_opcode": "D70Ecc", - "tlb": "#D70E cc:uint8", - "prefix": "D70E", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "PLDUQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `PLDU`.", - "gas": "34", - "fift": "[cc+1] PLDUQ" - }, - "bytecode": { - "doc_opcode": "D70Fcc", - "tlb": "#D70F cc:uint8", - "prefix": "D70F", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "PLDUZ", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "26", - "fift": "[32(c+1)] PLDUZ" - }, - "bytecode": { - "doc_opcode": "D714_c", - "tlb": "#D714_ c:uint3", - "prefix": "D714_", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 3 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s x" - } - }, - { - "mnemonic": "LDSLICEX", - "doc": { - "category": "cell_parse", - "description": "Loads the first `0 <= l <= 1023` bits from _Slice_ `s` into a separate _Slice_ `s''`, returning the remainder of `s` as `s'`.", - "gas": "26", - "fift": "LDSLICEX" - }, - "bytecode": { - "doc_opcode": "D718", - "tlb": "#D718", - "prefix": "D718", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'' s'" - } - }, - { - "mnemonic": "PLDSLICEX", - "doc": { - "category": "cell_parse", - "description": "Returns the first `0 <= l <= 1023` bits of `s` as `s''`.", - "gas": "26", - "fift": "PLDSLICEX" - }, - "bytecode": { - "doc_opcode": "D719", - "tlb": "#D719", - "prefix": "D719", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s''" - } - }, - { - "mnemonic": "LDSLICEXQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `LDSLICEX`.", - "gas": "26", - "fift": "LDSLICEXQ" - }, - "bytecode": { - "doc_opcode": "D71A", - "tlb": "#D71A", - "prefix": "D71A", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'' s' -1 or s 0" - } - }, - { - "mnemonic": "PLDSLICEXQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `LDSLICEXQ`.", - "gas": "26", - "fift": "PLDSLICEXQ" - }, - "bytecode": { - "doc_opcode": "D71B", - "tlb": "#D71B", - "prefix": "D71B", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s' -1 or 0" - } - }, - { - "mnemonic": "LDSLICE_ALT", - "doc": { - "category": "cell_parse", - "description": "A longer encoding for `LDSLICE`.", - "gas": "34", - "fift": "[cc+1] LDSLICE_l" - }, - "bytecode": { - "doc_opcode": "D71Ccc", - "tlb": "#D71C cc:uint8", - "prefix": "D71C", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s'' s'" - } - }, - { - "mnemonic": "PLDSLICE", - "doc": { - "category": "cell_parse", - "description": "Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.", - "gas": "34", - "fift": "[cc+1] PLDSLICE" - }, - "bytecode": { - "doc_opcode": "D71Dcc", - "tlb": "#D71D cc:uint8", - "prefix": "D71D", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s''" - } - }, - { - "mnemonic": "LDSLICEQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `LDSLICE`.", - "gas": "34", - "fift": "[cc+1] LDSLICEQ" - }, - "bytecode": { - "doc_opcode": "D71Ecc", - "tlb": "#D71E cc:uint8", - "prefix": "D71E", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s'' s' -1 or s 0" - } - }, - { - "mnemonic": "PLDSLICEQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `PLDSLICE`.", - "gas": "34", - "fift": "[cc+1] PLDSLICEQ" - }, - "bytecode": { - "doc_opcode": "D71Fcc", - "tlb": "#D71F cc:uint8", - "prefix": "D71F", - "operands": [ - { - "name": "c", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s'' -1 or 0" - } - }, - { - "mnemonic": "SDCUTFIRST", - "doc": { - "category": "cell_parse", - "description": "Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.", - "gas": "26", - "fift": "SDCUTFIRST" - }, - "bytecode": { - "doc_opcode": "D720", - "tlb": "#D720", - "prefix": "D720", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'" - } - }, - { - "mnemonic": "SDSKIPFIRST", - "doc": { - "category": "cell_parse", - "description": "Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.", - "gas": "26", - "fift": "SDSKIPFIRST" - }, - "bytecode": { - "doc_opcode": "D721", - "tlb": "#D721", - "prefix": "D721", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'" - } - }, - { - "mnemonic": "SDCUTLAST", - "doc": { - "category": "cell_parse", - "description": "Returns the last `0 <= l <= 1023` bits of `s`.", - "gas": "26", - "fift": "SDCUTLAST" - }, - "bytecode": { - "doc_opcode": "D722", - "tlb": "#D722", - "prefix": "D722", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'" - } - }, - { - "mnemonic": "SDSKIPLAST", - "doc": { - "category": "cell_parse", - "description": "Returns all but the last `0 <= l <= 1023` bits of `s`.", - "gas": "26", - "fift": "SDSKIPLAST" - }, - "bytecode": { - "doc_opcode": "D723", - "tlb": "#D723", - "prefix": "D723", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - s'" - } - }, - { - "mnemonic": "SDSUBSTR", - "doc": { - "category": "cell_parse", - "description": "Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.", - "gas": "26", - "fift": "SDSUBSTR" - }, - "bytecode": { - "doc_opcode": "D724", - "tlb": "#D724", - "prefix": "D724", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l l' - s'" - } - }, - { - "mnemonic": "SDBEGINSX", - "doc": { - "category": "cell_parse", - "description": "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`.", - "gas": "26", - "fift": "SDBEGINSX" - }, - "bytecode": { - "doc_opcode": "D726", - "tlb": "#D726", - "prefix": "D726", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - s''" - } - }, - { - "mnemonic": "SDBEGINSXQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `SDBEGINSX`.", - "gas": "26", - "fift": "SDBEGINSXQ" - }, - "bytecode": { - "doc_opcode": "D727", - "tlb": "#D727", - "prefix": "D727", - "operands": [] - }, - "value_flow": { - "doc_stack": "s s' - s'' -1 or s 0" - } - }, - { - "mnemonic": "SDBEGINS", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "31", - "fift": "[slice] SDBEGINS" - }, - "bytecode": { - "doc_opcode": "D72A_xsss", - "tlb": "#D72A_ x:(## 7) sss:((8 * x + 3) * Bit)", - "prefix": "D72A_", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 7 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 3, - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s''" - } - }, - { - "mnemonic": "SDBEGINSQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `SDBEGINS`.", - "gas": "31", - "fift": "[slice] SDBEGINSQ" - }, - "bytecode": { - "doc_opcode": "D72E_xsss", - "tlb": "#D72E_ x:(## 7) sss:((8 * x + 3) * Bit)", - "prefix": "D72E_", - "operands": [ - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 7 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 3, - "completion_tag": true - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s'' -1 or s 0" - } - }, - { - "mnemonic": "SCUTFIRST", - "doc": { - "category": "cell_parse", - "description": "Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.", - "gas": "26", - "fift": "SCUTFIRST" - }, - "bytecode": { - "doc_opcode": "D730", - "tlb": "#D730", - "prefix": "D730", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s'" - } - }, - { - "mnemonic": "SSKIPFIRST", - "doc": { - "category": "cell_parse", - "description": "Returns all but the first `l` bits of `s` and `r` references of `s`.", - "gas": "26", - "fift": "SSKIPFIRST" - }, - "bytecode": { - "doc_opcode": "D731", - "tlb": "#D731", - "prefix": "D731", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s'" - } - }, - { - "mnemonic": "SCUTLAST", - "doc": { - "category": "cell_parse", - "description": "Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.", - "gas": "26", - "fift": "SCUTLAST" - }, - "bytecode": { - "doc_opcode": "D732", - "tlb": "#D732", - "prefix": "D732", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s'" - } - }, - { - "mnemonic": "SSKIPLAST", - "doc": { - "category": "cell_parse", - "description": "Returns all but the last `l` bits of `s` and `r` references of `s`.", - "gas": "26", - "fift": "SSKIPLAST" - }, - "bytecode": { - "doc_opcode": "D733", - "tlb": "#D733", - "prefix": "D733", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s'" - } - }, - { - "mnemonic": "SUBSLICE", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "26", - "fift": "SUBSLICE" - }, - "bytecode": { - "doc_opcode": "D734", - "tlb": "#D734", - "prefix": "D734", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r l' r' - s'" - } - }, - { - "mnemonic": "SPLIT", - "doc": { - "category": "cell_parse", - "description": "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''`.", - "gas": "26", - "fift": "SPLIT" - }, - "bytecode": { - "doc_opcode": "D736", - "tlb": "#D736", - "prefix": "D736", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s' s''" - } - }, - { - "mnemonic": "SPLITQ", - "doc": { - "category": "cell_parse", - "description": "A quiet version of `SPLIT`.", - "gas": "26", - "fift": "SPLITQ" - }, - "bytecode": { - "doc_opcode": "D737", - "tlb": "#D737", - "prefix": "D737", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - s' s'' -1 or s 0" - } - }, - { - "mnemonic": "XCTOS", - "doc": { - "category": "cell_parse", - "description": "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`.", - "gas": "", - "fift": "" - }, - "bytecode": { - "doc_opcode": "D739", - "tlb": "#D739", - "prefix": "D739", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - s ?" - } - }, - { - "mnemonic": "XLOAD", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "", - "fift": "" - }, - "bytecode": { - "doc_opcode": "D73A", - "tlb": "#D73A", - "prefix": "D73A", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - c'" - } - }, - { - "mnemonic": "XLOADQ", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "", - "fift": "" - }, - "bytecode": { - "doc_opcode": "D73B", - "tlb": "#D73B", - "prefix": "D73B", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - c' -1 or c 0" - } - }, - { - "mnemonic": "SCHKBITS", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "26/76", - "fift": "SCHKBITS" - }, - "bytecode": { - "doc_opcode": "D741", - "tlb": "#D741", - "prefix": "D741", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - " - } - }, - { - "mnemonic": "SCHKREFS", - "doc": { - "category": "cell_parse", - "description": "Checks whether there are at least `r` references in _Slice_ `s`.", - "gas": "26/76", - "fift": "SCHKREFS" - }, - "bytecode": { - "doc_opcode": "D742", - "tlb": "#D742", - "prefix": "D742", - "operands": [] - }, - "value_flow": { - "doc_stack": "s r - " - } - }, - { - "mnemonic": "SCHKBITREFS", - "doc": { - "category": "cell_parse", - "description": "Checks whether there are at least `l` data bits and `r` references in _Slice_ `s`.", - "gas": "26/76", - "fift": "SCHKBITREFS" - }, - "bytecode": { - "doc_opcode": "D743", - "tlb": "#D743", - "prefix": "D743", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - " - } - }, - { - "mnemonic": "SCHKBITSQ", - "doc": { - "category": "cell_parse", - "description": "Checks whether there are at least `l` data bits in _Slice_ `s`.", - "gas": "26", - "fift": "SCHKBITSQ" - }, - "bytecode": { - "doc_opcode": "D745", - "tlb": "#D745", - "prefix": "D745", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l - ?" - } - }, - { - "mnemonic": "SCHKREFSQ", - "doc": { - "category": "cell_parse", - "description": "Checks whether there are at least `r` references in _Slice_ `s`.", - "gas": "26", - "fift": "SCHKREFSQ" - }, - "bytecode": { - "doc_opcode": "D746", - "tlb": "#D746", - "prefix": "D746", - "operands": [] - }, - "value_flow": { - "doc_stack": "s r - ?" - } - }, - { - "mnemonic": "SCHKBITREFSQ", - "doc": { - "category": "cell_parse", - "description": "Checks whether there are at least `l` data bits and `r` references in _Slice_ `s`.", - "gas": "26", - "fift": "SCHKBITREFSQ" - }, - "bytecode": { - "doc_opcode": "D747", - "tlb": "#D747", - "prefix": "D747", - "operands": [] - }, - "value_flow": { - "doc_stack": "s l r - ?" - } - }, - { - "mnemonic": "PLDREFVAR", - "doc": { - "category": "cell_parse", - "description": "Returns the `n`-th cell reference of _Slice_ `s` for `0 <= n <= 3`.", - "gas": "26", - "fift": "PLDREFVAR" - }, - "bytecode": { - "doc_opcode": "D748", - "tlb": "#D748", - "prefix": "D748", - "operands": [] - }, - "value_flow": { - "doc_stack": "s n - c" - } - }, - { - "mnemonic": "SBITS", - "doc": { - "category": "cell_parse", - "description": "Returns the number of data bits in _Slice_ `s`.", - "gas": "26", - "fift": "SBITS" - }, - "bytecode": { - "doc_opcode": "D749", - "tlb": "#D749", - "prefix": "D749", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - l" - } - }, - { - "mnemonic": "SREFS", - "doc": { - "category": "cell_parse", - "description": "Returns the number of references in _Slice_ `s`.", - "gas": "26", - "fift": "SREFS" - }, - "bytecode": { - "doc_opcode": "D74A", - "tlb": "#D74A", - "prefix": "D74A", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - r" - } - }, - { - "mnemonic": "SBITREFS", - "doc": { - "category": "cell_parse", - "description": "Returns both the number of data bits and the number of references in `s`.", - "gas": "26", - "fift": "SBITREFS" - }, - "bytecode": { - "doc_opcode": "D74B", - "tlb": "#D74B", - "prefix": "D74B", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - l r" - } - }, - { - "mnemonic": "PLDREFIDX", - "doc": { - "category": "cell_parse", - "description": "Returns the `n`-th cell reference of _Slice_ `s`, where `0 <= n <= 3`.", - "gas": "26", - "fift": "[n] PLDREFIDX" - }, - "bytecode": { - "doc_opcode": "D74E_n", - "tlb": "#D74E_ n:uint2", - "prefix": "D74E_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 2 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - c" - } - }, - { - "mnemonic": "LDILE4", - "doc": { - "category": "cell_parse", - "description": "Loads a little-endian signed 32-bit integer.", - "gas": "26", - "fift": "LDILE4" - }, - "bytecode": { - "doc_opcode": "D750", - "tlb": "#D750", - "prefix": "D750", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDULE4", - "doc": { - "category": "cell_parse", - "description": "Loads a little-endian unsigned 32-bit integer.", - "gas": "26", - "fift": "LDULE4" - }, - "bytecode": { - "doc_opcode": "D751", - "tlb": "#D751", - "prefix": "D751", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDILE8", - "doc": { - "category": "cell_parse", - "description": "Loads a little-endian signed 64-bit integer.", - "gas": "26", - "fift": "LDILE8" - }, - "bytecode": { - "doc_opcode": "D752", - "tlb": "#D752", - "prefix": "D752", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDULE8", - "doc": { - "category": "cell_parse", - "description": "Loads a little-endian unsigned 64-bit integer.", - "gas": "26", - "fift": "LDULE8" - }, - "bytecode": { - "doc_opcode": "D753", - "tlb": "#D753", - "prefix": "D753", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "PLDILE4", - "doc": { - "category": "cell_parse", - "description": "Preloads a little-endian signed 32-bit integer.", - "gas": "26", - "fift": "PLDILE4" - }, - "bytecode": { - "doc_opcode": "D754", - "tlb": "#D754", - "prefix": "D754", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "PLDULE4", - "doc": { - "category": "cell_parse", - "description": "Preloads a little-endian unsigned 32-bit integer.", - "gas": "26", - "fift": "PLDULE4" - }, - "bytecode": { - "doc_opcode": "D755", - "tlb": "#D755", - "prefix": "D755", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "PLDILE8", - "doc": { - "category": "cell_parse", - "description": "Preloads a little-endian signed 64-bit integer.", - "gas": "26", - "fift": "PLDILE8" - }, - "bytecode": { - "doc_opcode": "D756", - "tlb": "#D756", - "prefix": "D756", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "PLDULE8", - "doc": { - "category": "cell_parse", - "description": "Preloads a little-endian unsigned 64-bit integer.", - "gas": "26", - "fift": "PLDULE8" - }, - "bytecode": { - "doc_opcode": "D757", - "tlb": "#D757", - "prefix": "D757", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "LDILE4Q", - "doc": { - "category": "cell_parse", - "description": "Quietly loads a little-endian signed 32-bit integer.", - "gas": "26", - "fift": "LDILE4Q" - }, - "bytecode": { - "doc_opcode": "D758", - "tlb": "#D758", - "prefix": "D758", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "LDULE4Q", - "doc": { - "category": "cell_parse", - "description": "Quietly loads a little-endian unsigned 32-bit integer.", - "gas": "26", - "fift": "LDULE4Q" - }, - "bytecode": { - "doc_opcode": "D759", - "tlb": "#D759", - "prefix": "D759", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "LDILE8Q", - "doc": { - "category": "cell_parse", - "description": "Quietly loads a little-endian signed 64-bit integer.", - "gas": "26", - "fift": "LDILE8Q" - }, - "bytecode": { - "doc_opcode": "D75A", - "tlb": "#D75A", - "prefix": "D75A", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "LDULE8Q", - "doc": { - "category": "cell_parse", - "description": "Quietly loads a little-endian unsigned 64-bit integer.", - "gas": "26", - "fift": "LDULE8Q" - }, - "bytecode": { - "doc_opcode": "D75B", - "tlb": "#D75B", - "prefix": "D75B", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or s 0" - } - }, - { - "mnemonic": "PLDILE4Q", - "doc": { - "category": "cell_parse", - "description": "Quietly preloads a little-endian signed 32-bit integer.", - "gas": "26", - "fift": "PLDILE4Q" - }, - "bytecode": { - "doc_opcode": "D75C", - "tlb": "#D75C", - "prefix": "D75C", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "PLDULE4Q", - "doc": { - "category": "cell_parse", - "description": "Quietly preloads a little-endian unsigned 32-bit integer.", - "gas": "26", - "fift": "PLDULE4Q" - }, - "bytecode": { - "doc_opcode": "D75D", - "tlb": "#D75D", - "prefix": "D75D", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "PLDILE8Q", - "doc": { - "category": "cell_parse", - "description": "Quietly preloads a little-endian signed 64-bit integer.", - "gas": "26", - "fift": "PLDILE8Q" - }, - "bytecode": { - "doc_opcode": "D75E", - "tlb": "#D75E", - "prefix": "D75E", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "PLDULE8Q", - "doc": { - "category": "cell_parse", - "description": "Quietly preloads a little-endian unsigned 64-bit integer.", - "gas": "26", - "fift": "PLDULE8Q" - }, - "bytecode": { - "doc_opcode": "D75F", - "tlb": "#D75F", - "prefix": "D75F", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x -1 or 0" - } - }, - { - "mnemonic": "LDZEROES", - "doc": { - "category": "cell_parse", - "description": "Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.", - "gas": "26", - "fift": "LDZEROES" - }, - "bytecode": { - "doc_opcode": "D760", - "tlb": "#D760", - "prefix": "D760", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n s'" - } - }, - { - "mnemonic": "LDONES", - "doc": { - "category": "cell_parse", - "description": "Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.", - "gas": "26", - "fift": "LDONES" - }, - "bytecode": { - "doc_opcode": "D761", - "tlb": "#D761", - "prefix": "D761", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - n s'" - } - }, - { - "mnemonic": "LDSAME", - "doc": { - "category": "cell_parse", - "description": "Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.", - "gas": "26", - "fift": "LDSAME" - }, - "bytecode": { - "doc_opcode": "D762", - "tlb": "#D762", - "prefix": "D762", - "operands": [] - }, - "value_flow": { - "doc_stack": "s x - n s'" - } - }, - { - "mnemonic": "SDEPTH", - "doc": { - "category": "cell_parse", - "description": "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`.", - "gas": "26", - "fift": "SDEPTH" - }, - "bytecode": { - "doc_opcode": "D764", - "tlb": "#D764", - "prefix": "D764", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "CDEPTH", - "doc": { - "category": "cell_parse", - "description": "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.", - "gas": "26", - "fift": "CDEPTH" - }, - "bytecode": { - "doc_opcode": "D765", - "tlb": "#D765", - "prefix": "D765", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - x" - } - }, - { - "mnemonic": "EXECUTE", - "doc": { - "category": "cont_basic", - "description": "_Calls_, or _executes_, continuation `c`.", - "gas": "18", - "fift": "EXECUTE\nCALLX" - }, - "bytecode": { - "doc_opcode": "D8", - "tlb": "#D8", - "prefix": "D8", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "JMPX", - "doc": { - "category": "cont_basic", - "description": "_Jumps_, or transfers control, to continuation `c`.\nThe remainder of the previous current continuation `cc` is discarded.", - "gas": "18", - "fift": "JMPX" - }, - "bytecode": { - "doc_opcode": "D9", - "tlb": "#D9", - "prefix": "D9", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "CALLXARGS", - "doc": { - "category": "cont_basic", - "description": "_Calls_ continuation `c` with `p` parameters and expecting `r` return values\n`0 <= p <= 15`, `0 <= r <= 15`", - "gas": "26", - "fift": "[p] [r] CALLXARGS" - }, - "bytecode": { - "doc_opcode": "DApr", - "tlb": "#DA p:uint4 r:uint4", - "prefix": "DA", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "CALLXARGS_VAR", - "doc": { - "category": "cont_basic", - "description": "_Calls_ continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.", - "gas": "26", - "fift": "[p] -1 CALLXARGS" - }, - "bytecode": { - "doc_opcode": "DB0p", - "tlb": "#DB0 p:uint4", - "prefix": "DB0", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "JMPXARGS", - "doc": { - "category": "cont_basic", - "description": "_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).", - "gas": "26", - "fift": "[p] JMPXARGS" - }, - "bytecode": { - "doc_opcode": "DB1p", - "tlb": "#DB1 p:uint4", - "prefix": "DB1", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "RETARGS", - "doc": { - "category": "cont_basic", - "description": "_Returns_ to `c0`, with `0 <= r <= 15` return values taken from the current stack.", - "gas": "26", - "fift": "[r] RETARGS" - }, - "bytecode": { - "doc_opcode": "DB2r", - "tlb": "#DB2 r:uint4", - "prefix": "DB2", - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "RET", - "doc": { - "category": "cont_basic", - "description": "_Returns_ to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.\nApproximately equivalent to `c0 PUSHCTR` `JMPX`.", - "gas": "26", - "fift": "RET\nRETTRUE" - }, - "bytecode": { - "doc_opcode": "DB30", - "tlb": "#DB30", - "prefix": "DB30", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "RETALT", - "doc": { - "category": "cont_basic", - "description": "_Returns_ to the continuation at `c1`.\nApproximately equivalent to `c1 PUSHCTR` `JMPX`.", - "gas": "26", - "fift": "RETALT\nRETFALSE" - }, - "bytecode": { - "doc_opcode": "DB31", - "tlb": "#DB31", - "prefix": "DB31", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "BRANCH", - "doc": { - "category": "cont_basic", - "description": "Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.", - "gas": "26", - "fift": "BRANCH\nRETBOOL" - }, - "bytecode": { - "doc_opcode": "DB32", - "tlb": "#DB32", - "prefix": "DB32", - "operands": [] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "CALLCC", - "doc": { - "category": "cont_basic", - "description": "_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`).", - "gas": "26", - "fift": "CALLCC" - }, - "bytecode": { - "doc_opcode": "DB34", - "tlb": "#DB34", - "prefix": "DB34", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "JMPXDATA", - "doc": { - "category": "cont_basic", - "description": "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`.", - "gas": "26", - "fift": "JMPXDATA" - }, - "bytecode": { - "doc_opcode": "DB35", - "tlb": "#DB35", - "prefix": "DB35", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "CALLCCARGS", - "doc": { - "category": "cont_basic", - "description": "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`.", - "gas": "34", - "fift": "[p] [r] CALLCCARGS" - }, - "bytecode": { - "doc_opcode": "DB36pr", - "tlb": "#DB36 p:uint4 r:uint4", - "prefix": "DB36", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "CALLXVARARGS", - "doc": { - "category": "cont_basic", - "description": "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`.", - "gas": "26", - "fift": "CALLXVARARGS" - }, - "bytecode": { - "doc_opcode": "DB38", - "tlb": "#DB38", - "prefix": "DB38", - "operands": [] - }, - "value_flow": { - "doc_stack": "c p r - " - } - }, - { - "mnemonic": "RETVARARGS", - "doc": { - "category": "cont_basic", - "description": "Similar to `RETARGS`.", - "gas": "26", - "fift": "RETVARARGS" - }, - "bytecode": { - "doc_opcode": "DB39", - "tlb": "#DB39", - "prefix": "DB39", - "operands": [] - }, - "value_flow": { - "doc_stack": "p r - " - } - }, - { - "mnemonic": "JMPXVARARGS", - "doc": { - "category": "cont_basic", - "description": "Similar to `JMPXARGS`.", - "gas": "26", - "fift": "JMPXVARARGS" - }, - "bytecode": { - "doc_opcode": "DB3A", - "tlb": "#DB3A", - "prefix": "DB3A", - "operands": [] - }, - "value_flow": { - "doc_stack": "c p r - " - } - }, - { - "mnemonic": "CALLCCVARARGS", - "doc": { - "category": "cont_basic", - "description": "Similar to `CALLCCARGS`.", - "gas": "26", - "fift": "CALLCCVARARGS" - }, - "bytecode": { - "doc_opcode": "DB3B", - "tlb": "#DB3B", - "prefix": "DB3B", - "operands": [] - }, - "value_flow": { - "doc_stack": "c p r - " - } - }, - { - "mnemonic": "CALLREF", - "doc": { - "category": "cont_basic", - "description": "Equivalent to `PUSHREFCONT` `CALLX`.", - "gas": "126/51", - "fift": "[ref] CALLREF" - }, - "bytecode": { - "doc_opcode": "DB3C", - "tlb": "#DB3C c:^Cell", - "prefix": "DB3C", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "JMPREF", - "doc": { - "category": "cont_basic", - "description": "Equivalent to `PUSHREFCONT` `JMPX`.", - "gas": "126/51", - "fift": "[ref] JMPREF" - }, - "bytecode": { - "doc_opcode": "DB3D", - "tlb": "#DB3D c:^Cell", - "prefix": "DB3D", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "JMPREFDATA", - "doc": { - "category": "cont_basic", - "description": "Equivalent to `PUSHREFCONT` `JMPXDATA`.", - "gas": "126/51", - "fift": "[ref] JMPREFDATA" - }, - "bytecode": { - "doc_opcode": "DB3E", - "tlb": "#DB3E c:^Cell", - "prefix": "DB3E", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "RETDATA", - "doc": { - "category": "cont_basic", - "description": "Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a _Slice_ and returned to the caller.", - "gas": "26", - "fift": "RETDATA" - }, - "bytecode": { - "doc_opcode": "DB3F", - "tlb": "#DB3F", - "prefix": "DB3F", - "operands": [] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "IFRET", - "doc": { - "category": "cont_conditional", - "description": "Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.", - "gas": "18", - "fift": "IFRET\nIFNOT:" - }, - "bytecode": { - "doc_opcode": "DC", - "tlb": "#DC", - "prefix": "DC", - "operands": [] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "IFNOTRET", - "doc": { - "category": "cont_conditional", - "description": "Performs a `RET`, but only if integer `f` is zero.", - "gas": "18", - "fift": "IFNOTRET\nIF:" - }, - "bytecode": { - "doc_opcode": "DD", - "tlb": "#DD", - "prefix": "DD", - "operands": [] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "IF", - "doc": { - "category": "cont_conditional", - "description": "Performs `EXECUTE` for `c` (i.e., _executes_ `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.", - "gas": "18", - "fift": "IF", - "fift_examples": [ - { - "fift": "IF:<{ code }> <{ code }>IF", - "description": "Equivalent to `<{ code }> CONT` `IF`." - } - ] - }, - "bytecode": { - "doc_opcode": "DE", - "tlb": "#DE", - "prefix": "DE", - "operands": [] - }, - "value_flow": { - "doc_stack": "f c - " - } - }, - { - "mnemonic": "IFNOT", - "doc": { - "category": "cont_conditional", - "description": "Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.", - "gas": "18", - "fift": "IFNOT", - "fift_examples": [ - { - "fift": "IFNOT:<{ code }> <{ code }>IFNOT", - "description": "Equivalent to `<{ code }> CONT` `IFNOT`." - } - ] - }, - "bytecode": { - "doc_opcode": "DF", - "tlb": "#DF", - "prefix": "DF", - "operands": [] - }, - "value_flow": { - "doc_stack": "f c - " - } - }, - { - "mnemonic": "IFJMP", - "doc": { - "category": "cont_conditional", - "description": "Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.", - "gas": "18", - "fift": "IFJMP", - "fift_examples": [ - { - "fift": "IFJMP:<{ code }>", - "description": "Equivalent to `<{ code }> CONT` `IFJMP`." - } - ] - }, - "bytecode": { - "doc_opcode": "E0", - "tlb": "#E0", - "prefix": "E0", - "operands": [] - }, - "value_flow": { - "doc_stack": "f c - " - } - }, - { - "mnemonic": "IFNOTJMP", - "doc": { - "category": "cont_conditional", - "description": "Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.", - "gas": "18", - "fift": "IFNOTJMP", - "fift_examples": [ - { - "fift": "IFNOTJMP:<{ code }>", - "description": "Equivalent to `<{ code }> CONT` `IFNOTJMP`." - } - ] - }, - "bytecode": { - "doc_opcode": "E1", - "tlb": "#E1", - "prefix": "E1", - "operands": [] - }, - "value_flow": { - "doc_stack": "f c - " - } - }, - { - "mnemonic": "IFELSE", - "doc": { - "category": "cont_conditional", - "description": "If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.", - "gas": "18", - "fift": "IFELSE", - "fift_examples": [ - { - "fift": "IF:<{ code1 }>ELSE<{ code2 }>", - "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `IFELSE`." - } - ] - }, - "bytecode": { - "doc_opcode": "E2", - "tlb": "#E2", - "prefix": "E2", - "operands": [] - }, - "value_flow": { - "doc_stack": "f c c' - " - } - }, - { - "mnemonic": "IFREF", - "doc": { - "category": "cont_conditional", - "description": "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`.\nGas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before.\nSimilar remarks apply other primitives that accept a continuation as a reference.", - "gas": "26/126/51", - "fift": "[ref] IFREF" - }, - "bytecode": { - "doc_opcode": "E300", - "tlb": "#E300 c:^Cell", - "prefix": "E300", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "IFNOTREF", - "doc": { - "category": "cont_conditional", - "description": "Equivalent to `PUSHREFCONT` `IFNOT`.", - "gas": "26/126/51", - "fift": "[ref] IFNOTREF" - }, - "bytecode": { - "doc_opcode": "E301", - "tlb": "#E301 c:^Cell", - "prefix": "E301", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "IFJMPREF", - "doc": { - "category": "cont_conditional", - "description": "Equivalent to `PUSHREFCONT` `IFJMP`.", - "gas": "26/126/51", - "fift": "[ref] IFJMPREF" - }, - "bytecode": { - "doc_opcode": "E302", - "tlb": "#E302 c:^Cell", - "prefix": "E302", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "IFNOTJMPREF", - "doc": { - "category": "cont_conditional", - "description": "Equivalent to `PUSHREFCONT` `IFNOTJMP`.", - "gas": "26/126/51", - "fift": "[ref] IFNOTJMPREF" - }, - "bytecode": { - "doc_opcode": "E303", - "tlb": "#E303 c:^Cell", - "prefix": "E303", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "CONDSEL", - "doc": { - "category": "cont_conditional", - "description": "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`.", - "gas": "26", - "fift": "CONDSEL" - }, - "bytecode": { - "doc_opcode": "E304", - "tlb": "#E304", - "prefix": "E304", - "operands": [] - }, - "value_flow": { - "doc_stack": "f x y - x or y" - } - }, - { - "mnemonic": "CONDSELCHK", - "doc": { - "category": "cont_conditional", - "description": "Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.", - "gas": "26", - "fift": "CONDSELCHK" - }, - "bytecode": { - "doc_opcode": "E305", - "tlb": "#E305", - "prefix": "E305", - "operands": [] - }, - "value_flow": { - "doc_stack": "f x y - x or y" - } - }, - { - "mnemonic": "IFRETALT", - "doc": { - "category": "cont_conditional", - "description": "Performs `RETALT` if integer `f!=0`.", - "gas": "26", - "fift": "IFRETALT" - }, - "bytecode": { - "doc_opcode": "E308", - "tlb": "#E308", - "prefix": "E308", - "operands": [] - }, - "value_flow": { - "doc_stack": "f -" - } - }, - { - "mnemonic": "IFNOTRETALT", - "doc": { - "category": "cont_conditional", - "description": "Performs `RETALT` if integer `f=0`.", - "gas": "26", - "fift": "IFNOTRETALT" - }, - "bytecode": { - "doc_opcode": "E309", - "tlb": "#E309", - "prefix": "E309", - "operands": [] - }, - "value_flow": { - "doc_stack": "f -" - } - }, - { - "mnemonic": "IFREFELSE", - "doc": { - "category": "cont_conditional", - "description": "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.", - "gas": "26/126/51", - "fift": "[ref] IFREFELSE" - }, - "bytecode": { - "doc_opcode": "E30D", - "tlb": "#E30D c:^Cell", - "prefix": "E30D", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f c -" - } - }, - { - "mnemonic": "IFELSEREF", - "doc": { - "category": "cont_conditional", - "description": "Equivalent to `PUSHREFCONT` `IFELSE`.", - "gas": "26/126/51", - "fift": "[ref] IFELSEREF" - }, - "bytecode": { - "doc_opcode": "E30E", - "tlb": "#E30E c:^Cell", - "prefix": "E30E", - "operands": [ - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "f c -" - } - }, - { - "mnemonic": "IFREFELSEREF", - "doc": { - "category": "cont_conditional", - "description": "Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.", - "gas": "126/51", - "fift": "[ref] [ref] IFREFELSEREF" - }, - "bytecode": { - "doc_opcode": "E30F", - "tlb": "#E30F c1:^Cell c2:^Cell", - "prefix": "E30F", - "operands": [] - }, - "value_flow": { - "doc_stack": "f -" - } - }, - { - "mnemonic": "IFBITJMP", - "doc": { - "category": "cont_conditional", - "description": "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.", - "gas": "26", - "fift": "[n] IFBITJMP" - }, - "bytecode": { - "doc_opcode": "E39_n", - "tlb": "#E39_ n:uint5", - "prefix": "E39_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 5 - } - } - ] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "IFNBITJMP", - "doc": { - "category": "cont_conditional", - "description": "Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.", - "gas": "26", - "fift": "[n] IFNBITJMP" - }, - "bytecode": { - "doc_opcode": "E3B_n", - "tlb": "#E3B_ n:uint5", - "prefix": "E3B_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 5 - } - } - ] - }, - "value_flow": { - "doc_stack": "x c - x" - } - }, - { - "mnemonic": "IFBITJMPREF", - "doc": { - "category": "cont_conditional", - "description": "Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.", - "gas": "126/51", - "fift": "[ref] [n] IFBITJMPREF" - }, - "bytecode": { - "doc_opcode": "E3D_n", - "tlb": "#E3D_ n:uint5 c:^Cell", - "prefix": "E3D_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 5 - } - }, - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "IFNBITJMPREF", - "doc": { - "category": "cont_conditional", - "description": "Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.", - "gas": "126/51", - "fift": "[ref] [n] IFNBITJMPREF" - }, - "bytecode": { - "doc_opcode": "E3F_n", - "tlb": "#E3F_ n:uint5 c:^Cell", - "prefix": "E3F_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 5 - } - }, - { - "name": "c", - "loader": "ref", - "loader_args": {} - } - ] - }, - "value_flow": { - "doc_stack": "x - x" - } - }, - { - "mnemonic": "REPEAT", - "doc": { - "category": "cont_loops", - "description": "Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception.\nNotice 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.", - "gas": "18", - "fift": "REPEAT", - "fift_examples": [ - { - "fift": "REPEAT:<{ code }> <{ code }>REPEAT", - "description": "Equivalent to `<{ code }> CONT` `REPEAT`." - } - ] - }, - "bytecode": { - "doc_opcode": "E4", - "tlb": "#E4", - "prefix": "E4", - "operands": [] - }, - "value_flow": { - "doc_stack": "n c - " - } - }, - { - "mnemonic": "REPEATEND", - "doc": { - "category": "cont_loops", - "description": "Similar to `REPEAT`, but it is applied to the current continuation `cc`.", - "gas": "18", - "fift": "REPEATEND\nREPEAT:" - }, - "bytecode": { - "doc_opcode": "E5", - "tlb": "#E5", - "prefix": "E5", - "operands": [] - }, - "value_flow": { - "doc_stack": "n - " - } - }, - { - "mnemonic": "UNTIL", - "doc": { - "category": "cont_loops", - "description": "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.", - "gas": "18", - "fift": "UNTIL", - "fift_examples": [ - { - "fift": "UNTIL:<{ code }> <{ code }>UNTIL", - "description": "Equivalent to `<{ code }> CONT` `UNTIL`." - } - ] - }, - "bytecode": { - "doc_opcode": "E6", - "tlb": "#E6", - "prefix": "E6", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "UNTILEND", - "doc": { - "category": "cont_loops", - "description": "Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.", - "gas": "18", - "fift": "UNTILEND\nUNTIL:" - }, - "bytecode": { - "doc_opcode": "E7", - "tlb": "#E7", - "prefix": "E7", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "WHILE", - "doc": { - "category": "cont_loops", - "description": "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.", - "gas": "18", - "fift": "WHILE", - "fift_examples": [ - { - "fift": "WHILE:<{ cond }>DO<{ code }>", - "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILE`." - } - ] - }, - "bytecode": { - "doc_opcode": "E8", - "tlb": "#E8", - "prefix": "E8", - "operands": [] - }, - "value_flow": { - "doc_stack": "c' c - " - } - }, - { - "mnemonic": "WHILEEND", - "doc": { - "category": "cont_loops", - "description": "Similar to `WHILE`, but uses the current continuation `cc` as the loop body.", - "gas": "18", - "fift": "WHILEEND" - }, - "bytecode": { - "doc_opcode": "E9", - "tlb": "#E9", - "prefix": "E9", - "operands": [] - }, - "value_flow": { - "doc_stack": "c' - " - } - }, - { - "mnemonic": "AGAIN", - "doc": { - "category": "cont_loops", - "description": "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`).", - "gas": "18", - "fift": "AGAIN", - "fift_examples": [ - { - "fift": "AGAIN:<{ code }> <{ code }>AGAIN", - "description": "Equivalent to `<{ code }> CONT` `AGAIN`." - } - ] - }, - "bytecode": { - "doc_opcode": "EA", - "tlb": "#EA", - "prefix": "EA", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "AGAINEND", - "doc": { - "category": "cont_loops", - "description": "Similar to `AGAIN`, but performed with respect to the current continuation `cc`.", - "gas": "18", - "fift": "AGAINEND\nAGAIN:" - }, - "bytecode": { - "doc_opcode": "EB", - "tlb": "#EB", - "prefix": "EB", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "REPEATBRK", - "doc": { - "category": "cont_loops", - "description": "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.", - "gas": "26", - "fift": "REPEATBRK", - "fift_examples": [ - { - "fift": "REPEATBRK:<{ code }> <{ code }>REPEATBRK", - "description": "Equivalent to `<{ code }> CONT` `REPEATBRK`." - } - ] - }, - "bytecode": { - "doc_opcode": "E314", - "tlb": "#E314", - "prefix": "E314", - "operands": [] - }, - "value_flow": { - "doc_stack": "n c -" - } - }, - { - "mnemonic": "REPEATENDBRK", - "doc": { - "category": "cont_loops", - "description": "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`.", - "gas": "26", - "fift": "REPEATENDBRK" - }, - "bytecode": { - "doc_opcode": "E315", - "tlb": "#E315", - "prefix": "E315", - "operands": [] - }, - "value_flow": { - "doc_stack": "n -" - } - }, - { - "mnemonic": "UNTILBRK", - "doc": { - "category": "cont_loops", - "description": "Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.", - "gas": "26", - "fift": "UNTILBRK", - "fift_examples": [ - { - "fift": "UNTILBRK:<{ code }>", - "description": "Equivalent to `<{ code }> CONT` `UNTILBRK`." - } - ] - }, - "bytecode": { - "doc_opcode": "E316", - "tlb": "#E316", - "prefix": "E316", - "operands": [] - }, - "value_flow": { - "doc_stack": "c -" - } - }, - { - "mnemonic": "UNTILENDBRK", - "doc": { - "category": "cont_loops", - "description": "Equivalent to `SAMEALTSAVE` `UNTILEND`.", - "gas": "26", - "fift": "UNTILENDBRK\nUNTILBRK:" - }, - "bytecode": { - "doc_opcode": "E317", - "tlb": "#E317", - "prefix": "E317", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "WHILEBRK", - "doc": { - "category": "cont_loops", - "description": "Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.", - "gas": "26", - "fift": "WHILEBRK", - "fift_examples": [ - { - "fift": "WHILEBRK:<{ cond }>DO<{ code }>", - "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILEBRK`." - } - ] - }, - "bytecode": { - "doc_opcode": "E318", - "tlb": "#E318", - "prefix": "E318", - "operands": [] - }, - "value_flow": { - "doc_stack": "c' c -" - } - }, - { - "mnemonic": "WHILEENDBRK", - "doc": { - "category": "cont_loops", - "description": "Equivalent to `SAMEALTSAVE` `WHILEEND`.", - "gas": "26", - "fift": "WHILEENDBRK" - }, - "bytecode": { - "doc_opcode": "E319", - "tlb": "#E319", - "prefix": "E319", - "operands": [] - }, - "value_flow": { - "doc_stack": "c -" - } - }, - { - "mnemonic": "AGAINBRK", - "doc": { - "category": "cont_loops", - "description": "Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.", - "gas": "26", - "fift": "AGAINBRK", - "fift_examples": [ - { - "fift": "AGAINBRK:<{ code }>", - "description": "Equivalent to `<{ code }> CONT` `AGAINBRK`." - } - ] - }, - "bytecode": { - "doc_opcode": "E31A", - "tlb": "#E31A", - "prefix": "E31A", - "operands": [] - }, - "value_flow": { - "doc_stack": "c -" - } - }, - { - "mnemonic": "AGAINENDBRK", - "doc": { - "category": "cont_loops", - "description": "Equivalent to `SAMEALTSAVE` `AGAINEND`.", - "gas": "26", - "fift": "AGAINENDBRK\nAGAINBRK:" - }, - "bytecode": { - "doc_opcode": "E31B", - "tlb": "#E31B", - "prefix": "E31B", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SETCONTARGS_N", - "doc": { - "category": "cont_stack", - "description": "Similar to `[r] -1 SETCONTARGS`, but 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.", - "gas": "26+s\u0432\u0402\u045c", - "fift": "[r] [n] SETCONTARGS" - }, - "bytecode": { - "doc_opcode": "ECrn", - "tlb": "#EC r:uint4 n:uint4", - "prefix": "EC", - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x_1 x_2...x_r c - c'" - } - }, - { - "mnemonic": "RETURNARGS", - "doc": { - "category": "cont_stack", - "description": "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.", - "gas": "26+s\u0432\u0402\u045c", - "fift": "[p] RETURNARGS" - }, - "bytecode": { - "doc_opcode": "ED0p", - "tlb": "#ED0 p:uint4", - "prefix": "ED0", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "RETURNVARARGS", - "doc": { - "category": "cont_stack", - "description": "Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.", - "gas": "26+s\u0432\u0402\u045c", - "fift": "RETURNVARARGS" - }, - "bytecode": { - "doc_opcode": "ED10", - "tlb": "#ED10", - "prefix": "ED10", - "operands": [] - }, - "value_flow": { - "doc_stack": "p -" - } - }, - { - "mnemonic": "SETCONTVARARGS", - "doc": { - "category": "cont_stack", - "description": "Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.", - "gas": "26+s\u0432\u0402\u045c", - "fift": "SETCONTVARARGS" - }, - "bytecode": { - "doc_opcode": "ED11", - "tlb": "#ED11", - "prefix": "ED11", - "operands": [] - }, - "value_flow": { - "doc_stack": "x_1 x_2...x_r c r n - c'" - } - }, - { - "mnemonic": "SETNUMVARARGS", - "doc": { - "category": "cont_stack", - "description": "`-1 <= n <= 255`\nIf `n=-1`, this operation does nothing (`c'=c`).\nOtherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.", - "gas": "26", - "fift": "SETNUMVARARGS" - }, - "bytecode": { - "doc_opcode": "ED12", - "tlb": "#ED12", - "prefix": "ED12", - "operands": [] - }, - "value_flow": { - "doc_stack": "c n - c'" - } - }, - { - "mnemonic": "BLESS", - "doc": { - "category": "cont_create", - "description": "Transforms a _Slice_ `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.", - "gas": "26", - "fift": "BLESS" - }, - "bytecode": { - "doc_opcode": "ED1E", - "tlb": "#ED1E", - "prefix": "ED1E", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - c" - } - }, - { - "mnemonic": "BLESSVARARGS", - "doc": { - "category": "cont_create", - "description": "Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.", - "gas": "26+s\u0432\u0402\u045c", - "fift": "BLESSVARARGS" - }, - "bytecode": { - "doc_opcode": "ED1F", - "tlb": "#ED1F", - "prefix": "ED1F", - "operands": [] - }, - "value_flow": { - "doc_stack": "x_1...x_r s r n - c" - } - }, - { - "mnemonic": "BLESSARGS", - "doc": { - "category": "cont_create", - "description": "`0 <= r <= 15`, `-1 <= n <= 14`\nEquivalent to `BLESS` `[r] [n] SETCONTARGS`.\nThe value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.", - "gas": "26", - "fift": "[r] [n] BLESSARGS" - }, - "bytecode": { - "doc_opcode": "EErn", - "tlb": "#EE r:uint4 n:uint4", - "prefix": "EE", - "operands": [ - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x_1...x_r s - c" - } - }, - { - "mnemonic": "PUSHCTR", - "doc": { - "category": "cont_registers", - "description": "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.", - "gas": "26", - "fift": "c[i] PUSHCTR\nc[i] PUSH" - }, - "bytecode": { - "doc_opcode": "ED4i", - "tlb": "#ED4 i:uint4", - "prefix": "ED4", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "- x" - } - }, - { - "mnemonic": "POPCTR", - "doc": { - "category": "cont_registers", - "description": "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.", - "gas": "26", - "fift": "c[i] POPCTR\nc[i] POP" - }, - "bytecode": { - "doc_opcode": "ED5i", - "tlb": "#ED5 i:uint4", - "prefix": "ED5", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "SETCONTCTR", - "doc": { - "category": "cont_registers", - "description": "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`.", - "gas": "26", - "fift": "c[i] SETCONT\nc[i] SETCONTCTR" - }, - "bytecode": { - "doc_opcode": "ED6i", - "tlb": "#ED6 i:uint4", - "prefix": "ED6", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x c - c'" - } - }, - { - "mnemonic": "SETRETCTR", - "doc": { - "category": "cont_registers", - "description": "Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.", - "gas": "26", - "fift": "c[i] SETRETCTR" - }, - "bytecode": { - "doc_opcode": "ED7i", - "tlb": "#ED7 i:uint4", - "prefix": "ED7", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "SETALTCTR", - "doc": { - "category": "cont_registers", - "description": "Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.", - "gas": "26", - "fift": "c[i] SETALTCTR" - }, - "bytecode": { - "doc_opcode": "ED8i", - "tlb": "#ED8 i:uint4", - "prefix": "ED8", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "POPSAVE", - "doc": { - "category": "cont_registers", - "description": "Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`.\nEquivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.", - "gas": "26", - "fift": "c[i] POPSAVE\nc[i] POPCTRSAVE" - }, - "bytecode": { - "doc_opcode": "ED9i", - "tlb": "#ED9 i:uint4", - "prefix": "ED9", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "x -" - } - }, - { - "mnemonic": "SAVE", - "doc": { - "category": "cont_registers", - "description": "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`.", - "gas": "26", - "fift": "c[i] SAVE\nc[i] SAVECTR" - }, - "bytecode": { - "doc_opcode": "EDAi", - "tlb": "#EDA i:uint4", - "prefix": "EDA", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "SAVEALT", - "doc": { - "category": "cont_registers", - "description": "Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.", - "gas": "26", - "fift": "c[i] SAVEALT\nc[i] SAVEALTCTR" - }, - "bytecode": { - "doc_opcode": "EDBi", - "tlb": "#EDB i:uint4", - "prefix": "EDB", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "SAVEBOTH", - "doc": { - "category": "cont_registers", - "description": "Equivalent to `DUP` `c[i] SAVE` `c[i] SAVEALT`.", - "gas": "26", - "fift": "c[i] SAVEBOTH\nc[i] SAVEBOTHCTR" - }, - "bytecode": { - "doc_opcode": "EDCi", - "tlb": "#EDC i:uint4", - "prefix": "EDC", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "" - } - }, - { - "mnemonic": "PUSHCTRX", - "doc": { - "category": "cont_registers", - "description": "Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack.\nNotice that this primitive is one of the few \u0432\u0402\u045aexotic'' 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`.", - "gas": "26", - "fift": "PUSHCTRX" - }, - "bytecode": { - "doc_opcode": "EDE0", - "tlb": "#EDE0", - "prefix": "EDE0", - "operands": [] - }, - "value_flow": { - "doc_stack": "i - x" - } - }, - { - "mnemonic": "POPCTRX", - "doc": { - "category": "cont_registers", - "description": "Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.", - "gas": "26", - "fift": "POPCTRX" - }, - "bytecode": { - "doc_opcode": "EDE1", - "tlb": "#EDE1", - "prefix": "EDE1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i - " - } - }, - { - "mnemonic": "SETCONTCTRX", - "doc": { - "category": "cont_registers", - "description": "Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.", - "gas": "26", - "fift": "SETCONTCTRX" - }, - "bytecode": { - "doc_opcode": "EDE2", - "tlb": "#EDE2", - "prefix": "EDE2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x c i - c'" - } - }, - { - "mnemonic": "COMPOS", - "doc": { - "category": "cont_registers", - "description": "Computes the composition `compose0(c, c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045aperform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply \u0432\u0402\u045aperform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.", - "gas": "26", - "fift": "COMPOS\nBOOLAND" - }, - "bytecode": { - "doc_opcode": "EDF0", - "tlb": "#EDF0", - "prefix": "EDF0", - "operands": [] - }, - "value_flow": { - "doc_stack": "c c' - c''" - } - }, - { - "mnemonic": "COMPOSALT", - "doc": { - "category": "cont_registers", - "description": "Computes the alternative composition `compose1(c, c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045aperform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.", - "gas": "26", - "fift": "COMPOSALT\nBOOLOR" - }, - "bytecode": { - "doc_opcode": "EDF1", - "tlb": "#EDF1", - "prefix": "EDF1", - "operands": [] - }, - "value_flow": { - "doc_stack": "c c' - c''" - } - }, - { - "mnemonic": "COMPOSBOTH", - "doc": { - "category": "cont_registers", - "description": "Computes composition `compose1(compose0(c, c\u0432\u0402\u2122), c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045acompute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.", - "gas": "26", - "fift": "COMPOSBOTH" - }, - "bytecode": { - "doc_opcode": "EDF2", - "tlb": "#EDF2", - "prefix": "EDF2", - "operands": [] - }, - "value_flow": { - "doc_stack": "c c' - c''" - } - }, - { - "mnemonic": "ATEXIT", - "doc": { - "category": "cont_registers", - "description": "Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.", - "gas": "26", - "fift": "ATEXIT", - "fift_examples": [ - { - "fift": "ATEXIT:<{ code }> <{ code }>ATEXIT", - "description": "Equivalent to `<{ code }> CONT` `ATEXIT`." - } - ] - }, - "bytecode": { - "doc_opcode": "EDF3", - "tlb": "#EDF3", - "prefix": "EDF3", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "ATEXITALT", - "doc": { - "category": "cont_registers", - "description": "Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.", - "gas": "26", - "fift": "ATEXITALT", - "fift_examples": [ - { - "fift": "ATEXITALT:<{ code }> <{ code }>ATEXITALT", - "description": "Equivalent to `<{ code }> CONT` `ATEXITALT`." - } - ] - }, - "bytecode": { - "doc_opcode": "EDF4", - "tlb": "#EDF4", - "prefix": "EDF4", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "SETEXITALT", - "doc": { - "category": "cont_registers", - "description": "Sets `c1` to `compose1(compose0(c, c0), c1)`,\nIn 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.", - "gas": "26", - "fift": "SETEXITALT" - }, - "bytecode": { - "doc_opcode": "EDF5", - "tlb": "#EDF5", - "prefix": "EDF5", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "THENRET", - "doc": { - "category": "cont_registers", - "description": "Computes `compose0(c, c0)`.", - "gas": "26", - "fift": "THENRET" - }, - "bytecode": { - "doc_opcode": "EDF6", - "tlb": "#EDF6", - "prefix": "EDF6", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - c'" - } - }, - { - "mnemonic": "THENRETALT", - "doc": { - "category": "cont_registers", - "description": "Computes `compose0(c, c1)`", - "gas": "26", - "fift": "THENRETALT" - }, - "bytecode": { - "doc_opcode": "EDF7", - "tlb": "#EDF7", - "prefix": "EDF7", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - c'" - } - }, - { - "mnemonic": "INVERT", - "doc": { - "category": "cont_registers", - "description": "Interchanges `c0` and `c1`.", - "gas": "26", - "fift": "INVERT" - }, - "bytecode": { - "doc_opcode": "EDF8", - "tlb": "#EDF8", - "prefix": "EDF8", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "BOOLEVAL", - "doc": { - "category": "cont_registers", - "description": "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.", - "gas": "26", - "fift": "BOOLEVAL" - }, - "bytecode": { - "doc_opcode": "EDF9", - "tlb": "#EDF9", - "prefix": "EDF9", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - ?" - } - }, - { - "mnemonic": "SAMEALT", - "doc": { - "category": "cont_registers", - "description": "Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.", - "gas": "26", - "fift": "SAMEALT" - }, - "bytecode": { - "doc_opcode": "EDFA", - "tlb": "#EDFA", - "prefix": "EDFA", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SAMEALTSAVE", - "doc": { - "category": "cont_registers", - "description": "Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.\nEquivalent to `c1 SAVE` `SAMEALT`.", - "gas": "26", - "fift": "SAMEALTSAVE" - }, - "bytecode": { - "doc_opcode": "EDFB", - "tlb": "#EDFB", - "prefix": "EDFB", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "CALLDICT", - "doc": { - "category": "cont_dict", - "description": "Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.\nApproximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.", - "gas": "", - "fift": "[nn] CALL\n[nn] CALLDICT" - }, - "bytecode": { - "doc_opcode": "F0nn", - "tlb": "#F0 n:uint8", - "prefix": "F0", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "- nn" - } - }, - { - "mnemonic": "CALLDICT_LONG", - "doc": { - "category": "cont_dict", - "description": "For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.", - "gas": "", - "fift": "[n] CALL\n[n] CALLDICT" - }, - "bytecode": { - "doc_opcode": "F12_n", - "tlb": "#F12_ n:uint14", - "prefix": "F12_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 14 - } - } - ] - }, - "value_flow": { - "doc_stack": "- n" - } - }, - { - "mnemonic": "JMPDICT", - "doc": { - "category": "cont_dict", - "description": "Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.\nApproximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.", - "gas": "", - "fift": "[n] JMP" - }, - "bytecode": { - "doc_opcode": "F16_n", - "tlb": "#F16_ n:uint14", - "prefix": "F16_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 14 - } - } - ] - }, - "value_flow": { - "doc_stack": " - n" - } - }, - { - "mnemonic": "PREPAREDICT", - "doc": { - "category": "cont_dict", - "description": "Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`.\nIn this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`.\nOne might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.", - "gas": "", - "fift": "[n] PREPARE\n[n] PREPAREDICT" - }, - "bytecode": { - "doc_opcode": "F1A_n", - "tlb": "#F1A_ n:uint14", - "prefix": "F1A_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 14 - } - } - ] - }, - "value_flow": { - "doc_stack": " - n c" - } - }, - { - "mnemonic": "THROW_SHORT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n <= 63` with parameter zero.\nIn other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.", - "gas": "76", - "fift": "[n] THROW" - }, - "bytecode": { - "doc_opcode": "F22_n", - "tlb": "#F22_ n:uint6", - "prefix": "F22_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 6 - } - } - ] - }, - "value_flow": { - "doc_stack": " - 0 n" - } - }, - { - "mnemonic": "THROWIF_SHORT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.", - "gas": "26/76", - "fift": "[n] THROWIF" - }, - "bytecode": { - "doc_opcode": "F26_n", - "tlb": "#F26_ n:uint6", - "prefix": "F26_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 6 - } - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "THROWIFNOT_SHORT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.", - "gas": "26/76", - "fift": "[n] THROWIFNOT" - }, - "bytecode": { - "doc_opcode": "F2A_n", - "tlb": "#F2A_ n:uint6", - "prefix": "F2A_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 6 - } - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "THROW", - "doc": { - "category": "exceptions", - "description": "For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.", - "gas": "84", - "fift": "[n] THROW" - }, - "bytecode": { - "doc_opcode": "F2C4_n", - "tlb": "#F2C4_ n:uint11", - "prefix": "F2C4_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "- 0 nn" - } - }, - { - "mnemonic": "THROWARG", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.", - "gas": "84", - "fift": "[n] THROWARG" - }, - "bytecode": { - "doc_opcode": "F2CC_n", - "tlb": "#F2CC_ n:uint11", - "prefix": "F2CC_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - x nn" - } - }, - { - "mnemonic": "THROWIF", - "doc": { - "category": "exceptions", - "description": "For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.", - "gas": "34/84", - "fift": "[n] THROWIF" - }, - "bytecode": { - "doc_opcode": "F2D4_n", - "tlb": "#F2D4_ n:uint11", - "prefix": "F2D4_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "THROWARGIF", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.", - "gas": "34/84", - "fift": "[n] THROWARGIF" - }, - "bytecode": { - "doc_opcode": "F2DC_n", - "tlb": "#F2DC_ n:uint11", - "prefix": "F2DC_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "x f - " - } - }, - { - "mnemonic": "THROWIFNOT", - "doc": { - "category": "exceptions", - "description": "For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.", - "gas": "34/84", - "fift": "[n] THROWIFNOT" - }, - "bytecode": { - "doc_opcode": "F2E4_n", - "tlb": "#F2E4_ n:uint11", - "prefix": "F2E4_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "f - " - } - }, - { - "mnemonic": "THROWARGIFNOT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.", - "gas": "34/84", - "fift": "[n] THROWARGIFNOT" - }, - "bytecode": { - "doc_opcode": "F2EC_n", - "tlb": "#F2EC_ n:uint11", - "prefix": "F2EC_", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 11 - } - } - ] - }, - "value_flow": { - "doc_stack": "x f - " - } - }, - { - "mnemonic": "THROWANY", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n < 2^16` with parameter zero.\nApproximately equivalent to `ZERO` `SWAP` `THROWARGANY`.", - "gas": "76", - "fift": "THROWANY" - }, - "bytecode": { - "doc_opcode": "F2F0", - "tlb": "#F2F0", - "prefix": "F2F0", - "operands": [] - }, - "value_flow": { - "doc_stack": "n - 0 n" - } - }, - { - "mnemonic": "THROWARGANY", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.\nApproximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.", - "gas": "76", - "fift": "THROWARGANY" - }, - "bytecode": { - "doc_opcode": "F2F1", - "tlb": "#F2F1", - "prefix": "F2F1", - "operands": [] - }, - "value_flow": { - "doc_stack": "x n - x n" - } - }, - { - "mnemonic": "THROWANYIF", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.", - "gas": "26/76", - "fift": "THROWANYIF" - }, - "bytecode": { - "doc_opcode": "F2F2", - "tlb": "#F2F2", - "prefix": "F2F2", - "operands": [] - }, - "value_flow": { - "doc_stack": "n f - " - } - }, - { - "mnemonic": "THROWARGANYIF", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.", - "gas": "26/76", - "fift": "THROWARGANYIF" - }, - "bytecode": { - "doc_opcode": "F2F3", - "tlb": "#F2F3", - "prefix": "F2F3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x n f - " - } - }, - { - "mnemonic": "THROWANYIFNOT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.", - "gas": "26/76", - "fift": "THROWANYIFNOT" - }, - "bytecode": { - "doc_opcode": "F2F4", - "tlb": "#F2F4", - "prefix": "F2F4", - "operands": [] - }, - "value_flow": { - "doc_stack": "n f - " - } - }, - { - "mnemonic": "THROWARGANYIFNOT", - "doc": { - "category": "exceptions", - "description": "Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.", - "gas": "26/76", - "fift": "THROWARGANYIFNOT" - }, - "bytecode": { - "doc_opcode": "F2F5", - "tlb": "#F2F5", - "prefix": "F2F5", - "operands": [] - }, - "value_flow": { - "doc_stack": "x n f - " - } - }, - { - "mnemonic": "TRY", - "doc": { - "category": "exceptions", - "description": "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.", - "gas": "26", - "fift": "TRY", - "fift_examples": [ - { - "fift": "TRY:<{ code1 }>CATCH<{ code2 }>", - "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `TRY`." - } - ] - }, - "bytecode": { - "doc_opcode": "F2FF", - "tlb": "#F2FF", - "prefix": "F2FF", - "operands": [] - }, - "value_flow": { - "doc_stack": "c c' - " - } - }, - { - "mnemonic": "TRYARGS", - "doc": { - "category": "exceptions", - "description": "Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`.\nIn 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.", - "gas": "26", - "fift": "[p] [r] TRYARGS" - }, - "bytecode": { - "doc_opcode": "F3pr", - "tlb": "#F3 p:uint4 r:uint4", - "prefix": "F3", - "operands": [ - { - "name": "p", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "c c' - " - } - }, - { - "mnemonic": "STDICT", - "doc": { - "category": "dict_serial", - "description": "Stores dictionary `D` into _Builder_ `b`, returing the resulting _Builder_ `b'`.\nIn 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.", - "gas": "26", - "fift": "STDICT\nSTOPTREF" - }, - "bytecode": { - "doc_opcode": "F400", - "tlb": "#F400", - "prefix": "F400", - "operands": [] - }, - "value_flow": { - "doc_stack": "D b - b'" - } - }, - { - "mnemonic": "SKIPDICT", - "doc": { - "category": "dict_serial", - "description": "Equivalent to `LDDICT` `NIP`.", - "gas": "26", - "fift": "SKIPDICT\nSKIPOPTREF" - }, - "bytecode": { - "doc_opcode": "F401", - "tlb": "#F401", - "prefix": "F401", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s'" - } - }, - { - "mnemonic": "LDDICTS", - "doc": { - "category": "dict_serial", - "description": "Loads (parses) a (_Slice_-represented) dictionary `s'` from _Slice_ `s`, and returns the remainder of `s` as `s''`.\nThis is a \u0432\u0402\u045asplit function'' for all `HashmapE(n,X)` dictionary types.", - "gas": "26", - "fift": "LDDICTS" - }, - "bytecode": { - "doc_opcode": "F402", - "tlb": "#F402", - "prefix": "F402", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s' s''" - } - }, - { - "mnemonic": "PLDDICTS", - "doc": { - "category": "dict_serial", - "description": "Preloads a (_Slice_-represented) dictionary `s'` from _Slice_ `s`.\nApproximately equivalent to `LDDICTS` `DROP`.", - "gas": "26", - "fift": "PLDDICTS" - }, - "bytecode": { - "doc_opcode": "F403", - "tlb": "#F403", - "prefix": "F403", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s'" - } - }, - { - "mnemonic": "LDDICT", - "doc": { - "category": "dict_serial", - "description": "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.", - "gas": "26", - "fift": "LDDICT\nLDOPTREF" - }, - "bytecode": { - "doc_opcode": "F404", - "tlb": "#F404", - "prefix": "F404", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - D s'" - } - }, - { - "mnemonic": "PLDDICT", - "doc": { - "category": "dict_serial", - "description": "Preloads a dictionary `D` from _Slice_ `s`.\nApproximately equivalent to `LDDICT` `DROP`.", - "gas": "26", - "fift": "PLDDICT\nPLDOPTREF" - }, - "bytecode": { - "doc_opcode": "F405", - "tlb": "#F405", - "prefix": "F405", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - D" - } - }, - { - "mnemonic": "LDDICTQ", - "doc": { - "category": "dict_serial", - "description": "A quiet version of `LDDICT`.", - "gas": "26", - "fift": "LDDICTQ" - }, - "bytecode": { - "doc_opcode": "F406", - "tlb": "#F406", - "prefix": "F406", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - D s' -1 or s 0" - } - }, - { - "mnemonic": "PLDDICTQ", - "doc": { - "category": "dict_serial", - "description": "A quiet version of `PLDDICT`.", - "gas": "26", - "fift": "PLDDICTQ" - }, - "bytecode": { - "doc_opcode": "F407", - "tlb": "#F407", - "prefix": "F407", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - D -1 or 0" - } - }, - { - "mnemonic": "DICTGET", - "doc": { - "category": "dict_get", - "description": "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.\nOn success, returns the value found as a _Slice_ `x`.", - "gas": "", - "fift": "DICTGET" - }, - "bytecode": { - "doc_opcode": "F40A", - "tlb": "#F40A", - "prefix": "F40A", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - x -1 or 0" - } - }, - { - "mnemonic": "DICTGETREF", - "doc": { - "category": "dict_get", - "description": "Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.\nThis operation is useful for dictionaries of type `HashmapE(n,^Y)`.", - "gas": "", - "fift": "DICTGETREF" - }, - "bytecode": { - "doc_opcode": "F40B", - "tlb": "#F40B", - "prefix": "F40B", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - c -1 or 0" - } - }, - { - "mnemonic": "DICTIGET", - "doc": { - "category": "dict_get", - "description": "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.", - "gas": "", - "fift": "DICTIGET" - }, - "bytecode": { - "doc_opcode": "F40C", - "tlb": "#F40C", - "prefix": "F40C", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x -1 or 0" - } - }, - { - "mnemonic": "DICTIGETREF", - "doc": { - "category": "dict_get", - "description": "Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit _Integer_ `i` as a key and returns a _Cell_ instead of a _Slice_ on success.", - "gas": "", - "fift": "DICTIGETREF" - }, - "bytecode": { - "doc_opcode": "F40D", - "tlb": "#F40D", - "prefix": "F40D", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - c -1 or 0" - } - }, - { - "mnemonic": "DICTUGET", - "doc": { - "category": "dict_get", - "description": "Similar to `DICTIGET`, but with _unsigned_ (big-endian) `n`-bit _Integer_ `i` used as a key.", - "gas": "", - "fift": "DICTUGET" - }, - "bytecode": { - "doc_opcode": "F40E", - "tlb": "#F40E", - "prefix": "F40E", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x -1 or 0" - } - }, - { - "mnemonic": "DICTUGETREF", - "doc": { - "category": "dict_get", - "description": "Similar to `DICTIGETREF`, but with an unsigned `n`-bit _Integer_ key `i`.", - "gas": "", - "fift": "DICTUGETREF" - }, - "bytecode": { - "doc_opcode": "F40F", - "tlb": "#F40F", - "prefix": "F40F", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - c -1 or 0" - } - }, - { - "mnemonic": "DICTSET", - "doc": { - "category": "dict_set", - "description": "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'`.", - "gas": "", - "fift": "DICTSET" - }, - "bytecode": { - "doc_opcode": "F412", - "tlb": "#F412", - "prefix": "F412", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D'" - } - }, - { - "mnemonic": "DICTSETREF", - "doc": { - "category": "dict_set", - "description": "Similar to `DICTSET`, but with the value set to a reference to _Cell_ `c`.", - "gas": "", - "fift": "DICTSETREF" - }, - "bytecode": { - "doc_opcode": "F413", - "tlb": "#F413", - "prefix": "F413", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D'" - } - }, - { - "mnemonic": "DICTISET", - "doc": { - "category": "dict_set", - "description": "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.", - "gas": "", - "fift": "DICTISET" - }, - "bytecode": { - "doc_opcode": "F414", - "tlb": "#F414", - "prefix": "F414", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D'" - } - }, - { - "mnemonic": "DICTISETREF", - "doc": { - "category": "dict_set", - "description": "Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.", - "gas": "", - "fift": "DICTISETREF" - }, - "bytecode": { - "doc_opcode": "F415", - "tlb": "#F415", - "prefix": "F415", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D'" - } - }, - { - "mnemonic": "DICTUSET", - "doc": { - "category": "dict_set", - "description": "Similar to `DICTISET`, but with `i` an _unsigned_ `n`-bit integer.", - "gas": "", - "fift": "DICTUSET" - }, - "bytecode": { - "doc_opcode": "F416", - "tlb": "#F416", - "prefix": "F416", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D'" - } - }, - { - "mnemonic": "DICTUSETREF", - "doc": { - "category": "dict_set", - "description": "Similar to `DICTISETREF`, but with `i` unsigned.", - "gas": "", - "fift": "DICTUSETREF" - }, - "bytecode": { - "doc_opcode": "F417", - "tlb": "#F417", - "prefix": "F417", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D'" - } - }, - { - "mnemonic": "DICTSETGET", - "doc": { - "category": "dict_set", - "description": "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.", - "gas": "", - "fift": "DICTSETGET" - }, - "bytecode": { - "doc_opcode": "F41A", - "tlb": "#F41A", - "prefix": "F41A", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTSETGETREF", - "doc": { - "category": "dict_set", - "description": "Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.", - "gas": "", - "fift": "DICTSETGETREF" - }, - "bytecode": { - "doc_opcode": "F41B", - "tlb": "#F41B", - "prefix": "F41B", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D' c' -1 or D' 0" - } - }, - { - "mnemonic": "DICTISETGET", - "doc": { - "category": "dict_set", - "description": "`DICTISETGET`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTISETGET" - }, - "bytecode": { - "doc_opcode": "F41C", - "tlb": "#F41C", - "prefix": "F41C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTISETGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTISETGETREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTISETGETREF" - }, - "bytecode": { - "doc_opcode": "F41D", - "tlb": "#F41D", - "prefix": "F41D", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' c' -1 or D' 0" - } - }, - { - "mnemonic": "DICTUSETGET", - "doc": { - "category": "dict_set", - "description": "`DICTISETGET`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUSETGET" - }, - "bytecode": { - "doc_opcode": "F41E", - "tlb": "#F41E", - "prefix": "F41E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTUSETGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUSETGETREF" - }, - "bytecode": { - "doc_opcode": "F41F", - "tlb": "#F41F", - "prefix": "F41F", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' c' -1 or D' 0" - } - }, - { - "mnemonic": "DICTREPLACE", - "doc": { - "category": "dict_set", - "description": "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`.", - "gas": "", - "fift": "DICTREPLACE" - }, - "bytecode": { - "doc_opcode": "F422", - "tlb": "#F422", - "prefix": "F422", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTREPLACEREF", - "doc": { - "category": "dict_set", - "description": "A _Replace_ counterpart of `DICTSETREF`.", - "gas": "", - "fift": "DICTREPLACEREF" - }, - "bytecode": { - "doc_opcode": "F423", - "tlb": "#F423", - "prefix": "F423", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACE", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACE`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIREPLACE" - }, - "bytecode": { - "doc_opcode": "F424", - "tlb": "#F424", - "prefix": "F424", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACEREF", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIREPLACEREF" - }, - "bytecode": { - "doc_opcode": "F425", - "tlb": "#F425", - "prefix": "F425", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACE", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACE`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUREPLACE" - }, - "bytecode": { - "doc_opcode": "F426", - "tlb": "#F426", - "prefix": "F426", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACEREF", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUREPLACEREF" - }, - "bytecode": { - "doc_opcode": "F427", - "tlb": "#F427", - "prefix": "F427", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTREPLACEGET", - "doc": { - "category": "dict_set", - "description": "A _Replace_ counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.", - "gas": "", - "fift": "DICTREPLACEGET" - }, - "bytecode": { - "doc_opcode": "F42A", - "tlb": "#F42A", - "prefix": "F42A", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTREPLACEGETREF", - "doc": { - "category": "dict_set", - "description": "A _Replace_ counterpart of `DICTSETGETREF`.", - "gas": "", - "fift": "DICTREPLACEGETREF" - }, - "bytecode": { - "doc_opcode": "F42B", - "tlb": "#F42B", - "prefix": "F42B", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D' c' -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACEGET", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEGET`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIREPLACEGET" - }, - "bytecode": { - "doc_opcode": "F42C", - "tlb": "#F42C", - "prefix": "F42C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACEGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIREPLACEGETREF" - }, - "bytecode": { - "doc_opcode": "F42D", - "tlb": "#F42D", - "prefix": "F42D", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' c' -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACEGET", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUREPLACEGET" - }, - "bytecode": { - "doc_opcode": "F42E", - "tlb": "#F42E", - "prefix": "F42E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACEGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUREPLACEGETREF" - }, - "bytecode": { - "doc_opcode": "F42F", - "tlb": "#F42F", - "prefix": "F42F", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' c' -1 or D 0" - } - }, - { - "mnemonic": "DICTADD", - "doc": { - "category": "dict_set", - "description": "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`.", - "gas": "", - "fift": "DICTADD" - }, - "bytecode": { - "doc_opcode": "F432", - "tlb": "#F432", - "prefix": "F432", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTADDREF", - "doc": { - "category": "dict_set", - "description": "An _Add_ counterpart of `DICTSETREF`.", - "gas": "", - "fift": "DICTADDREF" - }, - "bytecode": { - "doc_opcode": "F433", - "tlb": "#F433", - "prefix": "F433", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIADD", - "doc": { - "category": "dict_set", - "description": "`DICTADD`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIADD" - }, - "bytecode": { - "doc_opcode": "F434", - "tlb": "#F434", - "prefix": "F434", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIADDREF", - "doc": { - "category": "dict_set", - "description": "`DICTADDREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIADDREF" - }, - "bytecode": { - "doc_opcode": "F435", - "tlb": "#F435", - "prefix": "F435", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUADD", - "doc": { - "category": "dict_set", - "description": "`DICTADD`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUADD" - }, - "bytecode": { - "doc_opcode": "F436", - "tlb": "#F436", - "prefix": "F436", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUADDREF", - "doc": { - "category": "dict_set", - "description": "`DICTADDREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUADDREF" - }, - "bytecode": { - "doc_opcode": "F437", - "tlb": "#F437", - "prefix": "F437", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTADDGET", - "doc": { - "category": "dict_set", - "description": "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.", - "gas": "", - "fift": "DICTADDGET" - }, - "bytecode": { - "doc_opcode": "F43A", - "tlb": "#F43A", - "prefix": "F43A", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTADDGETREF", - "doc": { - "category": "dict_set", - "description": "An _Add_ counterpart of `DICTSETGETREF`.", - "gas": "", - "fift": "DICTADDGETREF" - }, - "bytecode": { - "doc_opcode": "F43B", - "tlb": "#F43B", - "prefix": "F43B", - "operands": [] - }, - "value_flow": { - "doc_stack": "c k D n - D' -1 or D c' 0" - } - }, - { - "mnemonic": "DICTIADDGET", - "doc": { - "category": "dict_set", - "description": "`DICTADDGET`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIADDGET" - }, - "bytecode": { - "doc_opcode": "F43C", - "tlb": "#F43C", - "prefix": "F43C", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTIADDGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTADDGETREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIADDGETREF" - }, - "bytecode": { - "doc_opcode": "F43D", - "tlb": "#F43D", - "prefix": "F43D", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D c' 0" - } - }, - { - "mnemonic": "DICTUADDGET", - "doc": { - "category": "dict_set", - "description": "`DICTADDGET`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUADDGET" - }, - "bytecode": { - "doc_opcode": "F43E", - "tlb": "#F43E", - "prefix": "F43E", - "operands": [] - }, - "value_flow": { - "doc_stack": "x i D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTUADDGETREF", - "doc": { - "category": "dict_set", - "description": "`DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUADDGETREF" - }, - "bytecode": { - "doc_opcode": "F43F", - "tlb": "#F43F", - "prefix": "F43F", - "operands": [] - }, - "value_flow": { - "doc_stack": "c i D n - D' -1 or D c' 0" - } - }, - { - "mnemonic": "DICTSETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTSETB" - }, - "bytecode": { - "doc_opcode": "F441", - "tlb": "#F441", - "prefix": "F441", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D'" - } - }, - { - "mnemonic": "DICTISETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTISETB" - }, - "bytecode": { - "doc_opcode": "F442", - "tlb": "#F442", - "prefix": "F442", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D'" - } - }, - { - "mnemonic": "DICTUSETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUSETB" - }, - "bytecode": { - "doc_opcode": "F443", - "tlb": "#F443", - "prefix": "F443", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D'" - } - }, - { - "mnemonic": "DICTSETGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTSETGETB" - }, - "bytecode": { - "doc_opcode": "F445", - "tlb": "#F445", - "prefix": "F445", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTISETGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTISETGETB" - }, - "bytecode": { - "doc_opcode": "F446", - "tlb": "#F446", - "prefix": "F446", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTUSETGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUSETGETB" - }, - "bytecode": { - "doc_opcode": "F447", - "tlb": "#F447", - "prefix": "F447", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' y -1 or D' 0" - } - }, - { - "mnemonic": "DICTREPLACEB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTREPLACEB" - }, - "bytecode": { - "doc_opcode": "F449", - "tlb": "#F449", - "prefix": "F449", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACEB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTIREPLACEB" - }, - "bytecode": { - "doc_opcode": "F44A", - "tlb": "#F44A", - "prefix": "F44A", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACEB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUREPLACEB" - }, - "bytecode": { - "doc_opcode": "F44B", - "tlb": "#F44B", - "prefix": "F44B", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTREPLACEGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTREPLACEGETB" - }, - "bytecode": { - "doc_opcode": "F44D", - "tlb": "#F44D", - "prefix": "F44D", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTIREPLACEGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTIREPLACEGETB" - }, - "bytecode": { - "doc_opcode": "F44E", - "tlb": "#F44E", - "prefix": "F44E", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTUREPLACEGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUREPLACEGETB" - }, - "bytecode": { - "doc_opcode": "F44F", - "tlb": "#F44F", - "prefix": "F44F", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' y -1 or D 0" - } - }, - { - "mnemonic": "DICTADDB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTADDB" - }, - "bytecode": { - "doc_opcode": "F451", - "tlb": "#F451", - "prefix": "F451", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIADDB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTIADDB" - }, - "bytecode": { - "doc_opcode": "F452", - "tlb": "#F452", - "prefix": "F452", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTUADDB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUADDB" - }, - "bytecode": { - "doc_opcode": "F453", - "tlb": "#F453", - "prefix": "F453", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTADDGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTADDGETB" - }, - "bytecode": { - "doc_opcode": "F455", - "tlb": "#F455", - "prefix": "F455", - "operands": [] - }, - "value_flow": { - "doc_stack": "b k D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTIADDGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTIADDGETB" - }, - "bytecode": { - "doc_opcode": "F456", - "tlb": "#F456", - "prefix": "F456", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTUADDGETB", - "doc": { - "category": "dict_set_builder", - "description": "", - "gas": "", - "fift": "DICTUADDGETB" - }, - "bytecode": { - "doc_opcode": "F457", - "tlb": "#F457", - "prefix": "F457", - "operands": [] - }, - "value_flow": { - "doc_stack": "b i D n - D' -1 or D y 0" - } - }, - { - "mnemonic": "DICTDEL", - "doc": { - "category": "dict_delete", - "description": "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`.", - "gas": "", - "fift": "DICTDEL" - }, - "bytecode": { - "doc_opcode": "F459", - "tlb": "#F459", - "prefix": "F459", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTIDEL", - "doc": { - "category": "dict_delete", - "description": "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` (\u0432\u0402\u045akey not found, dictionary unmodified'').", - "gas": "", - "fift": "DICTIDEL" - }, - "bytecode": { - "doc_opcode": "F45A", - "tlb": "#F45A", - "prefix": "F45A", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' ?" - } - }, - { - "mnemonic": "DICTUDEL", - "doc": { - "category": "dict_delete", - "description": "Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUDEL" - }, - "bytecode": { - "doc_opcode": "F45B", - "tlb": "#F45B", - "prefix": "F45B", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' ?" - } - }, - { - "mnemonic": "DICTDELGET", - "doc": { - "category": "dict_delete", - "description": "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`.", - "gas": "", - "fift": "DICTDELGET" - }, - "bytecode": { - "doc_opcode": "F462", - "tlb": "#F462", - "prefix": "F462", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - D' x -1 or D 0" - } - }, - { - "mnemonic": "DICTDELGETREF", - "doc": { - "category": "dict_delete", - "description": "Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a _Cell_.", - "gas": "", - "fift": "DICTDELGETREF" - }, - "bytecode": { - "doc_opcode": "F463", - "tlb": "#F463", - "prefix": "F463", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - D' c -1 or D 0" - } - }, - { - "mnemonic": "DICTIDELGET", - "doc": { - "category": "dict_delete", - "description": "`DICTDELGET`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIDELGET" - }, - "bytecode": { - "doc_opcode": "F464", - "tlb": "#F464", - "prefix": "F464", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' x -1 or D 0" - } - }, - { - "mnemonic": "DICTIDELGETREF", - "doc": { - "category": "dict_delete", - "description": "`DICTDELGETREF`, but with `i` a signed `n`-bit integer.", - "gas": "", - "fift": "DICTIDELGETREF" - }, - "bytecode": { - "doc_opcode": "F465", - "tlb": "#F465", - "prefix": "F465", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' c -1 or D 0" - } - }, - { - "mnemonic": "DICTUDELGET", - "doc": { - "category": "dict_delete", - "description": "`DICTDELGET`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUDELGET" - }, - "bytecode": { - "doc_opcode": "F466", - "tlb": "#F466", - "prefix": "F466", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' x -1 or D 0" - } - }, - { - "mnemonic": "DICTUDELGETREF", - "doc": { - "category": "dict_delete", - "description": "`DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.", - "gas": "", - "fift": "DICTUDELGETREF" - }, - "bytecode": { - "doc_opcode": "F467", - "tlb": "#F467", - "prefix": "F467", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - D' c -1 or D 0" - } - }, - { - "mnemonic": "DICTGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "A variant of `DICTGETREF` that returns _Null_ instead of the value `c^?` if the key `k` is absent from dictionary `D`.", - "gas": "", - "fift": "DICTGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F469", - "tlb": "#F469", - "prefix": "F469", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - c^?" - } - }, - { - "mnemonic": "DICTIGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "`DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns _Null_.", - "gas": "", - "fift": "DICTIGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F46A", - "tlb": "#F46A", - "prefix": "F46A", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - c^?" - } - }, - { - "mnemonic": "DICTUGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "`DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns _Null_.", - "gas": "", - "fift": "DICTUGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F46B", - "tlb": "#F46B", - "prefix": "F46B", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - c^?" - } - }, - { - "mnemonic": "DICTSETGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "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).", - "gas": "", - "fift": "DICTSETGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F46D", - "tlb": "#F46D", - "prefix": "F46D", - "operands": [] - }, - "value_flow": { - "doc_stack": "c^? k D n - D' ~c^?" - } - }, - { - "mnemonic": "DICTISETGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "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.", - "gas": "", - "fift": "DICTISETGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F46E", - "tlb": "#F46E", - "prefix": "F46E", - "operands": [] - }, - "value_flow": { - "doc_stack": "c^? i D n - D' ~c^?" - } - }, - { - "mnemonic": "DICTUSETGETOPTREF", - "doc": { - "category": "dict_mayberef", - "description": "Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit _Integer_ `i` as a key.", - "gas": "", - "fift": "DICTUSETGETOPTREF" - }, - "bytecode": { - "doc_opcode": "F46F", - "tlb": "#F46F", - "prefix": "F46F", - "operands": [] - }, - "value_flow": { - "doc_stack": "c^? i D n - D' ~c^?" - } - }, - { - "mnemonic": "PFXDICTSET", - "doc": { - "category": "dict_prefix", - "description": "", - "gas": "", - "fift": "PFXDICTSET" - }, - "bytecode": { - "doc_opcode": "F470", - "tlb": "#F470", - "prefix": "F470", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "PFXDICTREPLACE", - "doc": { - "category": "dict_prefix", - "description": "", - "gas": "", - "fift": "PFXDICTREPLACE" - }, - "bytecode": { - "doc_opcode": "F471", - "tlb": "#F471", - "prefix": "F471", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "PFXDICTADD", - "doc": { - "category": "dict_prefix", - "description": "", - "gas": "", - "fift": "PFXDICTADD" - }, - "bytecode": { - "doc_opcode": "F472", - "tlb": "#F472", - "prefix": "F472", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "PFXDICTDEL", - "doc": { - "category": "dict_prefix", - "description": "", - "gas": "", - "fift": "PFXDICTDEL" - }, - "bytecode": { - "doc_opcode": "F473", - "tlb": "#F473", - "prefix": "F473", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - D' -1 or D 0" - } - }, - { - "mnemonic": "DICTGETNEXT", - "doc": { - "category": "dict_next", - "description": "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_).", - "gas": "", - "fift": "DICTGETNEXT" - }, - "bytecode": { - "doc_opcode": "F474", - "tlb": "#F474", - "prefix": "F474", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - x' k' -1 or 0" - } - }, - { - "mnemonic": "DICTGETNEXTEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.", - "gas": "", - "fift": "DICTGETNEXTEQ" - }, - "bytecode": { - "doc_opcode": "F475", - "tlb": "#F475", - "prefix": "F475", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - x' k' -1 or 0" - } - }, - { - "mnemonic": "DICTGETPREV", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.", - "gas": "", - "fift": "DICTGETPREV" - }, - "bytecode": { - "doc_opcode": "F476", - "tlb": "#F476", - "prefix": "F476", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - x' k' -1 or 0" - } - }, - { - "mnemonic": "DICTGETPREVEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.", - "gas": "", - "fift": "DICTGETPREVEQ" - }, - "bytecode": { - "doc_opcode": "F477", - "tlb": "#F477", - "prefix": "F477", - "operands": [] - }, - "value_flow": { - "doc_stack": "k D n - x' k' -1 or 0" - } - }, - { - "mnemonic": "DICTIGETNEXT", - "doc": { - "category": "dict_next", - "description": "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).", - "gas": "", - "fift": "DICTIGETNEXT" - }, - "bytecode": { - "doc_opcode": "F478", - "tlb": "#F478", - "prefix": "F478", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTIGETNEXTEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.", - "gas": "", - "fift": "DICTIGETNEXTEQ" - }, - "bytecode": { - "doc_opcode": "F479", - "tlb": "#F479", - "prefix": "F479", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTIGETPREV", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.", - "gas": "", - "fift": "DICTIGETPREV" - }, - "bytecode": { - "doc_opcode": "F47A", - "tlb": "#F47A", - "prefix": "F47A", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTIGETPREVEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.", - "gas": "", - "fift": "DICTIGETPREVEQ" - }, - "bytecode": { - "doc_opcode": "F47B", - "tlb": "#F47B", - "prefix": "F47B", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTUGETNEXT", - "doc": { - "category": "dict_next", - "description": "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).", - "gas": "", - "fift": "DICTUGETNEXT" - }, - "bytecode": { - "doc_opcode": "F47C", - "tlb": "#F47C", - "prefix": "F47C", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTUGETNEXTEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.", - "gas": "", - "fift": "DICTUGETNEXTEQ" - }, - "bytecode": { - "doc_opcode": "F47D", - "tlb": "#F47D", - "prefix": "F47D", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTUGETPREV", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.", - "gas": "", - "fift": "DICTUGETPREV" - }, - "bytecode": { - "doc_opcode": "F47E", - "tlb": "#F47E", - "prefix": "F47E", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTUGETPREVEQ", - "doc": { - "category": "dict_next", - "description": "Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.", - "gas": "", - "fift": "DICTUGETPREVEQ" - }, - "bytecode": { - "doc_opcode": "F47F", - "tlb": "#F47F", - "prefix": "F47F", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - x' i' -1 or 0" - } - }, - { - "mnemonic": "DICTMIN", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTMIN" - }, - "bytecode": { - "doc_opcode": "F482", - "tlb": "#F482", - "prefix": "F482", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x k -1 or 0" - } - }, - { - "mnemonic": "DICTMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTMIN`, but returns the only reference in the value as a _Cell_ `c`.", - "gas": "", - "fift": "DICTMINREF" - }, - "bytecode": { - "doc_opcode": "F483", - "tlb": "#F483", - "prefix": "F483", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c k -1 or 0" - } - }, - { - "mnemonic": "DICTIMIN", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTIMIN" - }, - "bytecode": { - "doc_opcode": "F484", - "tlb": "#F484", - "prefix": "F484", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x i -1 or 0" - } - }, - { - "mnemonic": "DICTIMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTIMIN`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTIMINREF" - }, - "bytecode": { - "doc_opcode": "F485", - "tlb": "#F485", - "prefix": "F485", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c i -1 or 0" - } - }, - { - "mnemonic": "DICTUMIN", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", - "gas": "", - "fift": "DICTUMIN" - }, - "bytecode": { - "doc_opcode": "F486", - "tlb": "#F486", - "prefix": "F486", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x i -1 or 0" - } - }, - { - "mnemonic": "DICTUMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTUMIN`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTUMINREF" - }, - "bytecode": { - "doc_opcode": "F487", - "tlb": "#F487", - "prefix": "F487", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c i -1 or 0" - } - }, - { - "mnemonic": "DICTMAX", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTMAX" - }, - "bytecode": { - "doc_opcode": "F48A", - "tlb": "#F48A", - "prefix": "F48A", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x k -1 or 0" - } - }, - { - "mnemonic": "DICTMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTMAX`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTMAXREF" - }, - "bytecode": { - "doc_opcode": "F48B", - "tlb": "#F48B", - "prefix": "F48B", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c k -1 or 0" - } - }, - { - "mnemonic": "DICTIMAX", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTIMAX" - }, - "bytecode": { - "doc_opcode": "F48C", - "tlb": "#F48C", - "prefix": "F48C", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x i -1 or 0" - } - }, - { - "mnemonic": "DICTIMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTIMAX`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTIMAXREF" - }, - "bytecode": { - "doc_opcode": "F48D", - "tlb": "#F48D", - "prefix": "F48D", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c i -1 or 0" - } - }, - { - "mnemonic": "DICTUMAX", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", - "gas": "", - "fift": "DICTUMAX" - }, - "bytecode": { - "doc_opcode": "F48E", - "tlb": "#F48E", - "prefix": "F48E", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - x i -1 or 0" - } - }, - { - "mnemonic": "DICTUMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTUMAX`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTUMAXREF" - }, - "bytecode": { - "doc_opcode": "F48F", - "tlb": "#F48F", - "prefix": "F48F", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - c i -1 or 0" - } - }, - { - "mnemonic": "DICTREMMIN", - "doc": { - "category": "dict_min", - "description": "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'`.", - "gas": "", - "fift": "DICTREMMIN" - }, - "bytecode": { - "doc_opcode": "F492", - "tlb": "#F492", - "prefix": "F492", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x k -1 or D 0" - } - }, - { - "mnemonic": "DICTREMMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTREMMIN`, but returns the only reference in the value as a _Cell_ `c`.", - "gas": "", - "fift": "DICTREMMINREF" - }, - "bytecode": { - "doc_opcode": "F493", - "tlb": "#F493", - "prefix": "F493", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c k -1 or D 0" - } - }, - { - "mnemonic": "DICTIREMMIN", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTIREMMIN" - }, - "bytecode": { - "doc_opcode": "F494", - "tlb": "#F494", - "prefix": "F494", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x i -1 or D 0" - } - }, - { - "mnemonic": "DICTIREMMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTIREMMIN`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTIREMMINREF" - }, - "bytecode": { - "doc_opcode": "F495", - "tlb": "#F495", - "prefix": "F495", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c i -1 or D 0" - } - }, - { - "mnemonic": "DICTUREMMIN", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", - "gas": "", - "fift": "DICTUREMMIN" - }, - "bytecode": { - "doc_opcode": "F496", - "tlb": "#F496", - "prefix": "F496", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x i -1 or D 0" - } - }, - { - "mnemonic": "DICTUREMMINREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTUREMMIN`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTUREMMINREF" - }, - "bytecode": { - "doc_opcode": "F497", - "tlb": "#F497", - "prefix": "F497", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c i -1 or D 0" - } - }, - { - "mnemonic": "DICTREMMAX", - "doc": { - "category": "dict_min", - "description": "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'`.", - "gas": "", - "fift": "DICTREMMAX" - }, - "bytecode": { - "doc_opcode": "F49A", - "tlb": "#F49A", - "prefix": "F49A", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x k -1 or D 0" - } - }, - { - "mnemonic": "DICTREMMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTREMMAX`, but returns the only reference in the value as a _Cell_ `c`.", - "gas": "", - "fift": "DICTREMMAXREF" - }, - "bytecode": { - "doc_opcode": "F49B", - "tlb": "#F49B", - "prefix": "F49B", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c k -1 or D 0" - } - }, - { - "mnemonic": "DICTIREMMAX", - "doc": { - "category": "dict_min", - "description": "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`.", - "gas": "", - "fift": "DICTIREMMAX" - }, - "bytecode": { - "doc_opcode": "F49C", - "tlb": "#F49C", - "prefix": "F49C", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x i -1 or D 0" - } - }, - { - "mnemonic": "DICTIREMMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTIREMMAX`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTIREMMAXREF" - }, - "bytecode": { - "doc_opcode": "F49D", - "tlb": "#F49D", - "prefix": "F49D", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c i -1 or D 0" - } - }, - { - "mnemonic": "DICTUREMMAX", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", - "gas": "", - "fift": "DICTUREMMAX" - }, - "bytecode": { - "doc_opcode": "F49E", - "tlb": "#F49E", - "prefix": "F49E", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' x i -1 or D 0" - } - }, - { - "mnemonic": "DICTUREMMAXREF", - "doc": { - "category": "dict_min", - "description": "Similar to `DICTUREMMAX`, but returns the only reference in the value.", - "gas": "", - "fift": "DICTUREMMAXREF" - }, - "bytecode": { - "doc_opcode": "F49F", - "tlb": "#F49F", - "prefix": "F49F", - "operands": [] - }, - "value_flow": { - "doc_stack": "D n - D' c i -1 or D 0" - } - }, - { - "mnemonic": "DICTIGETJMP", - "doc": { - "category": "dict_special", - "description": "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.", - "gas": "", - "fift": "DICTIGETJMP" - }, - "bytecode": { - "doc_opcode": "F4A0", - "tlb": "#F4A0", - "prefix": "F4A0", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - " - } - }, - { - "mnemonic": "DICTUGETJMP", - "doc": { - "category": "dict_special", - "description": "Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.", - "gas": "", - "fift": "DICTUGETJMP" - }, - "bytecode": { - "doc_opcode": "F4A1", - "tlb": "#F4A1", - "prefix": "F4A1", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - " - } - }, - { - "mnemonic": "DICTIGETEXEC", - "doc": { - "category": "dict_special", - "description": "Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.", - "gas": "", - "fift": "DICTIGETEXEC" - }, - "bytecode": { - "doc_opcode": "F4A2", - "tlb": "#F4A2", - "prefix": "F4A2", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - " - } - }, - { - "mnemonic": "DICTUGETEXEC", - "doc": { - "category": "dict_special", - "description": "Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.", - "gas": "", - "fift": "DICTUGETEXEC" - }, - "bytecode": { - "doc_opcode": "F4A3", - "tlb": "#F4A3", - "prefix": "F4A3", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - " - } - }, - { - "mnemonic": "DICTPUSHCONST", - "doc": { - "category": "dict_special", - "description": "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.", - "gas": "34", - "fift": "[ref] [n] DICTPUSHCONST" - }, - "bytecode": { - "doc_opcode": "F4A6_n", - "tlb": "#F4A6_ d:^Cell n:uint10", - "prefix": "F4A6_", - "operands": [ - { - "name": "d", - "loader": "ref", - "loader_args": {} - }, - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 10 - } - } - ] - }, - "value_flow": { - "doc_stack": " - D n" - } - }, - { - "mnemonic": "PFXDICTGETQ", - "doc": { - "category": "dict_special", - "description": "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.", - "gas": "", - "fift": "PFXDICTGETQ" - }, - "bytecode": { - "doc_opcode": "F4A8", - "tlb": "#F4A8", - "prefix": "F4A8", - "operands": [] - }, - "value_flow": { - "doc_stack": "s D n - s' x s'' -1 or s 0" - } - }, - { - "mnemonic": "PFXDICTGET", - "doc": { - "category": "dict_special", - "description": "Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.", - "gas": "", - "fift": "PFXDICTGET" - }, - "bytecode": { - "doc_opcode": "F4A9", - "tlb": "#F4A9", - "prefix": "F4A9", - "operands": [] - }, - "value_flow": { - "doc_stack": "s D n - s' x s''" - } - }, - { - "mnemonic": "PFXDICTGETJMP", - "doc": { - "category": "dict_special", - "description": "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.", - "gas": "", - "fift": "PFXDICTGETJMP" - }, - "bytecode": { - "doc_opcode": "F4AA", - "tlb": "#F4AA", - "prefix": "F4AA", - "operands": [] - }, - "value_flow": { - "doc_stack": "s D n - s' s'' or s" - } - }, - { - "mnemonic": "PFXDICTGETEXEC", - "doc": { - "category": "dict_special", - "description": "Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.", - "gas": "", - "fift": "PFXDICTGETEXEC" - }, - "bytecode": { - "doc_opcode": "F4AB", - "tlb": "#F4AB", - "prefix": "F4AB", - "operands": [] - }, - "value_flow": { - "doc_stack": "s D n - s' s''" - } - }, - { - "mnemonic": "PFXDICTCONSTGETJMP", - "doc": { - "category": "dict_special", - "description": "Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.", - "gas": "", - "fift": "[ref] [n] PFXDICTCONSTGETJMP\n[ref] [n] PFXDICTSWITCH" - }, - "bytecode": { - "doc_opcode": "F4AE_n", - "tlb": "#F4AE_ d:^Cell n:uint10", - "prefix": "F4AE_", - "operands": [ - { - "name": "d", - "loader": "ref", - "loader_args": {} - }, - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 10 - } - } - ] - }, - "value_flow": { - "doc_stack": "s - s' s'' or s" - } - }, - { - "mnemonic": "DICTIGETJMPZ", - "doc": { - "category": "dict_special", - "description": "A variant of `DICTIGETJMP` that returns index `i` on failure.", - "gas": "", - "fift": "DICTIGETJMPZ" - }, - "bytecode": { - "doc_opcode": "F4BC", - "tlb": "#F4BC", - "prefix": "F4BC", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - i or nothing" - } - }, - { - "mnemonic": "DICTUGETJMPZ", - "doc": { - "category": "dict_special", - "description": "A variant of `DICTUGETJMP` that returns index `i` on failure.", - "gas": "", - "fift": "DICTUGETJMPZ" - }, - "bytecode": { - "doc_opcode": "F4BD", - "tlb": "#F4BD", - "prefix": "F4BD", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - i or nothing" - } - }, - { - "mnemonic": "DICTIGETEXECZ", - "doc": { - "category": "dict_special", - "description": "A variant of `DICTIGETEXEC` that returns index `i` on failure.", - "gas": "", - "fift": "DICTIGETEXECZ" - }, - "bytecode": { - "doc_opcode": "F4BE", - "tlb": "#F4BE", - "prefix": "F4BE", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - i or nothing" - } - }, - { - "mnemonic": "DICTUGETEXECZ", - "doc": { - "category": "dict_special", - "description": "A variant of `DICTUGETEXEC` that returns index `i` on failure.", - "gas": "", - "fift": "DICTUGETEXECZ" - }, - "bytecode": { - "doc_opcode": "F4BF", - "tlb": "#F4BF", - "prefix": "F4BF", - "operands": [] - }, - "value_flow": { - "doc_stack": "i D n - i or nothing" - } - }, - { - "mnemonic": "SUBDICTGET", - "doc": { - "category": "dict_sub", - "description": "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'`.", - "gas": "", - "fift": "SUBDICTGET" - }, - "bytecode": { - "doc_opcode": "F4B1", - "tlb": "#F4B1", - "prefix": "F4B1", - "operands": [] - }, - "value_flow": { - "doc_stack": "k l D n - D'" - } - }, - { - "mnemonic": "SUBDICTIGET", - "doc": { - "category": "dict_sub", - "description": "Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 257`.", - "gas": "", - "fift": "SUBDICTIGET" - }, - "bytecode": { - "doc_opcode": "F4B2", - "tlb": "#F4B2", - "prefix": "F4B2", - "operands": [] - }, - "value_flow": { - "doc_stack": "x l D n - D'" - } - }, - { - "mnemonic": "SUBDICTUGET", - "doc": { - "category": "dict_sub", - "description": "Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 256`.", - "gas": "", - "fift": "SUBDICTUGET" - }, - "bytecode": { - "doc_opcode": "F4B3", - "tlb": "#F4B3", - "prefix": "F4B3", - "operands": [] - }, - "value_flow": { - "doc_stack": "x l D n - D'" - } - }, - { - "mnemonic": "SUBDICTRPGET", - "doc": { - "category": "dict_sub", - "description": "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)`.", - "gas": "", - "fift": "SUBDICTRPGET" - }, - "bytecode": { - "doc_opcode": "F4B5", - "tlb": "#F4B5", - "prefix": "F4B5", - "operands": [] - }, - "value_flow": { - "doc_stack": "k l D n - D'" - } - }, - { - "mnemonic": "SUBDICTIRPGET", - "doc": { - "category": "dict_sub", - "description": "Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 257`.", - "gas": "", - "fift": "SUBDICTIRPGET" - }, - "bytecode": { - "doc_opcode": "F4B6", - "tlb": "#F4B6", - "prefix": "F4B6", - "operands": [] - }, - "value_flow": { - "doc_stack": "x l D n - D'" - } - }, - { - "mnemonic": "SUBDICTURPGET", - "doc": { - "category": "dict_sub", - "description": "Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 256`.", - "gas": "", - "fift": "SUBDICTURPGET" - }, - "bytecode": { - "doc_opcode": "F4B7", - "tlb": "#F4B7", - "prefix": "F4B7", - "operands": [] - }, - "value_flow": { - "doc_stack": "x l D n - D'" - } - }, - { - "mnemonic": "ACCEPT", - "doc": { - "category": "app_gas", - "description": "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.\nIn 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.", - "gas": "26", - "fift": "ACCEPT" - }, - "bytecode": { - "doc_opcode": "F800", - "tlb": "#F800", - "prefix": "F800", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SETGASLIMIT", - "doc": { - "category": "app_gas", - "description": "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`.", - "gas": "26", - "fift": "SETGASLIMIT" - }, - "bytecode": { - "doc_opcode": "F801", - "tlb": "#F801", - "prefix": "F801", - "operands": [] - }, - "value_flow": { - "doc_stack": "g - " - } - }, - { - "mnemonic": "COMMIT", - "doc": { - "category": "app_gas", - "description": "Commits the current state of registers `c4` (\u0432\u0402\u045apersistent data'') and `c5` (\u0432\u0402\u045aactions'') so that the current execution is considered \u0432\u0402\u045asuccessful'' with the saved values even if an exception is thrown later.", - "gas": "26", - "fift": "COMMIT" - }, - "bytecode": { - "doc_opcode": "F80F", - "tlb": "#F80F", - "prefix": "F80F", - "operands": [] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "RANDU256", - "doc": { - "category": "app_rnd", - "description": "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`.", - "gas": "26+|c7|+|c1_1|", - "fift": "RANDU256" - }, - "bytecode": { - "doc_opcode": "F810", - "tlb": "#F810", - "prefix": "F810", - "operands": [] - }, - "value_flow": { - "doc_stack": "- x" - } - }, - { - "mnemonic": "RAND", - "doc": { - "category": "app_rnd", - "description": "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.\nEquivalent to `RANDU256` `256 MULRSHIFT`.", - "gas": "26+|c7|+|c1_1|", - "fift": "RAND" - }, - "bytecode": { - "doc_opcode": "F811", - "tlb": "#F811", - "prefix": "F811", - "operands": [] - }, - "value_flow": { - "doc_stack": "y - z" - } - }, - { - "mnemonic": "SETRAND", - "doc": { - "category": "app_rnd", - "description": "Sets the random seed to unsigned 256-bit _Integer_ `x`.", - "gas": "26+|c7|+|c1_1|", - "fift": "SETRAND" - }, - "bytecode": { - "doc_opcode": "F814", - "tlb": "#F814", - "prefix": "F814", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "ADDRAND", - "doc": { - "category": "app_rnd", - "description": "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`.", - "gas": "26", - "fift": "ADDRAND\nRANDOMIZE" - }, - "bytecode": { - "doc_opcode": "F815", - "tlb": "#F815", - "prefix": "F815", - "operands": [] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "GETPARAM", - "doc": { - "category": "app_config", - "description": "Returns the `i`-th parameter from the _Tuple_ provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.\nIf one of these internal operations fails, throws an appropriate type checking or range checking exception.", - "gas": "26", - "fift": "[i] GETPARAM" - }, - "bytecode": { - "doc_opcode": "F82i", - "tlb": "#F82 i:uint4", - "prefix": "F82", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": " - x" - } - }, - { - "mnemonic": "CONFIGDICT", - "doc": { - "category": "app_config", - "description": "Returns the global configuration dictionary along with its key length (32).\nEquivalent to `CONFIGROOT` `32 PUSHINT`.", - "gas": "26", - "fift": "CONFIGDICT" - }, - "bytecode": { - "doc_opcode": "F830", - "tlb": "#F830", - "prefix": "F830", - "operands": [] - }, - "value_flow": { - "doc_stack": " - D 32" - } - }, - { - "mnemonic": "CONFIGPARAM", - "doc": { - "category": "app_config", - "description": "Returns the value of the global configuration parameter with integer index `i` as a _Cell_ `c`, and a flag to indicate success.\nEquivalent to `CONFIGDICT` `DICTIGETREF`.", - "gas": "", - "fift": "CONFIGPARAM" - }, - "bytecode": { - "doc_opcode": "F832", - "tlb": "#F832", - "prefix": "F832", - "operands": [] - }, - "value_flow": { - "doc_stack": "i - c -1 or 0" - } - }, - { - "mnemonic": "CONFIGOPTPARAM", - "doc": { - "category": "app_config", - "description": "Returns the value of the global configuration parameter with integer index `i` as a _Maybe Cell_ `c^?`.\nEquivalent to `CONFIGDICT` `DICTIGETOPTREF`.", - "gas": "", - "fift": "CONFIGOPTPARAM" - }, - "bytecode": { - "doc_opcode": "F833", - "tlb": "#F833", - "prefix": "F833", - "operands": [] - }, - "value_flow": { - "doc_stack": "i - c^?" - } - }, - { - "mnemonic": "GETGLOBVAR", - "doc": { - "category": "app_global", - "description": "Returns the `k`-th global variable for `0 <= k < 255`.\nEquivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.", - "gas": "26", - "fift": "GETGLOBVAR" - }, - "bytecode": { - "doc_opcode": "F840", - "tlb": "#F840", - "prefix": "F840", - "operands": [] - }, - "value_flow": { - "doc_stack": "k - x" - } - }, - { - "mnemonic": "GETGLOB", - "doc": { - "category": "app_global", - "description": "Returns the `k`-th global variable for `1 <= k <= 31`.\nEquivalent to `c7 PUSHCTR` `[k] INDEXQ`.", - "gas": "26", - "fift": "[k] GETGLOB" - }, - "bytecode": { - "doc_opcode": "F85_k", - "tlb": "#F85_ k:(## 5) {1 <= k}", - "prefix": "F85_", - "operands_range_check": { - "length": 5, - "from": 1, - "to": 31 - }, - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 5 - } - } - ] - }, - "value_flow": { - "doc_stack": " - x" - } - }, - { - "mnemonic": "SETGLOBVAR", - "doc": { - "category": "app_global", - "description": "Assigns `x` to the `k`-th global variable for `0 <= k < 255`.\nEquivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.", - "gas": "26+|c7\u0432\u0402\u2122|", - "fift": "SETGLOBVAR" - }, - "bytecode": { - "doc_opcode": "F860", - "tlb": "#F860", - "prefix": "F860", - "operands": [] - }, - "value_flow": { - "doc_stack": "x k - " - } - }, - { - "mnemonic": "SETGLOB", - "doc": { - "category": "app_global", - "description": "Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.\nEquivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.", - "gas": "26+|c7\u0432\u0402\u2122|", - "fift": "[k] SETGLOB" - }, - "bytecode": { - "doc_opcode": "F87_k", - "tlb": "#F87_ k:(## 5) {1 <= k}", - "prefix": "F87_", - "operands_range_check": { - "length": 5, - "from": 1, - "to": 31 - }, - "operands": [ - { - "name": "k", - "loader": "uint", - "loader_args": { - "size": 5 - } - } - ] - }, - "value_flow": { - "doc_stack": "x - " - } - }, - { - "mnemonic": "HASHCU", - "doc": { - "category": "app_crypto", - "description": "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.", - "gas": "26", - "fift": "HASHCU" - }, - "bytecode": { - "doc_opcode": "F900", - "tlb": "#F900", - "prefix": "F900", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - x" - } - }, - { - "mnemonic": "HASHSU", - "doc": { - "category": "app_crypto", - "description": "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`.", - "gas": "526", - "fift": "HASHSU" - }, - "bytecode": { - "doc_opcode": "F901", - "tlb": "#F901", - "prefix": "F901", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "SHA256U", - "doc": { - "category": "app_crypto", - "description": "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`.", - "gas": "26", - "fift": "SHA256U" - }, - "bytecode": { - "doc_opcode": "F902", - "tlb": "#F902", - "prefix": "F902", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x" - } - }, - { - "mnemonic": "CHKSIGNU", - "doc": { - "category": "app_crypto", - "description": "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).\nThe 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.\nNotice 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`.", - "gas": "26", - "fift": "CHKSIGNU" - }, - "bytecode": { - "doc_opcode": "F910", - "tlb": "#F910", - "prefix": "F910", - "operands": [] - }, - "value_flow": { - "doc_stack": "h s k - ?" - } - }, - { - "mnemonic": "CHKSIGNS", - "doc": { - "category": "app_crypto", - "description": "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.", - "gas": "26", - "fift": "CHKSIGNS" - }, - "bytecode": { - "doc_opcode": "F911", - "tlb": "#F911", - "prefix": "F911", - "operands": [] - }, - "value_flow": { - "doc_stack": "d s k - ?" - } - }, - { - "mnemonic": "CDATASIZEQ", - "doc": { - "category": "app_misc", - "description": "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`.", - "gas": "", - "fift": "CDATASIZEQ" - }, - "bytecode": { - "doc_opcode": "F940", - "tlb": "#F940", - "prefix": "F940", - "operands": [] - }, - "value_flow": { - "doc_stack": "c n - x y z -1 or 0" - } - }, - { - "mnemonic": "CDATASIZE", - "doc": { - "category": "app_misc", - "description": "A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.", - "gas": "", - "fift": "CDATASIZE" - }, - "bytecode": { - "doc_opcode": "F941", - "tlb": "#F941", - "prefix": "F941", - "operands": [] - }, - "value_flow": { - "doc_stack": "c n - x y z" - } - }, - { - "mnemonic": "SDATASIZEQ", - "doc": { - "category": "app_misc", - "description": "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`.", - "gas": "", - "fift": "SDATASIZEQ" - }, - "bytecode": { - "doc_opcode": "F942", - "tlb": "#F942", - "prefix": "F942", - "operands": [] - }, - "value_flow": { - "doc_stack": "s n - x y z -1 or 0" - } - }, - { - "mnemonic": "SDATASIZE", - "doc": { - "category": "app_misc", - "description": "A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.", - "gas": "", - "fift": "SDATASIZE" - }, - "bytecode": { - "doc_opcode": "F943", - "tlb": "#F943", - "prefix": "F943", - "operands": [] - }, - "value_flow": { - "doc_stack": "s n - x y z" - } - }, - { - "mnemonic": "LDGRAMS", - "doc": { - "category": "app_currency", - "description": "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`.\nThe net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.", - "gas": "26", - "fift": "LDGRAMS\nLDVARUINT16" - }, - "bytecode": { - "doc_opcode": "FA00", - "tlb": "#FA00", - "prefix": "FA00", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "LDVARINT16", - "doc": { - "category": "app_currency", - "description": "Similar to `LDVARUINT16`, but loads a _signed_ _Integer_ `x`.\nApproximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.", - "gas": "26", - "fift": "LDVARINT16" - }, - "bytecode": { - "doc_opcode": "FA01", - "tlb": "#FA01", - "prefix": "FA01", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "STGRAMS", - "doc": { - "category": "app_currency", - "description": "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.", - "gas": "26", - "fift": "STGRAMS\nSTVARUINT16" - }, - "bytecode": { - "doc_opcode": "FA02", - "tlb": "#FA02", - "prefix": "FA02", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x - b'" - } - }, - { - "mnemonic": "STVARINT16", - "doc": { - "category": "app_currency", - "description": "Similar to `STVARUINT16`, but serializes a _signed_ _Integer_ `x` in the range `-2^119...2^119-1`.", - "gas": "26", - "fift": "STVARINT16" - }, - "bytecode": { - "doc_opcode": "FA03", - "tlb": "#FA03", - "prefix": "FA03", - "operands": [] - }, - "value_flow": { - "doc_stack": "b x - b'" - } - }, - { - "mnemonic": "LDMSGADDR", - "doc": { - "category": "app_addr", - "description": "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.", - "gas": "26", - "fift": "LDMSGADDR" - }, - "bytecode": { - "doc_opcode": "FA40", - "tlb": "#FA40", - "prefix": "FA40", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s' s''" - } - }, - { - "mnemonic": "LDMSGADDRQ", - "doc": { - "category": "app_addr", - "description": "A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.", - "gas": "26", - "fift": "LDMSGADDRQ" - }, - "bytecode": { - "doc_opcode": "FA41", - "tlb": "#FA41", - "prefix": "FA41", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - s' s'' -1 or s 0" - } - }, - { - "mnemonic": "PARSEMSGADDR", - "doc": { - "category": "app_addr", - "description": "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.", - "gas": "26", - "fift": "PARSEMSGADDR" - }, - "bytecode": { - "doc_opcode": "FA42", - "tlb": "#FA42", - "prefix": "FA42", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - t" - } - }, - { - "mnemonic": "PARSEMSGADDRQ", - "doc": { - "category": "app_addr", - "description": "A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.", - "gas": "26", - "fift": "PARSEMSGADDRQ" - }, - "bytecode": { - "doc_opcode": "FA43", - "tlb": "#FA43", - "prefix": "FA43", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - t -1 or 0" - } - }, - { - "mnemonic": "REWRITESTDADDR", - "doc": { - "category": "app_addr", - "description": "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.", - "gas": "26", - "fift": "REWRITESTDADDR" - }, - "bytecode": { - "doc_opcode": "FA44", - "tlb": "#FA44", - "prefix": "FA44", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x y" - } - }, - { - "mnemonic": "REWRITESTDADDRQ", - "doc": { - "category": "app_addr", - "description": "A quiet version of primitive `REWRITESTDADDR`.", - "gas": "26", - "fift": "REWRITESTDADDRQ" - }, - "bytecode": { - "doc_opcode": "FA45", - "tlb": "#FA45", - "prefix": "FA45", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x y -1 or 0" - } - }, - { - "mnemonic": "REWRITEVARADDR", - "doc": { - "category": "app_addr", - "description": "A variant of `REWRITESTDADDR` that returns the (rewritten) address as a _Slice_ `s`, even if it is not exactly 256 bit long (represented by a `msg_addr_var`).", - "gas": "26", - "fift": "REWRITEVARADDR" - }, - "bytecode": { - "doc_opcode": "FA46", - "tlb": "#FA46", - "prefix": "FA46", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s'" - } - }, - { - "mnemonic": "REWRITEVARADDRQ", - "doc": { - "category": "app_addr", - "description": "A quiet version of primitive `REWRITEVARADDR`.", - "gas": "26", - "fift": "REWRITEVARADDRQ" - }, - "bytecode": { - "doc_opcode": "FA47", - "tlb": "#FA47", - "prefix": "FA47", - "operands": [] - }, - "value_flow": { - "doc_stack": "s - x s' -1 or 0" - } - }, - { - "mnemonic": "SENDRAWMSG", - "doc": { - "category": "app_actions", - "description": "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`.", - "gas": "526", - "fift": "SENDRAWMSG" - }, - "bytecode": { - "doc_opcode": "FB00", - "tlb": "#FB00", - "prefix": "FB00", - "operands": [] - }, - "value_flow": { - "doc_stack": "c x - " - } - }, - { - "mnemonic": "RAWRESERVE", - "doc": { - "category": "app_actions", - "description": "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`.", - "gas": "526", - "fift": "RAWRESERVE" - }, - "bytecode": { - "doc_opcode": "FB02", - "tlb": "#FB02", - "prefix": "FB02", - "operands": [] - }, - "value_flow": { - "doc_stack": "x y - " - } - }, - { - "mnemonic": "RAWRESERVEX", - "doc": { - "category": "app_actions", - "description": "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.", - "gas": "526", - "fift": "RAWRESERVEX" - }, - "bytecode": { - "doc_opcode": "FB03", - "tlb": "#FB03", - "prefix": "FB03", - "operands": [] - }, - "value_flow": { - "doc_stack": "x D y - " - } - }, - { - "mnemonic": "SETCODE", - "doc": { - "category": "app_actions", - "description": "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.", - "gas": "526", - "fift": "SETCODE" - }, - "bytecode": { - "doc_opcode": "FB04", - "tlb": "#FB04", - "prefix": "FB04", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - }, - { - "mnemonic": "SETLIBCODE", - "doc": { - "category": "app_actions", - "description": "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.", - "gas": "526", - "fift": "SETLIBCODE" - }, - "bytecode": { - "doc_opcode": "FB06", - "tlb": "#FB06", - "prefix": "FB06", - "operands": [] - }, - "value_flow": { - "doc_stack": "c x - " - } - }, - { - "mnemonic": "CHANGELIB", - "doc": { - "category": "app_actions", - "description": "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.", - "gas": "526", - "fift": "CHANGELIB" - }, - "bytecode": { - "doc_opcode": "FB07", - "tlb": "#FB07", - "prefix": "FB07", - "operands": [] - }, - "value_flow": { - "doc_stack": "h x - " - } - }, - { - "mnemonic": "DUMPSTK", - "doc": { - "category": "debug", - "description": "Dumps the stack (at most the top 255 values) and shows the total stack depth.", - "gas": "26", - "fift": "DUMPSTK" - }, - "bytecode": { - "doc_opcode": "FE00", - "tlb": "#FE00", - "prefix": "FE00" - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "DEBUG", - "doc": { - "category": "debug", - "description": "", - "gas": "26", - "fift": "{nn} DEBUG" - }, - "bytecode": { - "doc_opcode": "FEnn", - "tlb": "#FE nn:(#<= 239)", - "prefix": "FE", - "operands_range_check": { - "length": 8, - "from": 1, - "to": 19 - }, - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "STRDUMP", - "doc": { - "category": "debug", - "description": "", - "gas": "26", - "fift": "STRDUMP" - }, - "bytecode": { - "doc_opcode": "FE14", - "tlb": "#FE14", - "prefix": "FE14" - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "DEBUG", - "doc": { - "category": "debug", - "description": "", - "gas": "26", - "fift": "{nn} DEBUG" - }, - "bytecode": { - "doc_opcode": "FEnn", - "tlb": "#FE nn:(#<= 239)", - "prefix": "FE", - "operands_range_check": { - "length": 8, - "from": 21, - "to": 31 - }, - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "DUMP", - "doc": { - "category": "debug", - "description": "Dumps `s[i]`.", - "gas": "26", - "fift": "s[i] DUMP" - }, - "bytecode": { - "doc_opcode": "FE2i", - "tlb": "#FE2 i:uint4", - "prefix": "FE2", - "operands": [ - { - "name": "i", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "DEBUG", - "doc": { - "category": "debug", - "description": "", - "gas": "26", - "fift": "{nn} DEBUG" - }, - "bytecode": { - "doc_opcode": "FEnn", - "tlb": "#FE nn:(#<= 239)", - "prefix": "FE", - "operands_range_check": { - "length": 8, - "from": 48, - "to": 239 - }, - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "DEBUGSTR", - "doc": { - "category": "debug", - "description": "`0 <= n < 16`. Length of `ssss` is `n+1` bytes.\n`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).\n`DEBUGSTR`: `ssss` is the given string.\n`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.", - "gas": "26", - "fift": "{string} DEBUGSTR\n{string} {x} DEBUGSTRI" - }, - "bytecode": { - "doc_opcode": "FEFnssss", - "tlb": "#FEF n:(## 4) ssss:((n * 8 + 8) * Bit)", - "prefix": "FEF", - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 4 - } - }, - { - "name": "s", - "loader": "subslice", - "loader_args": { - "bits_length_var": "n", - "bits_padding": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SETCP", - "doc": { - "category": "codepage", - "description": "Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.", - "gas": "26", - "fift": "[nn] SETCP" - }, - "bytecode": { - "doc_opcode": "FFnn", - "tlb": "#FF nn:(#<= 239)", - "prefix": "FF", - "operands_range_check": { - "length": 8, - "from": 0, - "to": 239 - }, - "operands": [ - { - "name": "n", - "loader": "uint", - "loader_args": { - "size": 8 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SETCP_SPECIAL", - "doc": { - "category": "codepage", - "description": "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.", - "gas": "26", - "fift": "[z-16] SETCP" - }, - "bytecode": { - "doc_opcode": "FFFz", - "tlb": "#FFF z:(## 4) {1 <= z}", - "prefix": "FFF", - "operands_range_check": { - "length": 4, - "from": 1, - "to": 15 - }, - "operands": [ - { - "name": "z", - "loader": "uint", - "loader_args": { - "size": 4 - } - } - ] - }, - "value_flow": { - "doc_stack": "-" - } - }, - { - "mnemonic": "SETCPX", - "doc": { - "category": "codepage", - "description": "Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.", - "gas": "26", - "fift": "SETCPX" - }, - "bytecode": { - "doc_opcode": "FFF0", - "tlb": "#FFF0", - "prefix": "FFF0", - "operands": [] - }, - "value_flow": { - "doc_stack": "c - " - } - } - ], - "aliases": [ - { - "mnemonic": "SWAP", - "alias_of": "XCHG_0I", - "doc_fift": "SWAP", - "doc_stack": "x y - y x", - "description": "Same as `s1 XCHG0`.", - "operands": { - "i": 1 - } - }, - { - "mnemonic": "DUP", - "alias_of": "PUSH", - "doc_fift": "DUP", - "doc_stack": "x - x x", - "description": "Same as `s0 PUSH`.", - "operands": { - "i": 0 - } - }, - { - "mnemonic": "OVER", - "alias_of": "PUSH", - "doc_fift": "OVER", - "doc_stack": "x y - x y x", - "description": "Same as `s1 PUSH`.", - "operands": { - "i": 1 - } - }, - { - "mnemonic": "DROP", - "alias_of": "POP", - "doc_fift": "DROP", - "doc_stack": "x -", - "description": "Same as `s0 POP`, discards the top-of-stack value.", - "operands": { - "i": 0 - } - }, - { - "mnemonic": "NIP", - "alias_of": "POP", - "doc_fift": "NIP", - "doc_stack": "x y - y", - "description": "Same as `s1 POP`.", - "operands": { - "i": 1 - } - }, - { - "mnemonic": "ROT2", - "alias_of": "BLKSWAP", - "doc_fift": "ROT2\n2ROT", - "doc_stack": "a b c d e f - c d e f a b", - "description": "Rotates the three topmost pairs of stack entries.", - "operands": { - "i": 1, - "j": 3 - } - }, - { - "mnemonic": "ROLL", - "alias_of": "BLKSWAP", - "doc_fift": "[i+1] ROLL", - "doc_stack": "", - "description": "Rotates the top `i+1` stack entries.\nEquivalent to `1 [i+1] BLKSWAP`.", - "operands": { - "i": 0 - } - }, - { - "mnemonic": "ROLLREV", - "alias_of": "BLKSWAP", - "doc_fift": "[i+1] -ROLL\n[i+1] ROLLREV", - "doc_stack": "", - "description": "Rotates the top `i+1` stack entries in the other direction.\nEquivalent to `[i+1] 1 BLKSWAP`.", - "operands": {} - }, - { - "mnemonic": "NIL", - "alias_of": "TUPLE", - "doc_fift": "NIL", - "doc_stack": "- t", - "description": "Pushes the only _Tuple_ `t=()` of length zero.", - "operands": { - "n": 0 - } - }, - { - "mnemonic": "SINGLE", - "alias_of": "TUPLE", - "doc_fift": "SINGLE", - "doc_stack": "x - t", - "description": "Creates a singleton `t:=(x)`, i.e., a _Tuple_ of length one.", - "operands": { - "n": 1 - } - }, - { - "mnemonic": "PAIR", - "alias_of": "TUPLE", - "doc_fift": "PAIR\nCONS", - "doc_stack": "x y - t", - "description": "Creates pair `t:=(x,y)`.", - "operands": { - "n": 2 - } - }, - { - "mnemonic": "TRIPLE", - "alias_of": "TUPLE", - "doc_fift": "TRIPLE", - "doc_stack": "x y z - t", - "description": "Creates triple `t:=(x,y,z)`.", - "operands": { - "n": 3 - } - }, - { - "mnemonic": "FIRST", - "alias_of": "INDEX", - "doc_fift": "FIRST\nCAR", - "doc_stack": "t - x", - "description": "Returns the first element of a _Tuple_.", - "operands": { - "k": 0 - } - }, - { - "mnemonic": "SECOND", - "alias_of": "INDEX", - "doc_fift": "SECOND\nCDR", - "doc_stack": "t - y", - "description": "Returns the second element of a _Tuple_.", - "operands": { - "k": 1 - } - }, - { - "mnemonic": "THIRD", - "alias_of": "INDEX", - "doc_fift": "THIRD", - "doc_stack": "t - z", - "description": "Returns the third element of a _Tuple_.", - "operands": { - "k": 2 - } - }, - { - "mnemonic": "UNSINGLE", - "alias_of": "UNTUPLE", - "doc_fift": "UNSINGLE", - "doc_stack": "t - x", - "description": "Unpacks a singleton `t=(x)`.", - "operands": { - "n": 1 - } - }, - { - "mnemonic": "UNPAIR", - "alias_of": "UNTUPLE", - "doc_fift": "UNPAIR\nUNCONS", - "doc_stack": "t - x y", - "description": "Unpacks a pair `t=(x,y)`.", - "operands": { - "n": 2 - } - }, - { - "mnemonic": "UNTRIPLE", - "alias_of": "UNTUPLE", - "doc_fift": "UNTRIPLE", - "doc_stack": "t - x y z", - "description": "Unpacks a triple `t=(x,y,z)`.", - "operands": { - "n": 3 - } - }, - { - "mnemonic": "CHKTUPLE", - "alias_of": "UNPACKFIRST", - "doc_fift": "CHKTUPLE", - "doc_stack": "t -", - "description": "Checks whether `t` is a _Tuple_. If not, throws a type check exception.", - "operands": { - "k": 0 - } - }, - { - "mnemonic": "SETFIRST", - "alias_of": "SETINDEX", - "doc_fift": "SETFIRST", - "doc_stack": "t x - t'", - "description": "Sets the first component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 0 - } - }, - { - "mnemonic": "SETSECOND", - "alias_of": "SETINDEX", - "doc_fift": "SETSECOND", - "doc_stack": "t x - t'", - "description": "Sets the second component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 1 - } - }, - { - "mnemonic": "SETTHIRD", - "alias_of": "SETINDEX", - "doc_fift": "SETTHIRD", - "doc_stack": "t x - t'", - "description": "Sets the third component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 2 - } - }, - { - "mnemonic": "FIRSTQ", - "alias_of": "INDEXQ", - "doc_fift": "FIRSTQ\nCARQ", - "doc_stack": "t - x", - "description": "Returns the first element of a _Tuple_.", - "operands": { - "k": 0 - } - }, - { - "mnemonic": "SECONDQ", - "alias_of": "INDEXQ", - "doc_fift": "SECONDQ\nCDRQ", - "doc_stack": "t - y", - "description": "Returns the second element of a _Tuple_.", - "operands": { - "k": 1 - } - }, - { - "mnemonic": "THIRDQ", - "alias_of": "INDEXQ", - "doc_fift": "THIRDQ", - "doc_stack": "t - z", - "description": "Returns the third element of a _Tuple_.", - "operands": { - "k": 2 - } - }, - { - "mnemonic": "SETFIRSTQ", - "alias_of": "SETINDEXQ", - "doc_fift": "SETFIRSTQ", - "doc_stack": "t x - t'", - "description": "Sets the first component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 0 - } - }, - { - "mnemonic": "SETSECONDQ", - "alias_of": "SETINDEXQ", - "doc_fift": "SETSECONDQ", - "doc_stack": "t x - t'", - "description": "Sets the second component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 1 - } - }, - { - "mnemonic": "SETTHIRDQ", - "alias_of": "SETINDEXQ", - "doc_fift": "SETTHIRDQ", - "doc_stack": "t x - t'", - "description": "Sets the third component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", - "operands": { - "k": 2 - } - }, - { - "mnemonic": "CADR", - "alias_of": "INDEX2", - "doc_fift": "CADR", - "doc_stack": "t - x", - "description": "Recovers `x=(t_2)_1`.", - "operands": { - "i": 1, - "j": 0 - } - }, - { - "mnemonic": "CDDR", - "alias_of": "INDEX2", - "doc_fift": "CDDR", - "doc_stack": "t - x", - "description": "Recovers `x=(t_2)_2`.", - "operands": { - "i": 1, - "j": 1 - } - }, - { - "mnemonic": "CADDR", - "alias_of": "INDEX3", - "doc_fift": "CADDR", - "doc_stack": "t - x", - "description": "Recovers `x=t_2_2_1`.", - "operands": { - "i": 1, - "j": 1, - "k": 0 - } - }, - { - "mnemonic": "CDDDR", - "alias_of": "INDEX3", - "doc_fift": "CDDDR", - "doc_stack": "t - x", - "description": "Recovers `x=t_2_2_2`.", - "operands": { - "i": 1, - "j": 1, - "k": 1 - } - }, - { - "mnemonic": "ZERO", - "alias_of": "PUSHINT_4", - "doc_fift": "ZERO\nFALSE", - "doc_stack": "- 0", - "description": "", - "operands": { - "i": 0 - } - }, - { - "mnemonic": "ONE", - "alias_of": "PUSHINT_4", - "doc_fift": "ONE", - "doc_stack": "- 1", - "description": "", - "operands": { - "i": 1 - } - }, - { - "mnemonic": "TWO", - "alias_of": "PUSHINT_4", - "doc_fift": "TWO", - "doc_stack": "- 2", - "description": "", - "operands": { - "i": 2 - } - }, - { - "mnemonic": "TEN", - "alias_of": "PUSHINT_4", - "doc_fift": "TEN", - "doc_stack": "- 10", - "description": "", - "operands": { - "i": 10 - } - }, - { - "mnemonic": "TRUE", - "alias_of": "PUSHINT_4", - "doc_fift": "TRUE", - "doc_stack": "- -1", - "description": "", - "operands": { - "i": 15 - } - }, - { - "mnemonic": "CHKBOOL", - "alias_of": "FITS", - "doc_fift": "CHKBOOL", - "doc_stack": "x - x", - "description": "Checks whether `x` is a \u0432\u0402\u045aboolean value'' (i.e., either 0 or -1).", - "operands": { - "c": 0 - } - }, - { - "mnemonic": "CHKBIT", - "alias_of": "UFITS", - "doc_fift": "CHKBIT", - "doc_stack": "x - x", - "description": "Checks whether `x` is a binary digit (i.e., zero or one).", - "operands": { - "c": 0 - } - }, - { - "mnemonic": "ISZERO", - "alias_of": "EQINT", - "doc_fift": "ISZERO", - "doc_stack": "x - x=0", - "description": "Checks whether an integer is zero. Corresponds to Forth's `0=`.", - "operands": { - "y": 0 - } - }, - { - "mnemonic": "ISNEG", - "alias_of": "LESSINT", - "doc_fift": "ISNEG", - "doc_stack": "x - x<0", - "description": "Checks whether an integer is negative. Corresponds to Forth's `0<`.", - "operands": { - "y": 0 - } - }, - { - "mnemonic": "ISNPOS", - "alias_of": "LESSINT", - "doc_fift": "ISNPOS", - "doc_stack": "x - x<=0", - "description": "Checks whether an integer is non-positive.", - "operands": { - "y": 1 - } - }, - { - "mnemonic": "ISPOS", - "alias_of": "GTINT", - "doc_fift": "ISPOS", - "doc_stack": "x - x>0", - "description": "Checks whether an integer is positive. Corresponds to Forth's `0>`.", - "operands": { - "y": 0 - } - }, - { - "mnemonic": "ISNNEG", - "alias_of": "GTINT", - "doc_fift": "ISNNEG", - "doc_stack": "x - x >=0", - "description": "Checks whether an integer is non-negative.", - "operands": { - "y": -1 - } - }, - { - "mnemonic": "STZERO", - "alias_of": "STSLICECONST", - "doc_fift": "STZERO", - "doc_stack": "b - b'", - "description": "Stores one binary zero.", - "operands": { - "x": 0, - "y": 0, - "sss": "0" - } - }, - { - "mnemonic": "STONE", - "alias_of": "STSLICECONST", - "doc_fift": "STONE", - "doc_stack": "b - b'", - "description": "Stores one binary one.", - "operands": { - "x": 0, - "y": 0, - "sss": "1" - } - }, - { - "mnemonic": "PLDREF", - "alias_of": "PLDREFIDX", - "doc_fift": "PLDREF", - "doc_stack": "s - c", - "description": "Preloads the first cell reference of a _Slice_.", - "operands": { - "n": 0 - } - }, - { - "mnemonic": "SETNUMARGS", - "alias_of": "SETCONTARGS_N", - "doc_fift": "[n] SETNUMARGS", - "doc_stack": "c - c'", - "description": "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.", - "operands": { - "r": 0 - } - }, - { - "mnemonic": "SETCONTARGS", - "alias_of": "SETCONTARGS_N", - "doc_fift": "[r] -1 SETCONTARGS", - "doc_stack": "x_1 x_2...x_r c - c'", - "description": "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.", - "operands": { - "n": -1 - } - }, - { - "mnemonic": "BLESSNUMARGS", - "alias_of": "BLESSARGS", - "doc_fift": "[n] BLESSNUMARGS", - "doc_stack": "s - c", - "description": "Also transforms a _Slice_ `s` into a _Continuation_ `c`, but sets `c.nargs` to `0 <= n <= 14`.", - "operands": { - "r": 0 - } - }, - { - "mnemonic": "PUSHROOT", - "alias_of": "PUSHCTR", - "doc_fift": "c4 PUSHCTR\nc4 PUSH", - "doc_stack": "- x", - "description": "Pushes the \u0432\u0402\u045aglobal data root'' cell reference, thus enabling access to persistent smart-contract data.", - "operands": { - "i": 4 - } - }, - { - "mnemonic": "POPROOT", - "alias_of": "POPCTR", - "doc_fift": "c4 POPCTR\nc4 POP", - "doc_stack": "x -", - "description": "Sets the \u0432\u0402\u045aglobal data root'' cell reference, thus allowing modification of persistent smart-contract data.", - "operands": { - "i": 4 - } - }, - { - "mnemonic": "NEWDICT", - "alias_of": "NULL", - "doc_fift": "NEWDICT", - "doc_stack": " - D", - "description": "Returns a new empty dictionary.\nIt is an alternative mnemonics for `PUSHNULL`.", - "operands": {} - }, - { - "mnemonic": "DICTEMPTY", - "alias_of": "ISNULL", - "doc_fift": "DICTEMPTY", - "doc_stack": "D - ?", - "description": "Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.\nIt is an alternative mnemonics for `ISNULL`.", - "operands": {} - }, - { - "mnemonic": "STDICTS", - "alias_of": "STSLICE", - "doc_fift": "STDICTS\n", - "doc_stack": "s b - b'", - "description": "Stores a _Slice_-represented dictionary `s` into _Builder_ `b`.\nIt is actually a synonym for `STSLICE`.", - "operands": {} - }, - { - "mnemonic": "NOW", - "alias_of": "GETPARAM", - "doc_fift": "NOW", - "doc_stack": " - x", - "description": "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.\nEquivalent to `3 GETPARAM`.", - "operands": { - "i": 3 - } - }, - { - "mnemonic": "BLOCKLT", - "alias_of": "GETPARAM", - "doc_fift": "BLOCKLT", - "doc_stack": " - x", - "description": "Returns the starting logical time of the current block.\nEquivalent to `4 GETPARAM`.", - "operands": { - "i": 4 - } - }, - { - "mnemonic": "LTIME", - "alias_of": "GETPARAM", - "doc_fift": "LTIME", - "doc_stack": " - x", - "description": "Returns the logical time of the current transaction.\nEquivalent to `5 GETPARAM`.", - "operands": { - "i": 5 - } - }, - { - "mnemonic": "RANDSEED", - "alias_of": "GETPARAM", - "doc_fift": "RANDSEED", - "doc_stack": " - x", - "description": "Returns the current random seed as an unsigned 256-bit _Integer_.\nEquivalent to `6 GETPARAM`.", - "operands": { - "i": 6 - } - }, - { - "mnemonic": "BALANCE", - "alias_of": "GETPARAM", - "doc_fift": "BALANCE", - "doc_stack": " - t", - "description": "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 \u0432\u0402\u045aextra currencies'').\nEquivalent to `7 GETPARAM`.\nNote that `RAW` primitives such as `SENDRAWMSG` do not update this field.", - "operands": { - "i": 7 - } - }, - { - "mnemonic": "MYADDR", - "alias_of": "GETPARAM", - "doc_fift": "MYADDR", - "doc_stack": " - s", - "description": "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`.\nEquivalent to `8 GETPARAM`.", - "operands": { - "i": 8 - } - }, - { - "mnemonic": "CONFIGROOT", - "alias_of": "GETPARAM", - "doc_fift": "CONFIGROOT", - "doc_stack": " - D", - "description": "Returns the _Maybe Cell_ `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `.", - "operands": { - "i": 9 - } - }, - { - "mnemonic": "SETCP0", - "alias_of": "SETCP", - "doc_fift": "SETCP0", - "doc_stack": "-", - "description": "Selects TVM (test) codepage zero as described in this document.", - "operands": { - "n": 0 - } - } - ] +{ + "$schema": "./schema.json", + "instructions": [ + { + "mnemonic": "NOP", + "doc": { + "category": "stack_basic", + "description": "Does nothing.", + "gas": "18", + "fift": "NOP" + }, + "bytecode": { + "doc_opcode": "00", + "tlb": "#00", + "prefix": "00", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "XCHG_0I", + "doc": { + "category": "stack_basic", + "description": "Interchanges `s0` with `s[i]`, `1 <= i <= 15`.", + "gas": "18", + "fift": "s[i] XCHG0" + }, + "bytecode": { + "doc_opcode": "0i", + "tlb": "#0 i:(## 4) {1 <= i}", + "prefix": "0", + "operands_range_check": { + "length": 4, + "from": 1, + "to": 15 + }, + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG_IJ", + "doc": { + "category": "stack_basic", + "description": "Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.", + "gas": "26", + "fift": "s[i] s[j] XCHG" + }, + "bytecode": { + "doc_opcode": "10ij", + "tlb": "#10 i:(## 4) j:(## 4) {1 <= i} {i + 1 <= j}", + "prefix": "10", + "operands_range_check": { + "length": 4, + "from": 1, + "to": 15 + }, + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG_0I_LONG", + "doc": { + "category": "stack_basic", + "description": "Interchanges `s0` with `s[ii]`, `0 <= ii <= 255`.", + "gas": "26", + "fift": "s0 [ii] s() XCHG" + }, + "bytecode": { + "doc_opcode": "11ii", + "tlb": "#11 ii:uint8", + "prefix": "11", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG_1I", + "doc": { + "category": "stack_basic", + "description": "Interchanges `s1` with `s[i]`, `2 <= i <= 15`.", + "gas": "18", + "fift": "s1 s[i] XCHG" + }, + "bytecode": { + "doc_opcode": "1i", + "tlb": "#1 i:(## 4) {2 <= i}", + "prefix": "1", + "operands_range_check": { + "length": 4, + "from": 2, + "to": 15 + }, + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUSH", + "doc": { + "category": "stack_basic", + "description": "Pushes a copy of the old `s[i]` into the stack.", + "gas": "18", + "fift": "s[i] PUSH" + }, + "bytecode": { + "doc_opcode": "2i", + "tlb": "#2 i:uint4", + "prefix": "2", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "POP", + "doc": { + "category": "stack_basic", + "description": "Pops the old `s0` value into the old `s[i]`.", + "gas": "18", + "fift": "s[i] POP" + }, + "bytecode": { + "doc_opcode": "3i", + "tlb": "#3 i:uint4", + "prefix": "3", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG3", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s2 s[i] XCHG` `s1 s[j] XCHG` `s[k] XCHG0`.", + "gas": "26", + "fift": "s[i] s[j] s[k] XCHG3" + }, + "bytecode": { + "doc_opcode": "4ijk", + "tlb": "#4 i:uint4 j:uint4 k:uint4", + "prefix": "4", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s1 s[i] XCHG` `s[j] XCHG0`.", + "gas": "26", + "fift": "s[i] s[j] XCHG2" + }, + "bytecode": { + "doc_opcode": "50ij", + "tlb": "#50 i:uint4 j:uint4", + "prefix": "50", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCPU", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] XCHG0` `s[j] PUSH`.", + "gas": "26", + "fift": "s[i] s[j] XCPU" + }, + "bytecode": { + "doc_opcode": "51ij", + "tlb": "#51 i:uint4 j:uint4", + "prefix": "51", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUXC", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] PUSH` `SWAP` `s[j] XCHG0`.", + "gas": "26", + "fift": "s[i] s[j-1] PUXC" + }, + "bytecode": { + "doc_opcode": "52ij", + "tlb": "#52 i:uint4 j:uint4", + "prefix": "52", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUSH2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] PUSH` `s[j+1] PUSH`.", + "gas": "26", + "fift": "s[i] s[j] PUSH2" + }, + "bytecode": { + "doc_opcode": "53ij", + "tlb": "#53 i:uint4 j:uint4", + "prefix": "53", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCHG3_ALT", + "doc": { + "category": "stack_complex", + "description": "Long form of `XCHG3`.", + "gas": "34", + "fift": "s[i] s[j] s[k] XCHG3_l" + }, + "bytecode": { + "doc_opcode": "540ijk", + "tlb": "#540 i:uint4 j:uint4 k:uint4", + "prefix": "540", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XC2PU", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] s[j] XCHG2` `s[k] PUSH`.", + "gas": "34", + "fift": "s[i] s[j] s[k] XC2PU" + }, + "bytecode": { + "doc_opcode": "541ijk", + "tlb": "#541 i:uint4 j:uint4 k:uint4", + "prefix": "541", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCPUXC", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s1 s[i] XCHG` `s[j] s[k-1] PUXC`.", + "gas": "34", + "fift": "s[i] s[j] s[k-1] XCPUXC" + }, + "bytecode": { + "doc_opcode": "542ijk", + "tlb": "#542 i:uint4 j:uint4 k:uint4", + "prefix": "542", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "XCPU2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] XCHG0` `s[j] s[k] PUSH2`.", + "gas": "34", + "fift": "s[i] s[j] s[k] XCPU2" + }, + "bytecode": { + "doc_opcode": "543ijk", + "tlb": "#543 i:uint4 j:uint4 k:uint4", + "prefix": "543", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUXC2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] PUSH` `s2 XCHG0` `s[j] s[k] XCHG2`.", + "gas": "34", + "fift": "s[i] s[j-1] s[k-1] PUXC2" + }, + "bytecode": { + "doc_opcode": "544ijk", + "tlb": "#544 i:uint4 j:uint4 k:uint4", + "prefix": "544", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUXCPU", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] s[j-1] PUXC` `s[k] PUSH`.", + "gas": "34", + "fift": "s[i] s[j-1] s[k-1] PUXCPU" + }, + "bytecode": { + "doc_opcode": "545ijk", + "tlb": "#545 i:uint4 j:uint4 k:uint4", + "prefix": "545", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PU2XC", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] PUSH` `SWAP` `s[j] s[k-1] PUXC`.", + "gas": "34", + "fift": "s[i] s[j-1] s[k-2] PU2XC" + }, + "bytecode": { + "doc_opcode": "546ijk", + "tlb": "#546 i:uint4 j:uint4 k:uint4", + "prefix": "546", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUSH3", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s[i] PUSH` `s[j+1] s[k+1] PUSH2`.", + "gas": "34", + "fift": "s[i] s[j] s[k] PUSH3" + }, + "bytecode": { + "doc_opcode": "547ijk", + "tlb": "#547 i:uint4 j:uint4 k:uint4", + "prefix": "547", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "BLKSWAP", + "doc": { + "category": "stack_complex", + "description": "Permutes two blocks `s[j+i+1] \u0432\u0402\u00a6 s[j+1]` and `s[j] \u0432\u0402\u00a6 s0`.\n`0 <= i,j <= 15`\nEquivalent to `[i+1] [j+1] REVERSE` `[j+1] 0 REVERSE` `[i+j+2] 0 REVERSE`.", + "gas": "26", + "fift": "[i+1] [j+1] BLKSWAP" + }, + "bytecode": { + "doc_opcode": "55ij", + "tlb": "#55 i:uint4 j:uint4", + "prefix": "55", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PUSH_LONG", + "doc": { + "category": "stack_complex", + "description": "Pushes a copy of the old `s[ii]` into the stack.\n`0 <= ii <= 255`", + "gas": "26", + "fift": "[ii] s() PUSH" + }, + "bytecode": { + "doc_opcode": "56ii", + "tlb": "#56 ii:uint8", + "prefix": "56", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "POP_LONG", + "doc": { + "category": "stack_complex", + "description": "Pops the old `s0` value into the old `s[ii]`.\n`0 <= ii <= 255`", + "gas": "26", + "fift": "[ii] s() POP" + }, + "bytecode": { + "doc_opcode": "57ii", + "tlb": "#57 ii:uint8", + "prefix": "57", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "ROT", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `1 2 BLKSWAP` or to `s2 s1 XCHG2`.", + "gas": "18", + "fift": "ROT" + }, + "bytecode": { + "doc_opcode": "58", + "tlb": "#58", + "prefix": "58", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b c - b c a" + } + }, + { + "mnemonic": "ROTREV", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `2 1 BLKSWAP` or to `s2 s2 XCHG2`.", + "gas": "18", + "fift": "ROTREV\n-ROT" + }, + "bytecode": { + "doc_opcode": "59", + "tlb": "#59", + "prefix": "59", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b c - c a b" + } + }, + { + "mnemonic": "SWAP2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `2 2 BLKSWAP` or to `s3 s2 XCHG2`.", + "gas": "18", + "fift": "SWAP2\n2SWAP" + }, + "bytecode": { + "doc_opcode": "5A", + "tlb": "#5A", + "prefix": "5A", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b c d - c d a b" + } + }, + { + "mnemonic": "DROP2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `DROP` `DROP`.", + "gas": "18", + "fift": "DROP2\n2DROP" + }, + "bytecode": { + "doc_opcode": "5B", + "tlb": "#5B", + "prefix": "5B", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b - " + } + }, + { + "mnemonic": "DUP2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s1 s0 PUSH2`.", + "gas": "18", + "fift": "DUP2\n2DUP" + }, + "bytecode": { + "doc_opcode": "5C", + "tlb": "#5C", + "prefix": "5C", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b - a b a b" + } + }, + { + "mnemonic": "OVER2", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `s3 s2 PUSH2`.", + "gas": "18", + "fift": "OVER2\n2OVER" + }, + "bytecode": { + "doc_opcode": "5D", + "tlb": "#5D", + "prefix": "5D", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b c d - a b c d a b" + } + }, + { + "mnemonic": "REVERSE", + "doc": { + "category": "stack_complex", + "description": "Reverses the order of `s[j+i+1] \u0432\u0402\u00a6 s[j]`.", + "gas": "26", + "fift": "[i+2] [j] REVERSE" + }, + "bytecode": { + "doc_opcode": "5Eij", + "tlb": "#5E i:uint4 j:uint4", + "prefix": "5E", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "BLKDROP", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `DROP` performed `i` times.", + "gas": "26", + "fift": "[i] BLKDROP" + }, + "bytecode": { + "doc_opcode": "5F0i", + "tlb": "#5F0 i:uint4", + "prefix": "5F0", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "BLKPUSH", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `PUSH s(j)` performed `i` times.\n`1 <= i <= 15`, `0 <= j <= 15`.", + "gas": "26", + "fift": "[i] [j] BLKPUSH" + }, + "bytecode": { + "doc_opcode": "5Fij", + "tlb": "#5F i:(## 4) j:uint4 {1 <= i}", + "prefix": "5F", + "operands_range_check": { + "length": 4, + "from": 1, + "to": 15 + }, + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "PICK", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then performs `s[i] PUSH`.", + "gas": "18", + "fift": "PICK\nPUSHX" + }, + "bytecode": { + "doc_opcode": "60", + "tlb": "#60", + "prefix": "60", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "ROLLX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then performs `1 [i] BLKSWAP`.", + "gas": "18", + "fift": "ROLLX" + }, + "bytecode": { + "doc_opcode": "61", + "tlb": "#61", + "prefix": "61", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "-ROLLX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then performs `[i] 1 BLKSWAP`.", + "gas": "18", + "fift": "-ROLLX\nROLLREVX" + }, + "bytecode": { + "doc_opcode": "62", + "tlb": "#62", + "prefix": "62", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "BLKSWX", + "doc": { + "category": "stack_complex", + "description": "Pops integers `i`,`j` from the stack, then performs `[i] [j] BLKSWAP`.", + "gas": "18", + "fift": "BLKSWX" + }, + "bytecode": { + "doc_opcode": "63", + "tlb": "#63", + "prefix": "63", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "REVX", + "doc": { + "category": "stack_complex", + "description": "Pops integers `i`,`j` from the stack, then performs `[i] [j] REVERSE`.", + "gas": "18", + "fift": "REVX" + }, + "bytecode": { + "doc_opcode": "64", + "tlb": "#64", + "prefix": "64", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "DROPX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then performs `[i] BLKDROP`.", + "gas": "18", + "fift": "DROPX" + }, + "bytecode": { + "doc_opcode": "65", + "tlb": "#65", + "prefix": "65", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "TUCK", + "doc": { + "category": "stack_complex", + "description": "Equivalent to `SWAP` `OVER` or to `s1 s1 XCPU`.", + "gas": "18", + "fift": "TUCK" + }, + "bytecode": { + "doc_opcode": "66", + "tlb": "#66", + "prefix": "66", + "operands": [] + }, + "value_flow": { + "doc_stack": "a b - b a b" + } + }, + { + "mnemonic": "XCHGX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then performs `s[i] XCHG`.", + "gas": "18", + "fift": "XCHGX" + }, + "bytecode": { + "doc_opcode": "67", + "tlb": "#67", + "prefix": "67", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "DEPTH", + "doc": { + "category": "stack_complex", + "description": "Pushes the current depth of the stack.", + "gas": "18", + "fift": "DEPTH" + }, + "bytecode": { + "doc_opcode": "68", + "tlb": "#68", + "prefix": "68", + "operands": [] + }, + "value_flow": { + "doc_stack": "- depth", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "depth", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CHKDEPTH", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then checks whether there are at least `i` elements, generating a stack underflow exception otherwise.", + "gas": "18/58", + "fift": "CHKDEPTH" + }, + "bytecode": { + "doc_opcode": "69", + "tlb": "#69", + "prefix": "69", + "operands": [] + }, + "value_flow": { + "doc_stack": "i -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "ONLYTOPX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then removes all but the top `i` elements.", + "gas": "18", + "fift": "ONLYTOPX" + }, + "bytecode": { + "doc_opcode": "6A", + "tlb": "#6A", + "prefix": "6A", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "ONLYX", + "doc": { + "category": "stack_complex", + "description": "Pops integer `i` from the stack, then leaves only the bottom `i` elements. Approximately equivalent to `DEPTH` `SWAP` `SUB` `DROPX`.", + "gas": "18", + "fift": "ONLYX" + }, + "bytecode": { + "doc_opcode": "6B", + "tlb": "#6B", + "prefix": "6B", + "operands": [] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "BLKDROP2", + "doc": { + "category": "stack_complex", + "description": "Drops `i` stack elements under the top `j` elements.\n`1 <= i <= 15`, `0 <= j <= 15`\nEquivalent to `[i+j] 0 REVERSE` `[i] BLKDROP` `[j] 0 REVERSE`.", + "gas": "26", + "fift": "[i] [j] BLKDROP2" + }, + "bytecode": { + "doc_opcode": "6Cij", + "tlb": "#6C i:(## 4) j:uint4 {1 <= i}", + "prefix": "6C", + "operands_range_check": { + "length": 4, + "from": 1, + "to": 15 + }, + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "" + } + }, + { + "mnemonic": "NULL", + "doc": { + "category": "tuple", + "description": "Pushes the only value of type _Null_.", + "gas": "18", + "fift": "NULL\nPUSHNULL" + }, + "bytecode": { + "doc_opcode": "6D", + "tlb": "#6D", + "prefix": "6D", + "operands": [] + }, + "value_flow": { + "doc_stack": " - null", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + } + }, + { + "mnemonic": "ISNULL", + "doc": { + "category": "tuple", + "description": "Checks whether `x` is a _Null_, and returns `-1` or `0` accordingly.", + "gas": "18", + "fift": "ISNULL" + }, + "bytecode": { + "doc_opcode": "6E", + "tlb": "#6E", + "prefix": "6E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "TUPLE", + "doc": { + "category": "tuple", + "description": "Creates a new _Tuple_ `t=(x_1, \u0432\u0402\u00a6 ,x_n)` containing `n` values `x_1`,..., `x_n`.\n`0 <= n <= 15`", + "gas": "26+n", + "fift": "[n] TUPLE" + }, + "bytecode": { + "doc_opcode": "6F0n", + "tlb": "#6F0 n:uint4", + "prefix": "6F0", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x_1 ... x_n - t", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "n" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "INDEX", + "doc": { + "category": "tuple", + "description": "Returns the `k`-th element of a _Tuple_ `t`.\n`0 <= k <= 15`.", + "gas": "26", + "fift": "[k] INDEX" + }, + "bytecode": { + "doc_opcode": "6F1k", + "tlb": "#6F1 k:uint4", + "prefix": "6F1", + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "t - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "UNTUPLE", + "doc": { + "category": "tuple", + "description": "Unpacks a _Tuple_ `t=(x_1,...,x_n)` of length equal to `0 <= n <= 15`.\nIf `t` is not a _Tuple_, or if `|t| != n`, a type check exception is thrown.", + "gas": "26+n", + "fift": "[n] UNTUPLE" + }, + "bytecode": { + "doc_opcode": "6F2n", + "tlb": "#6F2 n:uint4", + "prefix": "6F2", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "t - x_1 ... x_n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "n" + } + ] + } + } + }, + { + "mnemonic": "UNPACKFIRST", + "doc": { + "category": "tuple", + "description": "Unpacks first `0 <= k <= 15` elements of a _Tuple_ `t`.\nIf `|t|= |t|`, throws a range check exception.", + "gas": "26+|t|", + "fift": "[k] SETINDEX" + }, + "bytecode": { + "doc_opcode": "6F5k", + "tlb": "#6F5 k:uint4", + "prefix": "6F5", + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "t x - t'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "INDEXQ", + "doc": { + "category": "tuple", + "description": "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`.", + "gas": "26", + "fift": "[k] INDEXQ" + }, + "bytecode": { + "doc_opcode": "6F6k", + "tlb": "#6F6 k:uint4", + "prefix": "6F6", + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "t - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple", "Null"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "SETINDEXQ", + "doc": { + "category": "tuple", + "description": "Sets the `k`-th component of _Tuple_ `t` to `x`, where `0 <= k < 16`, and returns the resulting _Tuple_ `t'`.\nIf `|t| <= k`, first extends the original _Tuple_ to length `n\u0432\u0402\u2122=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).", + "gas": "26+|t\u0432\u0402\u2122|", + "fift": "[k] SETINDEXQ" + }, + "bytecode": { + "doc_opcode": "6F7k", + "tlb": "#6F7 k:uint4", + "prefix": "6F7", + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "t x - t'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple", "Null"] + }, + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple", "Null"] + } + ] + } + } + }, + { + "mnemonic": "TUPLEVAR", + "doc": { + "category": "tuple", + "description": "Creates a new _Tuple_ `t` of length `n` similarly to `TUPLE`, but with `0 <= n <= 255` taken from the stack.", + "gas": "26+n", + "fift": "TUPLEVAR" + }, + "bytecode": { + "doc_opcode": "6F80", + "tlb": "#6F80", + "prefix": "6F80", + "operands": [] + }, + "value_flow": { + "doc_stack": "x_1 ... x_n n - t", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "n" + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "INDEXVAR", + "doc": { + "category": "tuple", + "description": "Similar to `k INDEX`, but with `0 <= k <= 254` taken from the stack.", + "gas": "26", + "fift": "INDEXVAR" + }, + "bytecode": { + "doc_opcode": "6F81", + "tlb": "#6F81", + "prefix": "6F81", + "operands": [] + }, + "value_flow": { + "doc_stack": "t k - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "UNTUPLEVAR", + "doc": { + "category": "tuple", + "description": "Similar to `n UNTUPLE`, but with `0 <= n <= 255` taken from the stack.", + "gas": "26+n", + "fift": "UNTUPLEVAR" + }, + "bytecode": { + "doc_opcode": "6F82", + "tlb": "#6F82", + "prefix": "6F82", + "operands": [] + }, + "value_flow": { + "doc_stack": "t n - x_1 ... x_n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "n" + } + ] + } + } + }, + { + "mnemonic": "UNPACKFIRSTVAR", + "doc": { + "category": "tuple", + "description": "Similar to `n UNPACKFIRST`, but with `0 <= n <= 255` taken from the stack.", + "gas": "26+n", + "fift": "UNPACKFIRSTVAR" + }, + "bytecode": { + "doc_opcode": "6F83", + "tlb": "#6F83", + "prefix": "6F83", + "operands": [] + }, + "value_flow": { + "doc_stack": "t n - x_1 ... x_n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "n" + } + ] + } + } + }, + { + "mnemonic": "EXPLODEVAR", + "doc": { + "category": "tuple", + "description": "Similar to `n EXPLODE`, but with `0 <= n <= 255` taken from the stack.", + "gas": "26+m", + "fift": "EXPLODEVAR" + }, + "bytecode": { + "doc_opcode": "6F84", + "tlb": "#6F84", + "prefix": "6F84", + "operands": [] + }, + "value_flow": { + "doc_stack": "t n - x_1 ... x_m m", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "m" + }, + { + "type": "simple", + "name": "m", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SETINDEXVAR", + "doc": { + "category": "tuple", + "description": "Similar to `k SETINDEX`, but with `0 <= k <= 254` taken from the stack.", + "gas": "26+|t\u0432\u0402\u2122|", + "fift": "SETINDEXVAR" + }, + "bytecode": { + "doc_opcode": "6F85", + "tlb": "#6F85", + "prefix": "6F85", + "operands": [] + }, + "value_flow": { + "doc_stack": "t x k - t'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "INDEXVARQ", + "doc": { + "category": "tuple", + "description": "Similar to `n INDEXQ`, but with `0 <= k <= 254` taken from the stack.", + "gas": "26", + "fift": "INDEXVARQ" + }, + "bytecode": { + "doc_opcode": "6F86", + "tlb": "#6F86", + "prefix": "6F86", + "operands": [] + }, + "value_flow": { + "doc_stack": "t k - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple", "Null"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "SETINDEXVARQ", + "doc": { + "category": "tuple", + "description": "Similar to `k SETINDEXQ`, but with `0 <= k <= 254` taken from the stack.", + "gas": "26+|t\u0432\u0402\u2122|", + "fift": "SETINDEXVARQ" + }, + "bytecode": { + "doc_opcode": "6F87", + "tlb": "#6F87", + "prefix": "6F87", + "operands": [] + }, + "value_flow": { + "doc_stack": "t x k - t'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple", "Null"] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple", "Null"] + } + ] + } + } + }, + { + "mnemonic": "TLEN", + "doc": { + "category": "tuple", + "description": "Returns the length of a _Tuple_.", + "gas": "26", + "fift": "TLEN" + }, + "bytecode": { + "doc_opcode": "6F88", + "tlb": "#6F88", + "prefix": "6F88", + "operands": [] + }, + "value_flow": { + "doc_stack": "t - n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QTLEN", + "doc": { + "category": "tuple", + "description": "Similar to `TLEN`, but returns `-1` if `t` is not a _Tuple_.", + "gas": "26", + "fift": "QTLEN" + }, + "bytecode": { + "doc_opcode": "6F89", + "tlb": "#6F89", + "prefix": "6F89", + "operands": [] + }, + "value_flow": { + "doc_stack": "t - n or -1", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "ISTUPLE", + "doc": { + "category": "tuple", + "description": "Returns `-1` or `0` depending on whether `t` is a _Tuple_.", + "gas": "26", + "fift": "ISTUPLE" + }, + "bytecode": { + "doc_opcode": "6F8A", + "tlb": "#6F8A", + "prefix": "6F8A", + "operands": [] + }, + "value_flow": { + "doc_stack": "t - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LAST", + "doc": { + "category": "tuple", + "description": "Returns the last element of a non-empty _Tuple_ `t`.", + "gas": "26", + "fift": "LAST" + }, + "bytecode": { + "doc_opcode": "6F8B", + "tlb": "#6F8B", + "prefix": "6F8B", + "operands": [] + }, + "value_flow": { + "doc_stack": "t - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "TPUSH", + "doc": { + "category": "tuple", + "description": "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.", + "gas": "26+|t\u0432\u0402\u2122|", + "fift": "TPUSH\nCOMMA" + }, + "bytecode": { + "doc_opcode": "6F8C", + "tlb": "#6F8C", + "prefix": "6F8C", + "operands": [] + }, + "value_flow": { + "doc_stack": "t x - t'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "TPOP", + "doc": { + "category": "tuple", + "description": "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`.", + "gas": "26+|t\u0432\u0402\u2122|", + "fift": "TPOP" + }, + "bytecode": { + "doc_opcode": "6F8D", + "tlb": "#6F8D", + "prefix": "6F8D", + "operands": [] + }, + "value_flow": { + "doc_stack": "t - t' x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t2", + "value_types": ["Tuple"] + }, + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "NULLSWAPIF", + "doc": { + "category": "tuple", + "description": "Pushes a _Null_ under the topmost _Integer_ `x`, but only if `x!=0`.", + "gas": "26", + "fift": "NULLSWAPIF" + }, + "bytecode": { + "doc_opcode": "6FA0", + "tlb": "#6FA0", + "prefix": "6FA0", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x or null x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "x", + "match": [ + {"value": 0, "stack": []} + ], + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLSWAPIFNOT", + "doc": { + "category": "tuple", + "description": "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`.", + "gas": "26", + "fift": "NULLSWAPIFNOT" + }, + "bytecode": { + "doc_opcode": "6FA1", + "tlb": "#6FA1", + "prefix": "6FA1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x or null x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "x", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + ], + "else": [] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLROTRIF", + "doc": { + "category": "tuple", + "description": "Pushes a _Null_ under the second stack entry from the top, but only if the topmost _Integer_ `y` is non-zero.", + "gas": "26", + "fift": "NULLROTRIF" + }, + "bytecode": { + "doc_opcode": "6FA2", + "tlb": "#6FA2", + "prefix": "6FA2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x y or null x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "y", + "match": [ + {"value": 0, "stack": []} + ], + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLROTRIFNOT", + "doc": { + "category": "tuple", + "description": "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`.", + "gas": "26", + "fift": "NULLROTRIFNOT" + }, + "bytecode": { + "doc_opcode": "6FA3", + "tlb": "#6FA3", + "prefix": "6FA3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x y or null x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "y", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + ], + "else": [] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLSWAPIF2", + "doc": { + "category": "tuple", + "description": "Pushes two nulls under the topmost _Integer_ `x`, but only if `x!=0`.\nEquivalent to `NULLSWAPIF` `NULLSWAPIF`.", + "gas": "26", + "fift": "NULLSWAPIF2" + }, + "bytecode": { + "doc_opcode": "6FA4", + "tlb": "#6FA4", + "prefix": "6FA4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x or null null x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "x", + "match": [ + {"value": 0, "stack": []} + ], + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLSWAPIFNOT2", + "doc": { + "category": "tuple", + "description": "Pushes two nulls under the topmost _Integer_ `x`, but only if `x=0`.\nEquivalent to `NULLSWAPIFNOT` `NULLSWAPIFNOT`.", + "gas": "26", + "fift": "NULLSWAPIFNOT2" + }, + "bytecode": { + "doc_opcode": "6FA5", + "tlb": "#6FA5", + "prefix": "6FA5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x or null null x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "x", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + ], + "else": [] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLROTRIF2", + "doc": { + "category": "tuple", + "description": "Pushes two nulls under the second stack entry from the top, but only if the topmost _Integer_ `y` is non-zero.\nEquivalent to `NULLROTRIF` `NULLROTRIF`.", + "gas": "26", + "fift": "NULLROTRIF2" + }, + "bytecode": { + "doc_opcode": "6FA6", + "tlb": "#6FA6", + "prefix": "6FA6", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x y or null null x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "y", + "match": [ + {"value": 0, "stack": []} + ], + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NULLROTRIFNOT2", + "doc": { + "category": "tuple", + "description": "Pushes two nulls under the second stack entry from the top, but only if the topmost _Integer_ `y` is zero.\nEquivalent to `NULLROTRIFNOT` `NULLROTRIFNOT`.", + "gas": "26", + "fift": "NULLROTRIFNOT2" + }, + "bytecode": { + "doc_opcode": "6FA7", + "tlb": "#6FA7", + "prefix": "6FA7", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x y or null null x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "y", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + ], + "else": [] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "INDEX2", + "doc": { + "category": "tuple", + "description": "Recovers `x=(t_{i+1})_{j+1}` for `0 <= i,j <= 3`.\nEquivalent to `[i] INDEX` `[j] INDEX`.", + "gas": "26", + "fift": "[i] [j] INDEX2" + }, + "bytecode": { + "doc_opcode": "6FBij", + "tlb": "#6FB i:uint2 j:uint2", + "prefix": "6FB", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 2 + } + } + ] + }, + "value_flow": { + "doc_stack": "t - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "INDEX3", + "doc": { + "category": "tuple", + "description": "Recovers `x=t_{i+1}_{j+1}_{k+1}`.\n`0 <= i,j,k <= 3`\nEquivalent to `[i] [j] INDEX2` `[k] INDEX`.", + "gas": "26", + "fift": "[i] [j] [k] INDEX3" + }, + "bytecode": { + "doc_opcode": "6FE_ijk", + "tlb": "#6FE_ i:uint2 j:uint2 k:uint2", + "prefix": "6FE_", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "j", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 2 + } + } + ] + }, + "value_flow": { + "doc_stack": "t - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "PUSHINT_4", + "doc": { + "category": "const_int", + "description": "Pushes integer `x` into the stack. `-5 <= x <= 10`.\nHere `i` equals four lower-order bits of `x` (`i=x mod 16`).", + "gas": "18", + "fift": "[x] PUSHINT\n[x] INT" + }, + "bytecode": { + "doc_opcode": "7i", + "tlb": "#7 i:uint4", + "prefix": "7", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "- x", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHINT_8", + "doc": { + "category": "const_int", + "description": "Pushes integer `xx`. `-128 <= xx <= 127`.", + "gas": "26", + "fift": "[xx] PUSHINT\n[xx] INT" + }, + "bytecode": { + "doc_opcode": "80xx", + "tlb": "#80 xx:int8", + "prefix": "80", + "operands": [ + { + "name": "x", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "- xx", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHINT_16", + "doc": { + "category": "const_int", + "description": "Pushes integer `xxxx`. `-2^15 <= xx < 2^15`.", + "gas": "34", + "fift": "[xxxx] PUSHINT\n[xxxx] INT" + }, + "bytecode": { + "doc_opcode": "81xxxx", + "tlb": "#81 xxxx:int16", + "prefix": "81", + "operands": [ + { + "name": "x", + "loader": "int", + "loader_args": { + "size": 16 + } + } + ] + }, + "value_flow": { + "doc_stack": "- xxxx", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHINT_LONG", + "doc": { + "category": "const_int", + "description": "Pushes integer `xxx`.\n_Details:_ 5-bit `0 <= l <= 30` determines the length `n=8l+19` of signed big-endian integer `xxx`.\nThe total length of this instruction is `l+4` bytes or `n+13=8l+32` bits.", + "gas": "23", + "fift": "[xxx] PUSHINT\n[xxx] INT" + }, + "bytecode": { + "doc_opcode": "82lxxx", + "tlb": "#82 l:(## 5) xxx:(int (8 * l + 19))", + "prefix": "82", + "operands_range_check": { + "length": 5, + "from": 0, + "to": 30 + }, + "operands": [ + { + "name": "x", + "loader": "pushint_long", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "- xxx", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHPOW2", + "doc": { + "category": "const_int", + "description": "(Quietly) pushes `2^(xx+1)` for `0 <= xx <= 255`.\n`2^256` is a `NaN`.", + "gas": "26", + "fift": "[xx+1] PUSHPOW2" + }, + "bytecode": { + "doc_opcode": "83xx", + "tlb": "#83 xx:uint8", + "prefix": "83", + "operands_range_check": { + "length": 8, + "from": 0, + "to": 255 + }, + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "- 2^(xx+1)", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHNAN", + "doc": { + "category": "const_int", + "description": "Pushes a `NaN`.", + "gas": "26", + "fift": "PUSHNAN" + }, + "bytecode": { + "doc_opcode": "83FF", + "tlb": "#83FF", + "prefix": "83FF", + "operands": [] + }, + "value_flow": { + "doc_stack": "- NaN", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "const", + "value_type": "Integer", + "value": null + } + ] + } + } + }, + { + "mnemonic": "PUSHPOW2DEC", + "doc": { + "category": "const_int", + "description": "Pushes `2^(xx+1)-1` for `0 <= xx <= 255`.", + "gas": "26", + "fift": "[xx+1] PUSHPOW2DEC" + }, + "bytecode": { + "doc_opcode": "84xx", + "tlb": "#84 xx:uint8", + "prefix": "84", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "- 2^(xx+1)-1", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHNEGPOW2", + "doc": { + "category": "const_int", + "description": "Pushes `-2^(xx+1)` for `0 <= xx <= 255`.", + "gas": "26", + "fift": "[xx+1] PUSHNEGPOW2" + }, + "bytecode": { + "doc_opcode": "85xx", + "tlb": "#85 xx:uint8", + "prefix": "85", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "- -2^(xx+1)", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PUSHREF", + "doc": { + "category": "const_data", + "description": "Pushes the reference `ref` into the stack.\n_Details:_ Pushes the first reference of `cc.code` into the stack as a _Cell_ (and removes this reference from the current continuation).", + "gas": "18", + "fift": "[ref] PUSHREF" + }, + "bytecode": { + "doc_opcode": "88", + "tlb": "#88 c:^Cell", + "prefix": "88", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "- c", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "PUSHREFSLICE", + "doc": { + "category": "const_data", + "description": "Similar to `PUSHREF`, but converts the cell into a _Slice_.", + "gas": "118/43", + "fift": "[ref] PUSHREFSLICE" + }, + "bytecode": { + "doc_opcode": "89", + "tlb": "#89 c:^Cell", + "prefix": "89", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "- s", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PUSHREFCONT", + "doc": { + "category": "const_data", + "description": "Similar to `PUSHREFSLICE`, but makes a simple ordinary _Continuation_ out of the cell.", + "gas": "118/43", + "fift": "[ref] PUSHREFCONT" + }, + "bytecode": { + "doc_opcode": "8A", + "tlb": "#8A c:^Cell", + "prefix": "8A", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "- cont", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "PUSHSLICE", + "doc": { + "category": "const_data", + "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.\nIf the original bitstring consists only of zeroes, an empty slice will be pushed.", + "gas": "22", + "fift": "[slice] PUSHSLICE\n[slice] SLICE" + }, + "bytecode": { + "doc_opcode": "8Bxsss", + "tlb": "#8B x:(## 4) sss:((8 * x + 4) * Bit)", + "prefix": "8B", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 4, + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "- s", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PUSHSLICE_REFS", + "doc": { + "category": "const_data", + "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is also assumed.", + "gas": "25", + "fift": "[slice] PUSHSLICE\n[slice] SLICE" + }, + "bytecode": { + "doc_opcode": "8Crxxssss", + "tlb": "#8C r:(## 2) xx:(## 5) c:((r + 1) * ^Cell) ssss:((8 * xx + 1) * Bit)", + "prefix": "8C", + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 5 + } + }, + { + "name": "slice", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 1, + "refs_length_var": "r", + "refs_add": 1, + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "- s", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PUSHSLICE_LONG", + "doc": { + "category": "const_data", + "description": "Pushes the slice `slice` into the stack.\n_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`.\nA completion tag is assumed.", + "gas": "28", + "fift": "[slice] PUSHSLICE\n[slice] SLICE", + "fift_examples": [ + { + "fift": "x{} PUSHSLICE x{ABCD1234} PUSHSLICE b{01101} PUSHSLICE", + "description": "Examples of `PUSHSLICE`. `x{}` is an empty slice. `x{...}` is a hexadecimal literal. `b{...}` is a binary literal. More on slice literals [here](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-51-slice-literals). Note that the assembler can replace `PUSHSLICE` with `PUSHREFSLICE` in certain situations (e.g. if there’s not enough space in the current continuation)." + }, + { + "fift": " PUSHREF PUSHREFSLICE", + "description": "Examples of `PUSHREF` and `PUSHREFSLICE`. More on building cells in fift [here](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-52-builder-primitives)." + } + ] + }, + "bytecode": { + "doc_opcode": "8Drxxsssss", + "tlb": "#8D r:(#<= 4) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx + 6) * Bit)", + "prefix": "8D", + "operands_range_check": { + "length": 3, + "from": 0, + "to": 4 + }, + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 3 + } + }, + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 7 + } + }, + { + "name": "slice", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 6, + "refs_length_var": "r", + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "- s", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PUSHCONT", + "doc": { + "category": "const_data", + "description": "Pushes a continuation made from `builder`.\n_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`.", + "gas": "26", + "fift": "[builder] PUSHCONT\n[builder] CONT" + }, + "bytecode": { + "doc_opcode": "8F_rxxcccc", + "tlb": "#8F_ r:(## 2) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx) * Bit)", + "prefix": "8F_", + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 7 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "xx", + "bits_padding": 0, + "refs_length_var": "r" + } + } + ] + }, + "value_flow": { + "doc_stack": "- c", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "PUSHCONT_SHORT", + "doc": { + "category": "const_data", + "description": "Pushes a continuation made from `builder`.\n_Details:_ Pushes an `x`-byte continuation for `0 <= x <= 15`.", + "gas": "18", + "fift": "[builder] PUSHCONT\n[builder] CONT", + "fift_examples": [ + { + "fift": "<{ code }> PUSHCONT <{ code }> CONT CONT:<{ code }>", + "description": "Pushes a continuation with code `code`. Note that the assembler can replace `PUSHCONT` with `PUSHREFCONT` in certain situations (e.g. if there’s not enough space in the current continuation)." + } + ] + }, + "bytecode": { + "doc_opcode": "9xccc", + "tlb": "#9 x:(## 4) ssss:((8 * x) * Bit)", + "prefix": "9", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 0 + } + } + ] + }, + "value_flow": { + "doc_stack": "- c", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "ADD", + "doc": { + "category": "arithm_basic", + "description": "", + "gas": "18", + "fift": "ADD" + }, + "bytecode": { + "doc_opcode": "A0", + "tlb": "#A0", + "prefix": "A0", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x+y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SUB", + "doc": { + "category": "arithm_basic", + "description": "", + "gas": "18", + "fift": "SUB" + }, + "bytecode": { + "doc_opcode": "A1", + "tlb": "#A1", + "prefix": "A1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x-y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SUBR", + "doc": { + "category": "arithm_basic", + "description": "Equivalent to `SWAP` `SUB`.", + "gas": "18", + "fift": "SUBR" + }, + "bytecode": { + "doc_opcode": "A2", + "tlb": "#A2", + "prefix": "A2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - y-x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NEGATE", + "doc": { + "category": "arithm_basic", + "description": "Equivalent to `-1 MULCONST` or to `ZERO SUBR`.\nNotice that it triggers an integer overflow exception if `x=-2^256`.", + "gas": "18", + "fift": "NEGATE" + }, + "bytecode": { + "doc_opcode": "A3", + "tlb": "#A3", + "prefix": "A3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - -x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "INC", + "doc": { + "category": "arithm_basic", + "description": "Equivalent to `1 ADDCONST`.", + "gas": "18", + "fift": "INC" + }, + "bytecode": { + "doc_opcode": "A4", + "tlb": "#A4", + "prefix": "A4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x+1", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DEC", + "doc": { + "category": "arithm_basic", + "description": "Equivalent to `-1 ADDCONST`.", + "gas": "18", + "fift": "DEC" + }, + "bytecode": { + "doc_opcode": "A5", + "tlb": "#A5", + "prefix": "A5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x-1", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "ADDCONST", + "doc": { + "category": "arithm_basic", + "description": "`-128 <= cc <= 127`.", + "gas": "26", + "fift": "[cc] ADDCONST\n[cc] ADDINT\n[-cc] SUBCONST\n[-cc] SUBINT" + }, + "bytecode": { + "doc_opcode": "A6cc", + "tlb": "#A6 cc:int8", + "prefix": "A6", + "operands": [ + { + "name": "c", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x+cc", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULCONST", + "doc": { + "category": "arithm_basic", + "description": "`-128 <= cc <= 127`.", + "gas": "26", + "fift": "[cc] MULCONST\n[cc] MULINT" + }, + "bytecode": { + "doc_opcode": "A7cc", + "tlb": "#A7 cc:int8", + "prefix": "A7", + "operands": [ + { + "name": "c", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x*cc", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MUL", + "doc": { + "category": "arithm_basic", + "description": "", + "gas": "18", + "fift": "MUL" + }, + "bytecode": { + "doc_opcode": "A8", + "tlb": "#A8", + "prefix": "A8", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x*y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIV", + "doc": { + "category": "arithm_div", + "description": "`q=floor(x/y)`, `r=x-y*q`", + "gas": "26", + "fift": "DIV" + }, + "bytecode": { + "doc_opcode": "A904", + "tlb": "#A904", + "prefix": "A904", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIVR", + "doc": { + "category": "arithm_div", + "description": "`q\u0432\u0402\u2122=round(x/y)`, `r\u0432\u0402\u2122=x-y*q\u0432\u0402\u2122`", + "gas": "26", + "fift": "DIVR" + }, + "bytecode": { + "doc_opcode": "A905", + "tlb": "#A905", + "prefix": "A905", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q\u0432\u0402\u2122", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIVC", + "doc": { + "category": "arithm_div", + "description": "`q\u0432\u0402\u2122\u0432\u0402\u2122=ceil(x/y)`, `r\u0432\u0402\u2122\u0432\u0402\u2122=x-y*q\u0432\u0402\u2122\u0432\u0402\u2122`", + "gas": "26", + "fift": "DIVC" + }, + "bytecode": { + "doc_opcode": "A906", + "tlb": "#A906", + "prefix": "A906", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MOD", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "MOD" + }, + "bytecode": { + "doc_opcode": "A908", + "tlb": "#A908", + "prefix": "A908", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIVMOD", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "DIVMOD" + }, + "bytecode": { + "doc_opcode": "A90C", + "tlb": "#A90C", + "prefix": "A90C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIVMODR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "DIVMODR" + }, + "bytecode": { + "doc_opcode": "A90D", + "tlb": "#A90D", + "prefix": "A90D", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q' r'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DIVMODC", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "DIVMODC" + }, + "bytecode": { + "doc_opcode": "A90E", + "tlb": "#A90E", + "prefix": "A90E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q'' r''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFTR_VAR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "RSHIFTR" + }, + "bytecode": { + "doc_opcode": "A925", + "tlb": "#A925", + "prefix": "A925", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - round(x/2^y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFTC_VAR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "RSHIFTC" + }, + "bytecode": { + "doc_opcode": "A926", + "tlb": "#A926", + "prefix": "A926", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - ceil(x/2^y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFTR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] RSHIFTR#" + }, + "bytecode": { + "doc_opcode": "A935tt", + "tlb": "#A935 tt:uint8", + "prefix": "A935", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - round(x/2^(tt+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFTC", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] RSHIFTC#" + }, + "bytecode": { + "doc_opcode": "A936tt", + "tlb": "#A936 tt:uint8", + "prefix": "A936", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - ceil(x/2^(tt+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MODPOW2", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "[tt+1] MODPOW2#" + }, + "bytecode": { + "doc_opcode": "A938tt", + "tlb": "#A938 tt:uint8", + "prefix": "A938", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x mod 2^(tt+1)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULDIV", + "doc": { + "category": "arithm_div", + "description": "`q=floor(x*y/z)`", + "gas": "26", + "fift": "MULDIV" + }, + "bytecode": { + "doc_opcode": "A98", + "tlb": "#A984", + "prefix": "A984", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - q", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULDIVR", + "doc": { + "category": "arithm_div", + "description": "`q'=round(x*y/z)`", + "gas": "26", + "fift": "MULDIVR" + }, + "bytecode": { + "doc_opcode": "A985", + "tlb": "#A985", + "prefix": "A985", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - q'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULDIVMOD", + "doc": { + "category": "arithm_div", + "description": "`q=floor(x*y/z)`, `r=x*y-z*q`", + "gas": "26", + "fift": "MULDIVMOD" + }, + "bytecode": { + "doc_opcode": "A98C", + "tlb": "#A98C", + "prefix": "A98C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - q r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFT_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "26", + "fift": "MULRSHIFT" + }, + "bytecode": { + "doc_opcode": "A9A4", + "tlb": "#A9A4", + "prefix": "A9A4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - floor(x*y/2^z)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFTR_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "26", + "fift": "MULRSHIFTR" + }, + "bytecode": { + "doc_opcode": "A9A5", + "tlb": "#A9A5", + "prefix": "A9A5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - round(x*y/2^z)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFTC_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "34", + "fift": "MULRSHIFTC" + }, + "bytecode": { + "doc_opcode": "A9A6", + "tlb": "#A9A6", + "prefix": "A9A6", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - ceil(x*y/2^z)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFT", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] MULRSHIFT#" + }, + "bytecode": { + "doc_opcode": "A9B4tt", + "tlb": "#A9B4 tt:uint8", + "prefix": "A9B4", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - floor(x*y/2^(tt+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFTR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] MULRSHIFTR#" + }, + "bytecode": { + "doc_opcode": "A9B5tt", + "tlb": "#A9B5 tt:uint8", + "prefix": "A9B5", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - round(x*y/2^(tt+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MULRSHIFTC", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "[tt+1] MULRSHIFTC#" + }, + "bytecode": { + "doc_opcode": "A9B6tt", + "tlb": "#A9B6 tt:uint8", + "prefix": "A9B6", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - ceil(x*y/2^(tt+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIV_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "26", + "fift": "LSHIFTDIV" + }, + "bytecode": { + "doc_opcode": "A9C4", + "tlb": "#A9C4", + "prefix": "A9C4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - floor(2^z*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIVR_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "26", + "fift": "LSHIFTDIVR" + }, + "bytecode": { + "doc_opcode": "A9C5", + "tlb": "#A9C5", + "prefix": "A9C5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - round(2^z*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIVC_VAR", + "doc": { + "category": "arithm_div", + "description": "`0 <= z <= 256`", + "gas": "34", + "fift": "LSHIFTDIVC" + }, + "bytecode": { + "doc_opcode": "A9C6", + "tlb": "#A9C6", + "prefix": "A9C6", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - ceil(2^z*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIV", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] LSHIFT#DIV" + }, + "bytecode": { + "doc_opcode": "A9D4tt", + "tlb": "#A9D4 tt:uint8", + "prefix": "A9D4", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - floor(2^(tt+1)*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIVR", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "34", + "fift": "[tt+1] LSHIFT#DIVR" + }, + "bytecode": { + "doc_opcode": "A9D5tt", + "tlb": "#A9D5 tt:uint8", + "prefix": "A9D5", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - round(2^(tt+1)*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFTDIVC", + "doc": { + "category": "arithm_div", + "description": "", + "gas": "26", + "fift": "[tt+1] LSHIFT#DIVC" + }, + "bytecode": { + "doc_opcode": "A9D6tt", + "tlb": "#A9D6 tt:uint8", + "prefix": "A9D6", + "operands": [ + { + "name": "t", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x y - ceil(2^(tt+1)*x/y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFT", + "doc": { + "category": "arithm_logical", + "description": "`0 <= cc <= 255`", + "gas": "26", + "fift": "[cc+1] LSHIFT#" + }, + "bytecode": { + "doc_opcode": "AAcc", + "tlb": "#AA cc:uint8", + "prefix": "AA", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x*2^(cc+1)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFT", + "doc": { + "category": "arithm_logical", + "description": "`0 <= cc <= 255`", + "gas": "18", + "fift": "[cc+1] RSHIFT#" + }, + "bytecode": { + "doc_opcode": "ABcc", + "tlb": "#AB cc:uint8", + "prefix": "AB", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - floor(x/2^(cc+1))", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LSHIFT_VAR", + "doc": { + "category": "arithm_logical", + "description": "`0 <= y <= 1023`", + "gas": "18", + "fift": "LSHIFT" + }, + "bytecode": { + "doc_opcode": "AC", + "tlb": "#AC", + "prefix": "AC", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x*2^y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RSHIFT_VAR", + "doc": { + "category": "arithm_logical", + "description": "`0 <= y <= 1023`", + "gas": "18", + "fift": "RSHIFT" + }, + "bytecode": { + "doc_opcode": "AD", + "tlb": "#AD", + "prefix": "AD", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - floor(x/2^y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "POW2", + "doc": { + "category": "arithm_logical", + "description": "`0 <= y <= 1023`\nEquivalent to `ONE` `SWAP` `LSHIFT`.", + "gas": "18", + "fift": "POW2" + }, + "bytecode": { + "doc_opcode": "AE", + "tlb": "#AE", + "prefix": "AE", + "operands": [] + }, + "value_flow": { + "doc_stack": "y - 2^y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "AND", + "doc": { + "category": "arithm_logical", + "description": "Bitwise and of two signed integers `x` and `y`, sign-extended to infinity.", + "gas": "18", + "fift": "AND" + }, + "bytecode": { + "doc_opcode": "B0", + "tlb": "#B0", + "prefix": "B0", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x&y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "OR", + "doc": { + "category": "arithm_logical", + "description": "Bitwise or of two integers.", + "gas": "18", + "fift": "OR" + }, + "bytecode": { + "doc_opcode": "B1", + "tlb": "#B1", + "prefix": "B1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x|y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "XOR", + "doc": { + "category": "arithm_logical", + "description": "Bitwise xor of two integers.", + "gas": "18", + "fift": "XOR" + }, + "bytecode": { + "doc_opcode": "B2", + "tlb": "#B2", + "prefix": "B2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x xor y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NOT", + "doc": { + "category": "arithm_logical", + "description": "Bitwise not of an integer.", + "gas": "26", + "fift": "NOT" + }, + "bytecode": { + "doc_opcode": "B3", + "tlb": "#B3", + "prefix": "B3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - ~x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "FITS", + "doc": { + "category": "arithm_logical", + "description": "Checks whether `x` is a `cc+1`-bit signed integer for `0 <= cc <= 255` (i.e., whether `-2^cc <= x < 2^cc`).\nIf not, either triggers an integer overflow exception, or replaces `x` with a `NaN` (quiet version).", + "gas": "26/76", + "fift": "[cc+1] FITS" + }, + "bytecode": { + "doc_opcode": "B4cc", + "tlb": "#B4 cc:uint8", + "prefix": "B4", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "UFITS", + "doc": { + "category": "arithm_logical", + "description": "Checks whether `x` is a `cc+1`-bit unsigned integer for `0 <= cc <= 255` (i.e., whether `0 <= x < 2^(cc+1)`).", + "gas": "26/76", + "fift": "[cc+1] UFITS" + }, + "bytecode": { + "doc_opcode": "B5cc", + "tlb": "#B5 cc:uint8", + "prefix": "B5", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "FITSX", + "doc": { + "category": "arithm_logical", + "description": "Checks whether `x` is a `c`-bit signed integer for `0 <= c <= 1023`.", + "gas": "26/76", + "fift": "FITSX" + }, + "bytecode": { + "doc_opcode": "B600", + "tlb": "#B600", + "prefix": "B600", + "operands": [] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "UFITSX", + "doc": { + "category": "arithm_logical", + "description": "Checks whether `x` is a `c`-bit unsigned integer for `0 <= c <= 1023`.", + "gas": "26/76", + "fift": "UFITSX" + }, + "bytecode": { + "doc_opcode": "B601", + "tlb": "#B601", + "prefix": "B601", + "operands": [] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BITSIZE", + "doc": { + "category": "arithm_logical", + "description": "Computes smallest `c >= 0` such that `x` fits into a `c`-bit signed integer (`-2^(c-1) <= c < 2^(c-1)`).", + "gas": "26", + "fift": "BITSIZE" + }, + "bytecode": { + "doc_opcode": "B602", + "tlb": "#B602", + "prefix": "B602", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "UBITSIZE", + "doc": { + "category": "arithm_logical", + "description": "Computes smallest `c >= 0` such that `x` fits into a `c`-bit unsigned integer (`0 <= x < 2^c`), or throws a range check exception.", + "gas": "26", + "fift": "UBITSIZE" + }, + "bytecode": { + "doc_opcode": "B603", + "tlb": "#B603", + "prefix": "B603", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MIN", + "doc": { + "category": "arithm_logical", + "description": "Computes the minimum of two integers `x` and `y`.", + "gas": "26", + "fift": "MIN" + }, + "bytecode": { + "doc_opcode": "B608", + "tlb": "#B608", + "prefix": "B608", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x or y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MAX", + "doc": { + "category": "arithm_logical", + "description": "Computes the maximum of two integers `x` and `y`.", + "gas": "26", + "fift": "MAX" + }, + "bytecode": { + "doc_opcode": "B609", + "tlb": "#B609", + "prefix": "B609", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x or y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "MINMAX", + "doc": { + "category": "arithm_logical", + "description": "Sorts two integers. Quiet version of this operation returns two `NaN`s if any of the arguments are `NaN`s.", + "gas": "26", + "fift": "MINMAX\nINTSORT2" + }, + "bytecode": { + "doc_opcode": "B60A", + "tlb": "#B60A", + "prefix": "B60A", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x y or y x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "r1", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r2", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "ABS", + "doc": { + "category": "arithm_logical", + "description": "Computes the absolute value of an integer `x`.", + "gas": "26", + "fift": "ABS" + }, + "bytecode": { + "doc_opcode": "B60B", + "tlb": "#B60B", + "prefix": "B60B", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - |x|", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QADD", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QADD" + }, + "bytecode": { + "doc_opcode": "B7A0", + "tlb": "#B7A0", + "prefix": "B7A0", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x+y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QSUB", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QSUB" + }, + "bytecode": { + "doc_opcode": "B7A1", + "tlb": "#B7A1", + "prefix": "B7A1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x-y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QSUBR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QSUBR" + }, + "bytecode": { + "doc_opcode": "B7A2", + "tlb": "#B7A2", + "prefix": "B7A2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - y-x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QNEGATE", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QNEGATE" + }, + "bytecode": { + "doc_opcode": "B7A3", + "tlb": "#B7A3", + "prefix": "B7A3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - -x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QINC", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QINC" + }, + "bytecode": { + "doc_opcode": "B7A4", + "tlb": "#B7A4", + "prefix": "B7A4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x+1", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDEC", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QDEC" + }, + "bytecode": { + "doc_opcode": "B7A5", + "tlb": "#B7A5", + "prefix": "B7A5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x-1", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QMUL", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QMUL" + }, + "bytecode": { + "doc_opcode": "B7A8", + "tlb": "#B7A8", + "prefix": "B7A8", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x*y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIV", + "doc": { + "category": "arithm_quiet", + "description": "Division returns `NaN` if `y=0`.", + "gas": "34", + "fift": "QDIV" + }, + "bytecode": { + "doc_opcode": "B7A904", + "tlb": "#B7A904", + "prefix": "B7A904", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIVR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QDIVR" + }, + "bytecode": { + "doc_opcode": "B7A905", + "tlb": "#B7A905", + "prefix": "B7A905", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q\u0432\u0402\u2122", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIVC", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QDIVC" + }, + "bytecode": { + "doc_opcode": "B7A906", + "tlb": "#B7A906", + "prefix": "B7A906", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QMOD", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QMOD" + }, + "bytecode": { + "doc_opcode": "B7A908", + "tlb": "#B7A908", + "prefix": "B7A908", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIVMOD", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QDIVMOD" + }, + "bytecode": { + "doc_opcode": "B7A90C", + "tlb": "#B7A90C", + "prefix": "B7A90C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIVMODR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QDIVMODR" + }, + "bytecode": { + "doc_opcode": "B7A90D", + "tlb": "#B7A90D", + "prefix": "B7A90D", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q' r'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QDIVMODC", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QDIVMODC" + }, + "bytecode": { + "doc_opcode": "B7A90E", + "tlb": "#B7A90E", + "prefix": "B7A90E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - q'' r''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QMULDIVR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QMULDIVR" + }, + "bytecode": { + "doc_opcode": "B7A985", + "tlb": "#B7A985", + "prefix": "B7A985", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - q'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QMULDIVMOD", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "34", + "fift": "QMULDIVMOD" + }, + "bytecode": { + "doc_opcode": "B7A98C", + "tlb": "#B7A98C", + "prefix": "B7A98C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y z - q r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "q", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QLSHIFT", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QLSHIFT" + }, + "bytecode": { + "doc_opcode": "B7AC", + "tlb": "#B7AC", + "prefix": "B7AC", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x*2^y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QRSHIFT", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QRSHIFT" + }, + "bytecode": { + "doc_opcode": "B7AD", + "tlb": "#B7AD", + "prefix": "B7AD", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - floor(x/2^y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QPOW2", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QPOW2" + }, + "bytecode": { + "doc_opcode": "B7AE", + "tlb": "#B7AE", + "prefix": "B7AE", + "operands": [] + }, + "value_flow": { + "doc_stack": "y - 2^y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QAND", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QAND" + }, + "bytecode": { + "doc_opcode": "B7B0", + "tlb": "#B7B0", + "prefix": "B7B0", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x&y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QOR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QOR" + }, + "bytecode": { + "doc_opcode": "B7B1", + "tlb": "#B7B1", + "prefix": "B7B1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x|y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QXOR", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QXOR" + }, + "bytecode": { + "doc_opcode": "B7B2", + "tlb": "#B7B2", + "prefix": "B7B2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x xor y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QNOT", + "doc": { + "category": "arithm_quiet", + "description": "", + "gas": "26", + "fift": "QNOT" + }, + "bytecode": { + "doc_opcode": "B7B3", + "tlb": "#B7B3", + "prefix": "B7B3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - ~x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QFITS", + "doc": { + "category": "arithm_quiet", + "description": "Replaces `x` with a `NaN` if x is not a `cc+1`-bit signed integer, leaves it intact otherwise.", + "gas": "34", + "fift": "[cc+1] QFITS" + }, + "bytecode": { + "doc_opcode": "B7B4cc", + "tlb": "#B7B4 cc:uint8", + "prefix": "B7B4", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QUFITS", + "doc": { + "category": "arithm_quiet", + "description": "Replaces `x` with a `NaN` if x is not a `cc+1`-bit unsigned integer, leaves it intact otherwise.", + "gas": "34", + "fift": "[cc+1] QUFITS" + }, + "bytecode": { + "doc_opcode": "B7B5cc", + "tlb": "#B7B5 cc:uint8", + "prefix": "B7B5", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QFITSX", + "doc": { + "category": "arithm_quiet", + "description": "Replaces `x` with a `NaN` if x is not a c-bit signed integer, leaves it intact otherwise.", + "gas": "34", + "fift": "QFITSX" + }, + "bytecode": { + "doc_opcode": "B7B600", + "tlb": "#B7B600", + "prefix": "B7B600", + "operands": [] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "QUFITSX", + "doc": { + "category": "arithm_quiet", + "description": "Replaces `x` with a `NaN` if x is not a c-bit unsigned integer, leaves it intact otherwise.", + "gas": "34", + "fift": "QUFITSX" + }, + "bytecode": { + "doc_opcode": "B7B601", + "tlb": "#B7B601", + "prefix": "B7B601", + "operands": [] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SGN", + "doc": { + "category": "compare_int", + "description": "Computes the sign of an integer `x`:\n`-1` if `x<0`, `0` if `x=0`, `1` if `x>0`.", + "gas": "18", + "fift": "SGN" + }, + "bytecode": { + "doc_opcode": "B8", + "tlb": "#B8", + "prefix": "B8", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - sgn(x)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LESS", + "doc": { + "category": "compare_int", + "description": "Returns `-1` if `xy", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NEQ", + "doc": { + "category": "compare_int", + "description": "Equivalent to `EQUAL` `NOT`.", + "gas": "18", + "fift": "NEQ" + }, + "bytecode": { + "doc_opcode": "BD", + "tlb": "#BD", + "prefix": "BD", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x!=y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "GEQ", + "doc": { + "category": "compare_int", + "description": "Equivalent to `LESS` `NOT`.", + "gas": "18", + "fift": "GEQ" + }, + "bytecode": { + "doc_opcode": "BE", + "tlb": "#BE", + "prefix": "BE", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - x>=y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CMP", + "doc": { + "category": "compare_int", + "description": "Computes the sign of `x-y`:\n`-1` if `xy`.\nNo integer overflow can occur here unless `x` or `y` is a `NaN`.", + "gas": "18", + "fift": "CMP" + }, + "bytecode": { + "doc_opcode": "BF", + "tlb": "#BF", + "prefix": "BF", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - sgn(x-y)", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "EQINT", + "doc": { + "category": "compare_int", + "description": "Returns `-1` if `x=yy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", + "gas": "26", + "fift": "[yy] EQINT" + }, + "bytecode": { + "doc_opcode": "C0yy", + "tlb": "#C0 yy:int8", + "prefix": "C0", + "operands": [ + { + "name": "y", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x=yy", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LESSINT", + "doc": { + "category": "compare_int", + "description": "Returns `-1` if `xyy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", + "gas": "26", + "fift": "[yy] GTINT\n[yy+1] GEQINT" + }, + "bytecode": { + "doc_opcode": "C2yy", + "tlb": "#C2 yy:int8", + "prefix": "C2", + "operands": [ + { + "name": "y", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x>yy", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NEQINT", + "doc": { + "category": "compare_int", + "description": "Returns `-1` if `x!=yy`, `0` otherwise.\n`-2^7 <= yy < 2^7`.", + "gas": "26", + "fift": "[yy] NEQINT" + }, + "bytecode": { + "doc_opcode": "C3yy", + "tlb": "#C3 yy:int8", + "prefix": "C3", + "operands": [ + { + "name": "y", + "loader": "int", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x!=yy", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "ISNAN", + "doc": { + "category": "compare_int", + "description": "Checks whether `x` is a `NaN`.", + "gas": "18", + "fift": "ISNAN" + }, + "bytecode": { + "doc_opcode": "C4", + "tlb": "#C4", + "prefix": "C4", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x=NaN", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CHKNAN", + "doc": { + "category": "compare_int", + "description": "Throws an arithmetic overflow exception if `x` is a `NaN`.", + "gas": "18/68", + "fift": "CHKNAN" + }, + "bytecode": { + "doc_opcode": "C5", + "tlb": "#C5", + "prefix": "C5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SEMPTY", + "doc": { + "category": "compare_other", + "description": "Checks whether a _Slice_ `s` is empty (i.e., contains no bits of data and no cell references).", + "gas": "26", + "fift": "SEMPTY" + }, + "bytecode": { + "doc_opcode": "C700", + "tlb": "#C700", + "prefix": "C700", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDEMPTY", + "doc": { + "category": "compare_other", + "description": "Checks whether _Slice_ `s` has no bits of data.", + "gas": "26", + "fift": "SDEMPTY" + }, + "bytecode": { + "doc_opcode": "C701", + "tlb": "#C701", + "prefix": "C701", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SREMPTY", + "doc": { + "category": "compare_other", + "description": "Checks whether _Slice_ `s` has no references.", + "gas": "26", + "fift": "SREMPTY" + }, + "bytecode": { + "doc_opcode": "C702", + "tlb": "#C702", + "prefix": "C702", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDFIRST", + "doc": { + "category": "compare_other", + "description": "Checks whether the first bit of _Slice_ `s` is a one.", + "gas": "26", + "fift": "SDFIRST" + }, + "bytecode": { + "doc_opcode": "C703", + "tlb": "#C703", + "prefix": "C703", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDLEXCMP", + "doc": { + "category": "compare_other", + "description": "Compares the data of `s` lexicographically with the data of `s'`, returning `-1`, 0, or 1 depending on the result.", + "gas": "26", + "fift": "SDLEXCMP" + }, + "bytecode": { + "doc_opcode": "C704", + "tlb": "#C704", + "prefix": "C704", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDEQ", + "doc": { + "category": "compare_other", + "description": "Checks whether the data parts of `s` and `s'` coincide, equivalent to `SDLEXCMP` `ISZERO`.", + "gas": "26", + "fift": "SDEQ" + }, + "bytecode": { + "doc_opcode": "C705", + "tlb": "#C705", + "prefix": "C705", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPFX", + "doc": { + "category": "compare_other", + "description": "Checks whether `s` is a prefix of `s'`.", + "gas": "26", + "fift": "SDPFX" + }, + "bytecode": { + "doc_opcode": "C708", + "tlb": "#C708", + "prefix": "C708", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPFXREV", + "doc": { + "category": "compare_other", + "description": "Checks whether `s'` is a prefix of `s`, equivalent to `SWAP` `SDPFX`.", + "gas": "26", + "fift": "SDPFXREV" + }, + "bytecode": { + "doc_opcode": "C709", + "tlb": "#C709", + "prefix": "C709", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPPFX", + "doc": { + "category": "compare_other", + "description": "Checks whether `s` is a proper prefix of `s'` (i.e., a prefix distinct from `s'`).", + "gas": "26", + "fift": "SDPPFX" + }, + "bytecode": { + "doc_opcode": "C70A", + "tlb": "#C70A", + "prefix": "C70A", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPPFXREV", + "doc": { + "category": "compare_other", + "description": "Checks whether `s'` is a proper prefix of `s`.", + "gas": "26", + "fift": "SDPPFXREV" + }, + "bytecode": { + "doc_opcode": "C70B", + "tlb": "#C70B", + "prefix": "C70B", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "SDSFX", + "doc": { + "category": "compare_other", + "description": "Checks whether `s` is a suffix of `s'`.", + "gas": "26", + "fift": "SDSFX" + }, + "bytecode": { + "doc_opcode": "C70C", + "tlb": "#C70C", + "prefix": "C70C", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDSFXREV", + "doc": { + "category": "compare_other", + "description": "Checks whether `s'` is a suffix of `s`.", + "gas": "26", + "fift": "SDSFXREV" + }, + "bytecode": { + "doc_opcode": "C70D", + "tlb": "#C70D", + "prefix": "C70D", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPSFX", + "doc": { + "category": "compare_other", + "description": "Checks whether `s` is a proper suffix of `s'`.", + "gas": "26", + "fift": "SDPSFX" + }, + "bytecode": { + "doc_opcode": "C70E", + "tlb": "#C70E", + "prefix": "C70E", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDPSFXREV", + "doc": { + "category": "compare_other", + "description": "Checks whether `s'` is a proper suffix of `s`.", + "gas": "26", + "fift": "SDPSFXREV" + }, + "bytecode": { + "doc_opcode": "C70F", + "tlb": "#C70F", + "prefix": "C70F", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDCNTLEAD0", + "doc": { + "category": "compare_other", + "description": "Returns the number of leading zeroes in `s`.", + "gas": "26", + "fift": "SDCNTLEAD0" + }, + "bytecode": { + "doc_opcode": "C710", + "tlb": "#C710", + "prefix": "C710", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDCNTLEAD1", + "doc": { + "category": "compare_other", + "description": "Returns the number of leading ones in `s`.", + "gas": "26", + "fift": "SDCNTLEAD1" + }, + "bytecode": { + "doc_opcode": "C711", + "tlb": "#C711", + "prefix": "C711", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDCNTTRAIL0", + "doc": { + "category": "compare_other", + "description": "Returns the number of trailing zeroes in `s`.", + "gas": "26", + "fift": "SDCNTTRAIL0" + }, + "bytecode": { + "doc_opcode": "C712", + "tlb": "#C712", + "prefix": "C712", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDCNTTRAIL1", + "doc": { + "category": "compare_other", + "description": "Returns the number of trailing ones in `s`.", + "gas": "26", + "fift": "SDCNTTRAIL1" + }, + "bytecode": { + "doc_opcode": "C713", + "tlb": "#C713", + "prefix": "C713", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "NEWC", + "doc": { + "category": "cell_build", + "description": "Creates a new empty _Builder_.", + "gas": "18", + "fift": "NEWC" + }, + "bytecode": { + "doc_opcode": "C8", + "tlb": "#C8", + "prefix": "C8", + "operands": [] + }, + "value_flow": { + "doc_stack": "- b", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "ENDC", + "doc": { + "category": "cell_build", + "description": "Converts a _Builder_ into an ordinary _Cell_.", + "gas": "518", + "fift": "ENDC" + }, + "bytecode": { + "doc_opcode": "C9", + "tlb": "#C9", + "prefix": "C9", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "STI", + "doc": { + "category": "cell_build", + "description": "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.", + "gas": "26", + "fift": "[cc+1] STI" + }, + "bytecode": { + "doc_opcode": "CAcc", + "tlb": "#CA cc:uint8", + "prefix": "CA", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STU", + "doc": { + "category": "cell_build", + "description": "Stores an unsigned `cc+1`-bit integer `x` into _Builder_ `b`. In all other respects it is similar to `STI`.", + "gas": "26", + "fift": "[cc+1] STU" + }, + "bytecode": { + "doc_opcode": "CBcc", + "tlb": "#CB cc:uint8", + "prefix": "CB", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STREF", + "doc": { + "category": "cell_build", + "description": "Stores a reference to _Cell_ `c` into _Builder_ `b`.", + "gas": "18", + "fift": "STREF" + }, + "bytecode": { + "doc_opcode": "CC", + "tlb": "#CC", + "prefix": "CC", + "operands": [] + }, + "value_flow": { + "doc_stack": "c b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STBREFR", + "doc": { + "category": "cell_build", + "description": "Equivalent to `ENDC` `SWAP` `STREF`.", + "gas": "518", + "fift": "STBREFR\nENDCST" + }, + "bytecode": { + "doc_opcode": "CD", + "tlb": "#CD", + "prefix": "CD", + "operands": [] + }, + "value_flow": { + "doc_stack": "b b'' - b", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "child", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STSLICE", + "doc": { + "category": "cell_build", + "description": "Stores _Slice_ `s` into _Builder_ `b`.", + "gas": "18", + "fift": "STSLICE" + }, + "bytecode": { + "doc_opcode": "CE", + "tlb": "#CE", + "prefix": "CE", + "operands": [] + }, + "value_flow": { + "doc_stack": "s b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STIX", + "doc": { + "category": "cell_build", + "description": "Stores a signed `l`-bit integer `x` into `b` for `0 <= l <= 257`.", + "gas": "26", + "fift": "STIX" + }, + "bytecode": { + "doc_opcode": "CF00", + "tlb": "#CF00", + "prefix": "CF00", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b l - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STUX", + "doc": { + "category": "cell_build", + "description": "Stores an unsigned `l`-bit integer `x` into `b` for `0 <= l <= 256`.", + "gas": "26", + "fift": "STUX" + }, + "bytecode": { + "doc_opcode": "CF01", + "tlb": "#CF01", + "prefix": "CF01", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b l - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STIXR", + "doc": { + "category": "cell_build", + "description": "Similar to `STIX`, but with arguments in a different order.", + "gas": "26", + "fift": "STIXR" + }, + "bytecode": { + "doc_opcode": "CF02", + "tlb": "#CF02", + "prefix": "CF02", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x l - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STUXR", + "doc": { + "category": "cell_build", + "description": "Similar to `STUX`, but with arguments in a different order.", + "gas": "26", + "fift": "STUXR" + }, + "bytecode": { + "doc_opcode": "CF03", + "tlb": "#CF03", + "prefix": "CF03", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x l - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STIXQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STIX`. If there is no space in `b`, sets `b'=b` and `f=-1`.\nIf `x` does not fit into `l` bits, sets `b'=b` and `f=1`.\nIf the operation succeeds, `b'` is the new _Builder_ and `f=0`.\nHowever, `0 <= l <= 257`, with a range check exception if this is not so.", + "gas": "26", + "fift": "STIXQ" + }, + "bytecode": { + "doc_opcode": "CF04", + "tlb": "#CF04", + "prefix": "CF04", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b l - x b f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STUXQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STUX`.", + "gas": "26", + "fift": "STUXQ" + }, + "bytecode": { + "doc_opcode": "CF05", + "tlb": "#CF05", + "prefix": "CF05", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b l - x b f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STIXRQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STIXR`.", + "gas": "26", + "fift": "STIXRQ" + }, + "bytecode": { + "doc_opcode": "CF06", + "tlb": "#CF06", + "prefix": "CF06", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x l - b x f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STUXRQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STUXR`.", + "gas": "26", + "fift": "STUXRQ" + }, + "bytecode": { + "doc_opcode": "CF07", + "tlb": "#CF07", + "prefix": "CF07", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x l - b x f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STI_ALT", + "doc": { + "category": "cell_build", + "description": "A longer version of `[cc+1] STI`.", + "gas": "34", + "fift": "[cc+1] STI_l" + }, + "bytecode": { + "doc_opcode": "CF08cc", + "tlb": "#CF08 cc:uint8", + "prefix": "CF08", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STU_ALT", + "doc": { + "category": "cell_build", + "description": "A longer version of `[cc+1] STU`.", + "gas": "34", + "fift": "[cc+1] STU_l" + }, + "bytecode": { + "doc_opcode": "CF09cc", + "tlb": "#CF09 cc:uint8", + "prefix": "CF09", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STIR", + "doc": { + "category": "cell_build", + "description": "Equivalent to `SWAP` `[cc+1] STI`.", + "gas": "34", + "fift": "[cc+1] STIR" + }, + "bytecode": { + "doc_opcode": "CF0Acc", + "tlb": "#CF0A cc:uint8", + "prefix": "CF0A", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b x - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STUR", + "doc": { + "category": "cell_build", + "description": "Equivalent to `SWAP` `[cc+1] STU`.", + "gas": "34", + "fift": "[cc+1] STUR" + }, + "bytecode": { + "doc_opcode": "CF0Bcc", + "tlb": "#CF0B cc:uint8", + "prefix": "CF0B", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b x - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STIQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STI`.", + "gas": "34", + "fift": "[cc+1] STIQ" + }, + "bytecode": { + "doc_opcode": "CF0Ccc", + "tlb": "#CF0C cc:uint8", + "prefix": "CF0C", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - x b f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STUQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STU`.", + "gas": "34", + "fift": "[cc+1] STUQ" + }, + "bytecode": { + "doc_opcode": "CF0Dcc", + "tlb": "#CF0D cc:uint8", + "prefix": "CF0D", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "x b - x b f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STIRQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STIR`.", + "gas": "34", + "fift": "[cc+1] STIRQ" + }, + "bytecode": { + "doc_opcode": "CF0Ecc", + "tlb": "#CF0E cc:uint8", + "prefix": "CF0E", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b x - b x f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STURQ", + "doc": { + "category": "cell_build", + "description": "A quiet version of `STUR`.", + "gas": "34", + "fift": "[cc+1] STURQ" + }, + "bytecode": { + "doc_opcode": "CF0Fcc", + "tlb": "#CF0F cc:uint8", + "prefix": "CF0F", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b x - b x f or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + { + "value": 1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STREF_ALT", + "doc": { + "category": "cell_build", + "description": "A longer version of `STREF`.", + "gas": "26", + "fift": "STREF_l" + }, + "bytecode": { + "doc_opcode": "CF10", + "tlb": "#CF10", + "prefix": "CF10", + "operands": [] + }, + "value_flow": { + "doc_stack": "c b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STBREF", + "doc": { + "category": "cell_build", + "description": "Equivalent to `SWAP` `STBREFR`.", + "gas": "526", + "fift": "STBREF" + }, + "bytecode": { + "doc_opcode": "CF11", + "tlb": "#CF11", + "prefix": "CF11", + "operands": [] + }, + "value_flow": { + "doc_stack": "b' b - b''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "child", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STSLICE_ALT", + "doc": { + "category": "cell_build", + "description": "A longer version of `STSLICE`.", + "gas": "26", + "fift": "STSLICE_l" + }, + "bytecode": { + "doc_opcode": "CF12", + "tlb": "#CF12", + "prefix": "CF12", + "operands": [] + }, + "value_flow": { + "doc_stack": "s b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STB", + "doc": { + "category": "cell_build", + "description": "Appends all data from _Builder_ `b'` to _Builder_ `b`.", + "gas": "26", + "fift": "STB" + }, + "bytecode": { + "doc_opcode": "CF13", + "tlb": "#CF13", + "prefix": "CF13", + "operands": [] + }, + "value_flow": { + "doc_stack": "b' b - b''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STREFR", + "doc": { + "category": "cell_build", + "description": "Equivalent to `SWAP` `STREF`.", + "gas": "26", + "fift": "STREFR" + }, + "bytecode": { + "doc_opcode": "CF14", + "tlb": "#CF14", + "prefix": "CF14", + "operands": [] + }, + "value_flow": { + "doc_stack": "b c - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STBREFR_ALT", + "doc": { + "category": "cell_build", + "description": "A longer encoding of `STBREFR`.", + "gas": "526", + "fift": "STBREFR_l" + }, + "bytecode": { + "doc_opcode": "CF15", + "tlb": "#CF15", + "prefix": "CF15", + "operands": [] + }, + "value_flow": { + "doc_stack": "b b' - b''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STSLICER", + "doc": { + "category": "cell_build", + "description": "Equivalent to `SWAP` `STSLICE`.", + "gas": "26", + "fift": "STSLICER" + }, + "bytecode": { + "doc_opcode": "CF16", + "tlb": "#CF16", + "prefix": "CF16", + "operands": [] + }, + "value_flow": { + "doc_stack": "b s - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STBR", + "doc": { + "category": "cell_build", + "description": "Concatenates two builders.\nEquivalent to `SWAP` `STB`.", + "gas": "26", + "fift": "STBR\nBCONCAT" + }, + "bytecode": { + "doc_opcode": "CF17", + "tlb": "#CF17", + "prefix": "CF17", + "operands": [] + }, + "value_flow": { + "doc_stack": "b b' - b''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STREFQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STREF`.", + "gas": "26", + "fift": "STREFQ" + }, + "bytecode": { + "doc_opcode": "CF18", + "tlb": "#CF18", + "prefix": "CF18", + "operands": [] + }, + "value_flow": { + "doc_stack": "c b - c b -1 or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STBREFQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STBREF`.", + "gas": "526", + "fift": "STBREFQ" + }, + "bytecode": { + "doc_opcode": "CF19", + "tlb": "#CF19", + "prefix": "CF19", + "operands": [] + }, + "value_flow": { + "doc_stack": "b' b - b' b -1 or b'' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STSLICEQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STSLICE`.", + "gas": "26", + "fift": "STSLICEQ" + }, + "bytecode": { + "doc_opcode": "CF1A", + "tlb": "#CF1A", + "prefix": "CF1A", + "operands": [] + }, + "value_flow": { + "doc_stack": "s b - s b -1 or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STBQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STB`.", + "gas": "26", + "fift": "STBQ" + }, + "bytecode": { + "doc_opcode": "CF1B", + "tlb": "#CF1B", + "prefix": "CF1B", + "operands": [] + }, + "value_flow": { + "doc_stack": "b' b - b' b -1 or b'' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STREFRQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STREFR`.", + "gas": "26", + "fift": "STREFRQ" + }, + "bytecode": { + "doc_opcode": "CF1C", + "tlb": "#CF1C", + "prefix": "CF1C", + "operands": [] + }, + "value_flow": { + "doc_stack": "b c - b c -1 or b' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STBREFRQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STBREFR`.", + "gas": "526", + "fift": "STBREFRQ" + }, + "bytecode": { + "doc_opcode": "CF1D", + "tlb": "#CF1D", + "prefix": "CF1D", + "operands": [] + }, + "value_flow": { + "doc_stack": "b b' - b b' -1 or b'' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STSLICERQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STSLICER`.", + "gas": "26", + "fift": "STSLICERQ" + }, + "bytecode": { + "doc_opcode": "CF1E", + "tlb": "#CF1E", + "prefix": "CF1E", + "operands": [] + }, + "value_flow": { + "doc_stack": "b s - b s -1 or b'' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STBRQ", + "doc": { + "category": "cell_build", + "description": "Quiet version of `STBR`.", + "gas": "26", + "fift": "STBRQ\nBCONCATQ" + }, + "bytecode": { + "doc_opcode": "CF1F", + "tlb": "#CF1F", + "prefix": "CF1F", + "operands": [] + }, + "value_flow": { + "doc_stack": "b b' - b b' -1 or b'' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "b3", + "value_types": ["Builder"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STREFCONST", + "doc": { + "category": "cell_build", + "description": "Equivalent to `PUSHREF` `STREFR`.", + "gas": "26", + "fift": "[ref] STREFCONST" + }, + "bytecode": { + "doc_opcode": "CF20", + "tlb": "#CF20 c:^Cell", + "prefix": "CF20", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "b - b\u0432\u0402\u2122", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STREF2CONST", + "doc": { + "category": "cell_build", + "description": "Equivalent to `STREFCONST` `STREFCONST`.", + "gas": "26", + "fift": "[ref] [ref] STREF2CONST" + }, + "bytecode": { + "doc_opcode": "CF21", + "tlb": "#CF21 c1:^Cell c2:^Cell", + "prefix": "CF21", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - b\u0432\u0402\u2122", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "ENDXC", + "doc": { + "category": "cell_build", + "description": "If `x!=0`, creates a _special_ or _exotic_ cell from _Builder_ `b`.\nThe type of the exotic cell must be stored in the first 8 bits of `b`.\nIf `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.", + "gas": "526", + "fift": "" + }, + "bytecode": { + "doc_opcode": "CF23", + "tlb": "#CF23", + "prefix": "CF23", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "STILE4", + "doc": { + "category": "cell_build", + "description": "Stores a little-endian signed 32-bit integer.", + "gas": "26", + "fift": "STILE4" + }, + "bytecode": { + "doc_opcode": "CF28", + "tlb": "#CF28", + "prefix": "CF28", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STULE4", + "doc": { + "category": "cell_build", + "description": "Stores a little-endian unsigned 32-bit integer.", + "gas": "26", + "fift": "STULE4" + }, + "bytecode": { + "doc_opcode": "CF29", + "tlb": "#CF29", + "prefix": "CF29", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STILE8", + "doc": { + "category": "cell_build", + "description": "Stores a little-endian signed 64-bit integer.", + "gas": "26", + "fift": "STILE8" + }, + "bytecode": { + "doc_opcode": "CF2A", + "tlb": "#CF2A", + "prefix": "CF2A", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STULE8", + "doc": { + "category": "cell_build", + "description": "Stores a little-endian unsigned 64-bit integer.", + "gas": "26", + "fift": "STULE8" + }, + "bytecode": { + "doc_opcode": "CF2B", + "tlb": "#CF2B", + "prefix": "CF2B", + "operands": [] + }, + "value_flow": { + "doc_stack": "x b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "BDEPTH", + "doc": { + "category": "cell_build", + "description": "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`.", + "gas": "26", + "fift": "BDEPTH" + }, + "bytecode": { + "doc_opcode": "CF30", + "tlb": "#CF30", + "prefix": "CF30", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BBITS", + "doc": { + "category": "cell_build", + "description": "Returns the number of data bits already stored in _Builder_ `b`.", + "gas": "26", + "fift": "BBITS" + }, + "bytecode": { + "doc_opcode": "CF31", + "tlb": "#CF31", + "prefix": "CF31", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BREFS", + "doc": { + "category": "cell_build", + "description": "Returns the number of cell references already stored in `b`.", + "gas": "26", + "fift": "BREFS" + }, + "bytecode": { + "doc_opcode": "CF32", + "tlb": "#CF32", + "prefix": "CF32", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BBITREFS", + "doc": { + "category": "cell_build", + "description": "Returns the numbers of both data bits and cell references in `b`.", + "gas": "26", + "fift": "BBITREFS" + }, + "bytecode": { + "doc_opcode": "CF33", + "tlb": "#CF33", + "prefix": "CF33", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BREMBITS", + "doc": { + "category": "cell_build", + "description": "Returns the number of data bits that can still be stored in `b`.", + "gas": "26", + "fift": "BREMBITS" + }, + "bytecode": { + "doc_opcode": "CF35", + "tlb": "#CF35", + "prefix": "CF35", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - x'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BREMREFS", + "doc": { + "category": "cell_build", + "description": "Returns the number of references that can still be stored in `b`.", + "gas": "26", + "fift": "BREMREFS" + }, + "bytecode": { + "doc_opcode": "CF36", + "tlb": "#CF36", + "prefix": "CF36", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - y'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "y2", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BREMBITREFS", + "doc": { + "category": "cell_build", + "description": "Returns the numbers of both data bits and references that can still be stored in `b`.", + "gas": "26", + "fift": "BREMBITREFS" + }, + "bytecode": { + "doc_opcode": "CF37", + "tlb": "#CF37", + "prefix": "CF37", + "operands": [] + }, + "value_flow": { + "doc_stack": "b - x' y'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y2", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BCHKBITS", + "doc": { + "category": "cell_build", + "description": "Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.", + "gas": "34/84", + "fift": "[cc+1] BCHKBITS#" + }, + "bytecode": { + "doc_opcode": "CF38cc", + "tlb": "#CF38 cc:uint8", + "prefix": "CF38", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "BCHKBITS_VAR", + "doc": { + "category": "cell_build", + "description": "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.", + "gas": "26/76", + "fift": "BCHKBITS" + }, + "bytecode": { + "doc_opcode": "CF39", + "tlb": "#CF39", + "prefix": "CF39", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "BCHKREFS", + "doc": { + "category": "cell_build", + "description": "Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.", + "gas": "26/76", + "fift": "BCHKREFS" + }, + "bytecode": { + "doc_opcode": "CF3A", + "tlb": "#CF3A", + "prefix": "CF3A", + "operands": [] + }, + "value_flow": { + "doc_stack": "b y - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "BCHKBITREFS", + "doc": { + "category": "cell_build", + "description": "Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.", + "gas": "26/76", + "fift": "BCHKBITREFS" + }, + "bytecode": { + "doc_opcode": "CF3B", + "tlb": "#CF3B", + "prefix": "CF3B", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x y - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "BCHKBITSQ", + "doc": { + "category": "cell_build", + "description": "Checks whether `cc+1` bits can be stored into `b`, where `0 <= cc <= 255`.", + "gas": "34", + "fift": "[cc+1] BCHKBITSQ#" + }, + "bytecode": { + "doc_opcode": "CF3Ccc", + "tlb": "#CF3C cc:uint8", + "prefix": "CF3C", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "b - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BCHKBITSQ_VAR", + "doc": { + "category": "cell_build", + "description": "Checks whether `x` bits can be stored into `b`, `0 <= x <= 1023`.", + "gas": "26", + "fift": "BCHKBITSQ" + }, + "bytecode": { + "doc_opcode": "CF3D", + "tlb": "#CF3D", + "prefix": "CF3D", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BCHKREFSQ", + "doc": { + "category": "cell_build", + "description": "Checks whether `y` references can be stored into `b`, `0 <= y <= 7`.", + "gas": "26", + "fift": "BCHKREFSQ" + }, + "bytecode": { + "doc_opcode": "CF3E", + "tlb": "#CF3E", + "prefix": "CF3E", + "operands": [] + }, + "value_flow": { + "doc_stack": "b y - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "BCHKBITREFSQ", + "doc": { + "category": "cell_build", + "description": "Checks whether `x` bits and `y` references can be stored into `b`, `0 <= x <= 1023`, `0 <= y <= 7`.", + "gas": "26", + "fift": "BCHKBITREFSQ" + }, + "bytecode": { + "doc_opcode": "CF3F", + "tlb": "#CF3F", + "prefix": "CF3F", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x y - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "STZEROES", + "doc": { + "category": "cell_build", + "description": "Stores `n` binary zeroes into _Builder_ `b`.", + "gas": "26", + "fift": "STZEROES" + }, + "bytecode": { + "doc_opcode": "CF40", + "tlb": "#CF40", + "prefix": "CF40", + "operands": [] + }, + "value_flow": { + "doc_stack": "b n - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STONES", + "doc": { + "category": "cell_build", + "description": "Stores `n` binary ones into _Builder_ `b`.", + "gas": "26", + "fift": "STONES" + }, + "bytecode": { + "doc_opcode": "CF41", + "tlb": "#CF41", + "prefix": "CF41", + "operands": [] + }, + "value_flow": { + "doc_stack": "b n - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STSAME", + "doc": { + "category": "cell_build", + "description": "Stores `n` binary `x`es (`0 <= x <= 1`) into _Builder_ `b`.", + "gas": "26", + "fift": "STSAME" + }, + "bytecode": { + "doc_opcode": "CF42", + "tlb": "#CF42", + "prefix": "CF42", + "operands": [] + }, + "value_flow": { + "doc_stack": "b n x - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STSLICECONST", + "doc": { + "category": "cell_build", + "description": "Stores a constant subslice `sss`.\n_Details:_ `sss` consists of `0 <= x <= 3` references and up to `8y+2` data bits, with `0 <= y <= 7`. Completion bit is assumed.\nNote that the assembler can replace `STSLICECONST` with `PUSHSLICE` `STSLICER` if the slice is too big.", + "gas": "24", + "fift": "[slice] STSLICECONST" + }, + "bytecode": { + "doc_opcode": "CFC0_xysss", + "tlb": "#CFC0_ x:(## 2) y:(## 3) c:(x * ^Cell) sss:((8 * y + 2) * Bit)", + "prefix": "CFC0_", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 2 + } + }, + { + "name": "y", + "loader": "uint", + "loader_args": { + "size": 3 + } + }, + { + "name": "sss", + "loader": "subslice", + "loader_args": { + "bits_length_var": "y", + "bits_padding": 2, + "refs_length_var": "x", + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "CTOS", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "118/43", + "fift": "CTOS" + }, + "bytecode": { + "doc_opcode": "D0", + "tlb": "#D0", + "prefix": "D0", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - s", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "ENDS", + "doc": { + "category": "cell_parse", + "description": "Removes a _Slice_ `s` from the stack, and throws an exception if it is not empty.", + "gas": "18/68", + "fift": "ENDS" + }, + "bytecode": { + "doc_opcode": "D1", + "tlb": "#D1", + "prefix": "D1", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "LDI", + "doc": { + "category": "cell_parse", + "description": "Loads (i.e., parses) a signed `cc+1`-bit integer `x` from _Slice_ `s`, and returns the remainder of `s` as `s'`.", + "gas": "26", + "fift": "[cc+1] LDI" + }, + "bytecode": { + "doc_opcode": "D2cc", + "tlb": "#D2 cc:uint8", + "prefix": "D2", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDU", + "doc": { + "category": "cell_parse", + "description": "Loads an unsigned `cc+1`-bit integer `x` from _Slice_ `s`.", + "gas": "26", + "fift": "[cc+1] LDU" + }, + "bytecode": { + "doc_opcode": "D3cc", + "tlb": "#D3 cc:uint8", + "prefix": "D3", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDREF", + "doc": { + "category": "cell_parse", + "description": "Loads a cell reference `c` from `s`.", + "gas": "18", + "fift": "LDREF" + }, + "bytecode": { + "doc_opcode": "D4", + "tlb": "#D4", + "prefix": "D4", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - c s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDREFRTOS", + "doc": { + "category": "cell_parse", + "description": "Equivalent to `LDREF` `SWAP` `CTOS`.", + "gas": "118/43", + "fift": "LDREFRTOS" + }, + "bytecode": { + "doc_opcode": "D5", + "tlb": "#D5", + "prefix": "D5", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s' s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDSLICE", + "doc": { + "category": "cell_parse", + "description": "Cuts the next `cc+1` bits of `s` into a separate _Slice_ `s''`.", + "gas": "26", + "fift": "[cc+1] LDSLICE" + }, + "bytecode": { + "doc_opcode": "D6cc", + "tlb": "#D6 cc:uint8", + "prefix": "D6", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s'' s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDIX", + "doc": { + "category": "cell_parse", + "description": "Loads a signed `l`-bit (`0 <= l <= 257`) integer `x` from _Slice_ `s`, and returns the remainder of `s` as `s'`.", + "gas": "26", + "fift": "LDIX" + }, + "bytecode": { + "doc_opcode": "D700", + "tlb": "#D700", + "prefix": "D700", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDUX", + "doc": { + "category": "cell_parse", + "description": "Loads an unsigned `l`-bit integer `x` from (the first `l` bits of) `s`, with `0 <= l <= 256`.", + "gas": "26", + "fift": "LDUX" + }, + "bytecode": { + "doc_opcode": "D701", + "tlb": "#D701", + "prefix": "D701", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDIX", + "doc": { + "category": "cell_parse", + "description": "Preloads a signed `l`-bit integer from _Slice_ `s`, for `0 <= l <= 257`.", + "gas": "26", + "fift": "PLDIX" + }, + "bytecode": { + "doc_opcode": "D702", + "tlb": "#D702", + "prefix": "D702", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDUX", + "doc": { + "category": "cell_parse", + "description": "Preloads an unsigned `l`-bit integer from `s`, for `0 <= l <= 256`.", + "gas": "26", + "fift": "PLDUX" + }, + "bytecode": { + "doc_opcode": "D703", + "tlb": "#D703", + "prefix": "D703", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDIXQ", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "26", + "fift": "LDIXQ" + }, + "bytecode": { + "doc_opcode": "D704", + "tlb": "#D704", + "prefix": "D704", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDUXQ", + "doc": { + "category": "cell_parse", + "description": "Quiet version of `LDUX`.", + "gas": "26", + "fift": "LDUXQ" + }, + "bytecode": { + "doc_opcode": "D705", + "tlb": "#D705", + "prefix": "D705", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDIXQ", + "doc": { + "category": "cell_parse", + "description": "Quiet version of `PLDIX`.", + "gas": "26", + "fift": "PLDIXQ" + }, + "bytecode": { + "doc_opcode": "D706", + "tlb": "#D706", + "prefix": "D706", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDUXQ", + "doc": { + "category": "cell_parse", + "description": "Quiet version of `PLDUX`.", + "gas": "26", + "fift": "PLDUXQ" + }, + "bytecode": { + "doc_opcode": "D707", + "tlb": "#D707", + "prefix": "D707", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDI_ALT", + "doc": { + "category": "cell_parse", + "description": "A longer encoding for `LDI`.", + "gas": "34", + "fift": "[cc+1] LDI_l" + }, + "bytecode": { + "doc_opcode": "D708cc", + "tlb": "#D708 cc:uint8", + "prefix": "D708", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDU_ALT", + "doc": { + "category": "cell_parse", + "description": "A longer encoding for `LDU`.", + "gas": "34", + "fift": "[cc+1] LDU_l" + }, + "bytecode": { + "doc_opcode": "D709cc", + "tlb": "#D709 cc:uint8", + "prefix": "D709", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDI", + "doc": { + "category": "cell_parse", + "description": "Preloads a signed `cc+1`-bit integer from _Slice_ `s`.", + "gas": "34", + "fift": "[cc+1] PLDI" + }, + "bytecode": { + "doc_opcode": "D70Acc", + "tlb": "#D70A cc:uint8", + "prefix": "D70A", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDU", + "doc": { + "category": "cell_parse", + "description": "Preloads an unsigned `cc+1`-bit integer from `s`.", + "gas": "34", + "fift": "[cc+1] PLDU" + }, + "bytecode": { + "doc_opcode": "D70Bcc", + "tlb": "#D70B cc:uint8", + "prefix": "D70B", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDIQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `LDI`.", + "gas": "34", + "fift": "[cc+1] LDIQ" + }, + "bytecode": { + "doc_opcode": "D70Ccc", + "tlb": "#D70C cc:uint8", + "prefix": "D70C", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDUQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `LDU`.", + "gas": "34", + "fift": "[cc+1] LDUQ" + }, + "bytecode": { + "doc_opcode": "D70Dcc", + "tlb": "#D70D cc:uint8", + "prefix": "D70D", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDIQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `PLDI`.", + "gas": "34", + "fift": "[cc+1] PLDIQ" + }, + "bytecode": { + "doc_opcode": "D70Ecc", + "tlb": "#D70E cc:uint8", + "prefix": "D70E", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDUQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `PLDU`.", + "gas": "34", + "fift": "[cc+1] PLDUQ" + }, + "bytecode": { + "doc_opcode": "D70Fcc", + "tlb": "#D70F cc:uint8", + "prefix": "D70F", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDUZ", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "26", + "fift": "[32(c+1)] PLDUZ" + }, + "bytecode": { + "doc_opcode": "D714_c", + "tlb": "#D714_ c:uint3", + "prefix": "D714_", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 3 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDSLICEX", + "doc": { + "category": "cell_parse", + "description": "Loads the first `0 <= l <= 1023` bits from _Slice_ `s` into a separate _Slice_ `s''`, returning the remainder of `s` as `s'`.", + "gas": "26", + "fift": "LDSLICEX" + }, + "bytecode": { + "doc_opcode": "D718", + "tlb": "#D718", + "prefix": "D718", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'' s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDSLICEX", + "doc": { + "category": "cell_parse", + "description": "Returns the first `0 <= l <= 1023` bits of `s` as `s''`.", + "gas": "26", + "fift": "PLDSLICEX" + }, + "bytecode": { + "doc_opcode": "D719", + "tlb": "#D719", + "prefix": "D719", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDSLICEXQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `LDSLICEX`.", + "gas": "26", + "fift": "LDSLICEXQ" + }, + "bytecode": { + "doc_opcode": "D71A", + "tlb": "#D71A", + "prefix": "D71A", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'' s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDSLICEXQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `LDSLICEXQ`.", + "gas": "26", + "fift": "PLDSLICEXQ" + }, + "bytecode": { + "doc_opcode": "D71B", + "tlb": "#D71B", + "prefix": "D71B", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDSLICE_ALT", + "doc": { + "category": "cell_parse", + "description": "A longer encoding for `LDSLICE`.", + "gas": "34", + "fift": "[cc+1] LDSLICE_l" + }, + "bytecode": { + "doc_opcode": "D71Ccc", + "tlb": "#D71C cc:uint8", + "prefix": "D71C", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s'' s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDSLICE", + "doc": { + "category": "cell_parse", + "description": "Returns the first `0 < cc+1 <= 256` bits of `s` as `s''`.", + "gas": "34", + "fift": "[cc+1] PLDSLICE" + }, + "bytecode": { + "doc_opcode": "D71Dcc", + "tlb": "#D71D cc:uint8", + "prefix": "D71D", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDSLICEQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `LDSLICE`.", + "gas": "34", + "fift": "[cc+1] LDSLICEQ" + }, + "bytecode": { + "doc_opcode": "D71Ecc", + "tlb": "#D71E cc:uint8", + "prefix": "D71E", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s'' s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDSLICEQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `PLDSLICE`.", + "gas": "34", + "fift": "[cc+1] PLDSLICEQ" + }, + "bytecode": { + "doc_opcode": "D71Fcc", + "tlb": "#D71F cc:uint8", + "prefix": "D71F", + "operands": [ + { + "name": "c", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s'' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDCUTFIRST", + "doc": { + "category": "cell_parse", + "description": "Returns the first `0 <= l <= 1023` bits of `s`. It is equivalent to `PLDSLICEX`.", + "gas": "26", + "fift": "SDCUTFIRST" + }, + "bytecode": { + "doc_opcode": "D720", + "tlb": "#D720", + "prefix": "D720", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDSKIPFIRST", + "doc": { + "category": "cell_parse", + "description": "Returns all but the first `0 <= l <= 1023` bits of `s`. It is equivalent to `LDSLICEX` `NIP`.", + "gas": "26", + "fift": "SDSKIPFIRST" + }, + "bytecode": { + "doc_opcode": "D721", + "tlb": "#D721", + "prefix": "D721", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDCUTLAST", + "doc": { + "category": "cell_parse", + "description": "Returns the last `0 <= l <= 1023` bits of `s`.", + "gas": "26", + "fift": "SDCUTLAST" + }, + "bytecode": { + "doc_opcode": "D722", + "tlb": "#D722", + "prefix": "D722", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDSKIPLAST", + "doc": { + "category": "cell_parse", + "description": "Returns all but the last `0 <= l <= 1023` bits of `s`.", + "gas": "26", + "fift": "SDSKIPLAST" + }, + "bytecode": { + "doc_opcode": "D723", + "tlb": "#D723", + "prefix": "D723", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDSUBSTR", + "doc": { + "category": "cell_parse", + "description": "Returns `0 <= l' <= 1023` bits of `s` starting from offset `0 <= l <= 1023`, thus extracting a bit substring out of the data of `s`.", + "gas": "26", + "fift": "SDSUBSTR" + }, + "bytecode": { + "doc_opcode": "D724", + "tlb": "#D724", + "prefix": "D724", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l l' - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l2", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDBEGINSX", + "doc": { + "category": "cell_parse", + "description": "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`.", + "gas": "26", + "fift": "SDBEGINSX" + }, + "bytecode": { + "doc_opcode": "D726", + "tlb": "#D726", + "prefix": "D726", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDBEGINSXQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `SDBEGINSX`.", + "gas": "26", + "fift": "SDBEGINSXQ" + }, + "bytecode": { + "doc_opcode": "D727", + "tlb": "#D727", + "prefix": "D727", + "operands": [] + }, + "value_flow": { + "doc_stack": "s s' - s'' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDBEGINS", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "31", + "fift": "[slice] SDBEGINS" + }, + "bytecode": { + "doc_opcode": "D72A_xsss", + "tlb": "#D72A_ x:(## 7) sss:((8 * x + 3) * Bit)", + "prefix": "D72A_", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 7 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 3, + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDBEGINSQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `SDBEGINS`.", + "gas": "31", + "fift": "[slice] SDBEGINSQ" + }, + "bytecode": { + "doc_opcode": "D72E_xsss", + "tlb": "#D72E_ x:(## 7) sss:((8 * x + 3) * Bit)", + "prefix": "D72E_", + "operands": [ + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 7 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 3, + "completion_tag": true + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s'' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SCUTFIRST", + "doc": { + "category": "cell_parse", + "description": "Returns the first `0 <= l <= 1023` bits and first `0 <= r <= 4` references of `s`.", + "gas": "26", + "fift": "SCUTFIRST" + }, + "bytecode": { + "doc_opcode": "D730", + "tlb": "#D730", + "prefix": "D730", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SSKIPFIRST", + "doc": { + "category": "cell_parse", + "description": "Returns all but the first `l` bits of `s` and `r` references of `s`.", + "gas": "26", + "fift": "SSKIPFIRST" + }, + "bytecode": { + "doc_opcode": "D731", + "tlb": "#D731", + "prefix": "D731", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SCUTLAST", + "doc": { + "category": "cell_parse", + "description": "Returns the last `0 <= l <= 1023` data bits and last `0 <= r <= 4` references of `s`.", + "gas": "26", + "fift": "SCUTLAST" + }, + "bytecode": { + "doc_opcode": "D732", + "tlb": "#D732", + "prefix": "D732", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SSKIPLAST", + "doc": { + "category": "cell_parse", + "description": "Returns all but the last `l` bits of `s` and `r` references of `s`.", + "gas": "26", + "fift": "SSKIPLAST" + }, + "bytecode": { + "doc_opcode": "D733", + "tlb": "#D733", + "prefix": "D733", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SUBSLICE", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "26", + "fift": "SUBSLICE" + }, + "bytecode": { + "doc_opcode": "D734", + "tlb": "#D734", + "prefix": "D734", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r l' r' - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l2", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r2", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SPLIT", + "doc": { + "category": "cell_parse", + "description": "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''`.", + "gas": "26", + "fift": "SPLIT" + }, + "bytecode": { + "doc_opcode": "D736", + "tlb": "#D736", + "prefix": "D736", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s' s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SPLITQ", + "doc": { + "category": "cell_parse", + "description": "A quiet version of `SPLIT`.", + "gas": "26", + "fift": "SPLITQ" + }, + "bytecode": { + "doc_opcode": "D737", + "tlb": "#D737", + "prefix": "D737", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - s' s'' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "XCTOS", + "doc": { + "category": "cell_parse", + "description": "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`.", + "gas": "", + "fift": "" + }, + "bytecode": { + "doc_opcode": "D739", + "tlb": "#D739", + "prefix": "D739", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - s ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "flag", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "XLOAD", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "", + "fift": "" + }, + "bytecode": { + "doc_opcode": "D73A", + "tlb": "#D73A", + "prefix": "D73A", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "XLOADQ", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "", + "fift": "" + }, + "bytecode": { + "doc_opcode": "D73B", + "tlb": "#D73B", + "prefix": "D73B", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - c' -1 or c 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SCHKBITS", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "26/76", + "fift": "SCHKBITS" + }, + "bytecode": { + "doc_opcode": "D741", + "tlb": "#D741", + "prefix": "D741", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SCHKREFS", + "doc": { + "category": "cell_parse", + "description": "Checks whether there are at least `r` references in _Slice_ `s`.", + "gas": "26/76", + "fift": "SCHKREFS" + }, + "bytecode": { + "doc_opcode": "D742", + "tlb": "#D742", + "prefix": "D742", + "operands": [] + }, + "value_flow": { + "doc_stack": "s r - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SCHKBITREFS", + "doc": { + "category": "cell_parse", + "description": "Checks whether there are at least `l` data bits and `r` references in _Slice_ `s`.", + "gas": "26/76", + "fift": "SCHKBITREFS" + }, + "bytecode": { + "doc_opcode": "D743", + "tlb": "#D743", + "prefix": "D743", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SCHKBITSQ", + "doc": { + "category": "cell_parse", + "description": "Checks whether there are at least `l` data bits in _Slice_ `s`.", + "gas": "26", + "fift": "SCHKBITSQ" + }, + "bytecode": { + "doc_opcode": "D745", + "tlb": "#D745", + "prefix": "D745", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SCHKREFSQ", + "doc": { + "category": "cell_parse", + "description": "Checks whether there are at least `r` references in _Slice_ `s`.", + "gas": "26", + "fift": "SCHKREFSQ" + }, + "bytecode": { + "doc_opcode": "D746", + "tlb": "#D746", + "prefix": "D746", + "operands": [] + }, + "value_flow": { + "doc_stack": "s r - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SCHKBITREFSQ", + "doc": { + "category": "cell_parse", + "description": "Checks whether there are at least `l` data bits and `r` references in _Slice_ `s`.", + "gas": "26", + "fift": "SCHKBITREFSQ" + }, + "bytecode": { + "doc_opcode": "D747", + "tlb": "#D747", + "prefix": "D747", + "operands": [] + }, + "value_flow": { + "doc_stack": "s l r - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDREFVAR", + "doc": { + "category": "cell_parse", + "description": "Returns the `n`-th cell reference of _Slice_ `s` for `0 <= n <= 3`.", + "gas": "26", + "fift": "PLDREFVAR" + }, + "bytecode": { + "doc_opcode": "D748", + "tlb": "#D748", + "prefix": "D748", + "operands": [] + }, + "value_flow": { + "doc_stack": "s n - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "SBITS", + "doc": { + "category": "cell_parse", + "description": "Returns the number of data bits in _Slice_ `s`.", + "gas": "26", + "fift": "SBITS" + }, + "bytecode": { + "doc_opcode": "D749", + "tlb": "#D749", + "prefix": "D749", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - l", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SREFS", + "doc": { + "category": "cell_parse", + "description": "Returns the number of references in _Slice_ `s`.", + "gas": "26", + "fift": "SREFS" + }, + "bytecode": { + "doc_opcode": "D74A", + "tlb": "#D74A", + "prefix": "D74A", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SBITREFS", + "doc": { + "category": "cell_parse", + "description": "Returns both the number of data bits and the number of references in `s`.", + "gas": "26", + "fift": "SBITREFS" + }, + "bytecode": { + "doc_opcode": "D74B", + "tlb": "#D74B", + "prefix": "D74B", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - l r", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDREFIDX", + "doc": { + "category": "cell_parse", + "description": "Returns the `n`-th cell reference of _Slice_ `s`, where `0 <= n <= 3`.", + "gas": "26", + "fift": "[n] PLDREFIDX" + }, + "bytecode": { + "doc_opcode": "D74E_n", + "tlb": "#D74E_ n:uint2", + "prefix": "D74E_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 2 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + } + }, + { + "mnemonic": "LDILE4", + "doc": { + "category": "cell_parse", + "description": "Loads a little-endian signed 32-bit integer.", + "gas": "26", + "fift": "LDILE4" + }, + "bytecode": { + "doc_opcode": "D750", + "tlb": "#D750", + "prefix": "D750", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDULE4", + "doc": { + "category": "cell_parse", + "description": "Loads a little-endian unsigned 32-bit integer.", + "gas": "26", + "fift": "LDULE4" + }, + "bytecode": { + "doc_opcode": "D751", + "tlb": "#D751", + "prefix": "D751", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDILE8", + "doc": { + "category": "cell_parse", + "description": "Loads a little-endian signed 64-bit integer.", + "gas": "26", + "fift": "LDILE8" + }, + "bytecode": { + "doc_opcode": "D752", + "tlb": "#D752", + "prefix": "D752", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDULE8", + "doc": { + "category": "cell_parse", + "description": "Loads a little-endian unsigned 64-bit integer.", + "gas": "26", + "fift": "LDULE8" + }, + "bytecode": { + "doc_opcode": "D753", + "tlb": "#D753", + "prefix": "D753", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDILE4", + "doc": { + "category": "cell_parse", + "description": "Preloads a little-endian signed 32-bit integer.", + "gas": "26", + "fift": "PLDILE4" + }, + "bytecode": { + "doc_opcode": "D754", + "tlb": "#D754", + "prefix": "D754", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDULE4", + "doc": { + "category": "cell_parse", + "description": "Preloads a little-endian unsigned 32-bit integer.", + "gas": "26", + "fift": "PLDULE4" + }, + "bytecode": { + "doc_opcode": "D755", + "tlb": "#D755", + "prefix": "D755", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDILE8", + "doc": { + "category": "cell_parse", + "description": "Preloads a little-endian signed 64-bit integer.", + "gas": "26", + "fift": "PLDILE8" + }, + "bytecode": { + "doc_opcode": "D756", + "tlb": "#D756", + "prefix": "D756", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDULE8", + "doc": { + "category": "cell_parse", + "description": "Preloads a little-endian unsigned 64-bit integer.", + "gas": "26", + "fift": "PLDULE8" + }, + "bytecode": { + "doc_opcode": "D757", + "tlb": "#D757", + "prefix": "D757", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDILE4Q", + "doc": { + "category": "cell_parse", + "description": "Quietly loads a little-endian signed 32-bit integer.", + "gas": "26", + "fift": "LDILE4Q" + }, + "bytecode": { + "doc_opcode": "D758", + "tlb": "#D758", + "prefix": "D758", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDULE4Q", + "doc": { + "category": "cell_parse", + "description": "Quietly loads a little-endian unsigned 32-bit integer.", + "gas": "26", + "fift": "LDULE4Q" + }, + "bytecode": { + "doc_opcode": "D759", + "tlb": "#D759", + "prefix": "D759", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDILE8Q", + "doc": { + "category": "cell_parse", + "description": "Quietly loads a little-endian signed 64-bit integer.", + "gas": "26", + "fift": "LDILE8Q" + }, + "bytecode": { + "doc_opcode": "D75A", + "tlb": "#D75A", + "prefix": "D75A", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDULE8Q", + "doc": { + "category": "cell_parse", + "description": "Quietly loads a little-endian unsigned 64-bit integer.", + "gas": "26", + "fift": "LDULE8Q" + }, + "bytecode": { + "doc_opcode": "D75B", + "tlb": "#D75B", + "prefix": "D75B", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDILE4Q", + "doc": { + "category": "cell_parse", + "description": "Quietly preloads a little-endian signed 32-bit integer.", + "gas": "26", + "fift": "PLDILE4Q" + }, + "bytecode": { + "doc_opcode": "D75C", + "tlb": "#D75C", + "prefix": "D75C", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDULE4Q", + "doc": { + "category": "cell_parse", + "description": "Quietly preloads a little-endian unsigned 32-bit integer.", + "gas": "26", + "fift": "PLDULE4Q" + }, + "bytecode": { + "doc_opcode": "D75D", + "tlb": "#D75D", + "prefix": "D75D", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDILE8Q", + "doc": { + "category": "cell_parse", + "description": "Quietly preloads a little-endian signed 64-bit integer.", + "gas": "26", + "fift": "PLDILE8Q" + }, + "bytecode": { + "doc_opcode": "D75E", + "tlb": "#D75E", + "prefix": "D75E", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDULE8Q", + "doc": { + "category": "cell_parse", + "description": "Quietly preloads a little-endian unsigned 64-bit integer.", + "gas": "26", + "fift": "PLDULE8Q" + }, + "bytecode": { + "doc_opcode": "D75F", + "tlb": "#D75F", + "prefix": "D75F", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDZEROES", + "doc": { + "category": "cell_parse", + "description": "Returns the count `n` of leading zero bits in `s`, and removes these bits from `s`.", + "gas": "26", + "fift": "LDZEROES" + }, + "bytecode": { + "doc_opcode": "D760", + "tlb": "#D760", + "prefix": "D760", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDONES", + "doc": { + "category": "cell_parse", + "description": "Returns the count `n` of leading one bits in `s`, and removes these bits from `s`.", + "gas": "26", + "fift": "LDONES" + }, + "bytecode": { + "doc_opcode": "D761", + "tlb": "#D761", + "prefix": "D761", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - n s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDSAME", + "doc": { + "category": "cell_parse", + "description": "Returns the count `n` of leading bits equal to `0 <= x <= 1` in `s`, and removes these bits from `s`.", + "gas": "26", + "fift": "LDSAME" + }, + "bytecode": { + "doc_opcode": "D762", + "tlb": "#D762", + "prefix": "D762", + "operands": [] + }, + "value_flow": { + "doc_stack": "s x - n s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "SDEPTH", + "doc": { + "category": "cell_parse", + "description": "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`.", + "gas": "26", + "fift": "SDEPTH" + }, + "bytecode": { + "doc_opcode": "D764", + "tlb": "#D764", + "prefix": "D764", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CDEPTH", + "doc": { + "category": "cell_parse", + "description": "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.", + "gas": "26", + "fift": "CDEPTH" + }, + "bytecode": { + "doc_opcode": "D765", + "tlb": "#D765", + "prefix": "D765", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "EXECUTE", + "doc": { + "category": "cont_basic", + "description": "_Calls_, or _executes_, continuation `c`.", + "gas": "18", + "fift": "EXECUTE\nCALLX" + }, + "bytecode": { + "doc_opcode": "D8", + "tlb": "#D8", + "prefix": "D8", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPX", + "doc": { + "category": "cont_basic", + "description": "_Jumps_, or transfers control, to continuation `c`.\nThe remainder of the previous current continuation `cc` is discarded.", + "gas": "18", + "fift": "JMPX" + }, + "bytecode": { + "doc_opcode": "D9", + "tlb": "#D9", + "prefix": "D9", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLXARGS", + "doc": { + "category": "cont_basic", + "description": "_Calls_ continuation `c` with `p` parameters and expecting `r` return values\n`0 <= p <= 15`, `0 <= r <= 15`", + "gas": "26", + "fift": "[p] [r] CALLXARGS" + }, + "bytecode": { + "doc_opcode": "DApr", + "tlb": "#DA p:uint4 r:uint4", + "prefix": "DA", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLXARGS_VAR", + "doc": { + "category": "cont_basic", + "description": "_Calls_ continuation `c` with `0 <= p <= 15` parameters, expecting an arbitrary number of return values.", + "gas": "26", + "fift": "[p] -1 CALLXARGS" + }, + "bytecode": { + "doc_opcode": "DB0p", + "tlb": "#DB0 p:uint4", + "prefix": "DB0", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPXARGS", + "doc": { + "category": "cont_basic", + "description": "_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).", + "gas": "26", + "fift": "[p] JMPXARGS" + }, + "bytecode": { + "doc_opcode": "DB1p", + "tlb": "#DB1 p:uint4", + "prefix": "DB1", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "RETARGS", + "doc": { + "category": "cont_basic", + "description": "_Returns_ to `c0`, with `0 <= r <= 15` return values taken from the current stack.", + "gas": "26", + "fift": "[r] RETARGS" + }, + "bytecode": { + "doc_opcode": "DB2r", + "tlb": "#DB2 r:uint4", + "prefix": "DB2", + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "RET", + "doc": { + "category": "cont_basic", + "description": "_Returns_ to the continuation at `c0`. The remainder of the current continuation `cc` is discarded.\nApproximately equivalent to `c0 PUSHCTR` `JMPX`.", + "gas": "26", + "fift": "RET\nRETTRUE" + }, + "bytecode": { + "doc_opcode": "DB30", + "tlb": "#DB30", + "prefix": "DB30", + "operands": [] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "RETALT", + "doc": { + "category": "cont_basic", + "description": "_Returns_ to the continuation at `c1`.\nApproximately equivalent to `c1 PUSHCTR` `JMPX`.", + "gas": "26", + "fift": "RETALT\nRETFALSE" + }, + "bytecode": { + "doc_opcode": "DB31", + "tlb": "#DB31", + "prefix": "DB31", + "operands": [] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "BRANCH", + "doc": { + "category": "cont_basic", + "description": "Performs `RETTRUE` if integer `f!=0`, or `RETFALSE` if `f=0`.", + "gas": "26", + "fift": "BRANCH\nRETBOOL" + }, + "bytecode": { + "doc_opcode": "DB32", + "tlb": "#DB32", + "prefix": "DB32", + "operands": [] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLCC", + "doc": { + "category": "cont_basic", + "description": "_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`).", + "gas": "26", + "fift": "CALLCC" + }, + "bytecode": { + "doc_opcode": "DB34", + "tlb": "#DB34", + "prefix": "DB34", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPXDATA", + "doc": { + "category": "cont_basic", + "description": "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`.", + "gas": "26", + "fift": "JMPXDATA" + }, + "bytecode": { + "doc_opcode": "DB35", + "tlb": "#DB35", + "prefix": "DB35", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLCCARGS", + "doc": { + "category": "cont_basic", + "description": "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`.", + "gas": "34", + "fift": "[p] [r] CALLCCARGS" + }, + "bytecode": { + "doc_opcode": "DB36pr", + "tlb": "#DB36 p:uint4 r:uint4", + "prefix": "DB36", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLXVARARGS", + "doc": { + "category": "cont_basic", + "description": "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`.", + "gas": "26", + "fift": "CALLXVARARGS" + }, + "bytecode": { + "doc_opcode": "DB38", + "tlb": "#DB38", + "prefix": "DB38", + "operands": [] + }, + "value_flow": { + "doc_stack": "c p r - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "p", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "RETVARARGS", + "doc": { + "category": "cont_basic", + "description": "Similar to `RETARGS`.", + "gas": "26", + "fift": "RETVARARGS" + }, + "bytecode": { + "doc_opcode": "DB39", + "tlb": "#DB39", + "prefix": "DB39", + "operands": [] + }, + "value_flow": { + "doc_stack": "p r - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "p", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPXVARARGS", + "doc": { + "category": "cont_basic", + "description": "Similar to `JMPXARGS`.", + "gas": "26", + "fift": "JMPXVARARGS" + }, + "bytecode": { + "doc_opcode": "DB3A", + "tlb": "#DB3A", + "prefix": "DB3A", + "operands": [] + }, + "value_flow": { + "doc_stack": "c p r - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "p", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLCCVARARGS", + "doc": { + "category": "cont_basic", + "description": "Similar to `CALLCCARGS`.", + "gas": "26", + "fift": "CALLCCVARARGS" + }, + "bytecode": { + "doc_opcode": "DB3B", + "tlb": "#DB3B", + "prefix": "DB3B", + "operands": [] + }, + "value_flow": { + "doc_stack": "c p r - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "p", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLREF", + "doc": { + "category": "cont_basic", + "description": "Equivalent to `PUSHREFCONT` `CALLX`.", + "gas": "126/51", + "fift": "[ref] CALLREF" + }, + "bytecode": { + "doc_opcode": "DB3C", + "tlb": "#DB3C c:^Cell", + "prefix": "DB3C", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPREF", + "doc": { + "category": "cont_basic", + "description": "Equivalent to `PUSHREFCONT` `JMPX`.", + "gas": "126/51", + "fift": "[ref] JMPREF" + }, + "bytecode": { + "doc_opcode": "DB3D", + "tlb": "#DB3D c:^Cell", + "prefix": "DB3D", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "JMPREFDATA", + "doc": { + "category": "cont_basic", + "description": "Equivalent to `PUSHREFCONT` `JMPXDATA`.", + "gas": "126/51", + "fift": "[ref] JMPREFDATA" + }, + "bytecode": { + "doc_opcode": "DB3E", + "tlb": "#DB3E c:^Cell", + "prefix": "DB3E", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "RETDATA", + "doc": { + "category": "cont_basic", + "description": "Equivalent to `c0 PUSHCTR` `JMPXDATA`. In this way, the remainder of the current continuation is converted into a _Slice_ and returned to the caller.", + "gas": "26", + "fift": "RETDATA" + }, + "bytecode": { + "doc_opcode": "DB3F", + "tlb": "#DB3F", + "prefix": "DB3F", + "operands": [] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "IFRET", + "doc": { + "category": "cont_conditional", + "description": "Performs a `RET`, but only if integer `f` is non-zero. If `f` is a `NaN`, throws an integer overflow exception.", + "gas": "18", + "fift": "IFRET\nIFNOT:" + }, + "bytecode": { + "doc_opcode": "DC", + "tlb": "#DC", + "prefix": "DC", + "operands": [] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOTRET", + "doc": { + "category": "cont_conditional", + "description": "Performs a `RET`, but only if integer `f` is zero.", + "gas": "18", + "fift": "IFNOTRET\nIF:" + }, + "bytecode": { + "doc_opcode": "DD", + "tlb": "#DD", + "prefix": "DD", + "operands": [] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IF", + "doc": { + "category": "cont_conditional", + "description": "Performs `EXECUTE` for `c` (i.e., _executes_ `c`), but only if integer `f` is non-zero. Otherwise simply discards both values.", + "gas": "18", + "fift": "IF", + "fift_examples": [ + { + "fift": "IF:<{ code }> <{ code }>IF", + "description": "Equivalent to `<{ code }> CONT` `IF`." + } + ] + }, + "bytecode": { + "doc_opcode": "DE", + "tlb": "#DE", + "prefix": "DE", + "operands": [] + }, + "value_flow": { + "doc_stack": "f c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOT", + "doc": { + "category": "cont_conditional", + "description": "Executes continuation `c`, but only if integer `f` is zero. Otherwise simply discards both values.", + "gas": "18", + "fift": "IFNOT", + "fift_examples": [ + { + "fift": "IFNOT:<{ code }> <{ code }>IFNOT", + "description": "Equivalent to `<{ code }> CONT` `IFNOT`." + } + ] + }, + "bytecode": { + "doc_opcode": "DF", + "tlb": "#DF", + "prefix": "DF", + "operands": [] + }, + "value_flow": { + "doc_stack": "f c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFJMP", + "doc": { + "category": "cont_conditional", + "description": "Jumps to `c` (similarly to `JMPX`), but only if `f` is non-zero.", + "gas": "18", + "fift": "IFJMP", + "fift_examples": [ + { + "fift": "IFJMP:<{ code }>", + "description": "Equivalent to `<{ code }> CONT` `IFJMP`." + } + ] + }, + "bytecode": { + "doc_opcode": "E0", + "tlb": "#E0", + "prefix": "E0", + "operands": [] + }, + "value_flow": { + "doc_stack": "f c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOTJMP", + "doc": { + "category": "cont_conditional", + "description": "Jumps to `c` (similarly to `JMPX`), but only if `f` is zero.", + "gas": "18", + "fift": "IFNOTJMP", + "fift_examples": [ + { + "fift": "IFNOTJMP:<{ code }>", + "description": "Equivalent to `<{ code }> CONT` `IFNOTJMP`." + } + ] + }, + "bytecode": { + "doc_opcode": "E1", + "tlb": "#E1", + "prefix": "E1", + "operands": [] + }, + "value_flow": { + "doc_stack": "f c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFELSE", + "doc": { + "category": "cont_conditional", + "description": "If integer `f` is non-zero, executes `c`, otherwise executes `c'`. Equivalent to `CONDSELCHK` `EXECUTE`.", + "gas": "18", + "fift": "IFELSE", + "fift_examples": [ + { + "fift": "IF:<{ code1 }>ELSE<{ code2 }>", + "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `IFELSE`." + } + ] + }, + "bytecode": { + "doc_opcode": "E2", + "tlb": "#E2", + "prefix": "E2", + "operands": [] + }, + "value_flow": { + "doc_stack": "f c c' - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFREF", + "doc": { + "category": "cont_conditional", + "description": "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`.\nGas consumption of this primitive depends on whether `f=0` and whether the reference was loaded before.\nSimilar remarks apply other primitives that accept a continuation as a reference.", + "gas": "26/126/51", + "fift": "[ref] IFREF" + }, + "bytecode": { + "doc_opcode": "E300", + "tlb": "#E300 c:^Cell", + "prefix": "E300", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOTREF", + "doc": { + "category": "cont_conditional", + "description": "Equivalent to `PUSHREFCONT` `IFNOT`.", + "gas": "26/126/51", + "fift": "[ref] IFNOTREF" + }, + "bytecode": { + "doc_opcode": "E301", + "tlb": "#E301 c:^Cell", + "prefix": "E301", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFJMPREF", + "doc": { + "category": "cont_conditional", + "description": "Equivalent to `PUSHREFCONT` `IFJMP`.", + "gas": "26/126/51", + "fift": "[ref] IFJMPREF" + }, + "bytecode": { + "doc_opcode": "E302", + "tlb": "#E302 c:^Cell", + "prefix": "E302", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOTJMPREF", + "doc": { + "category": "cont_conditional", + "description": "Equivalent to `PUSHREFCONT` `IFNOTJMP`.", + "gas": "26/126/51", + "fift": "[ref] IFNOTJMPREF" + }, + "bytecode": { + "doc_opcode": "E303", + "tlb": "#E303 c:^Cell", + "prefix": "E303", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "CONDSEL", + "doc": { + "category": "cont_conditional", + "description": "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`.", + "gas": "26", + "fift": "CONDSEL" + }, + "bytecode": { + "doc_opcode": "E304", + "tlb": "#E304", + "prefix": "E304", + "operands": [] + }, + "value_flow": { + "doc_stack": "f x y - x or y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result" + } + ] + } + } + }, + { + "mnemonic": "CONDSELCHK", + "doc": { + "category": "cont_conditional", + "description": "Same as `CONDSEL`, but first checks whether `x` and `y` have the same type.", + "gas": "26", + "fift": "CONDSELCHK" + }, + "bytecode": { + "doc_opcode": "E305", + "tlb": "#E305", + "prefix": "E305", + "operands": [] + }, + "value_flow": { + "doc_stack": "f x y - x or y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "y" + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result" + } + ] + } + } + }, + { + "mnemonic": "IFRETALT", + "doc": { + "category": "cont_conditional", + "description": "Performs `RETALT` if integer `f!=0`.", + "gas": "26", + "fift": "IFRETALT" + }, + "bytecode": { + "doc_opcode": "E308", + "tlb": "#E308", + "prefix": "E308", + "operands": [] + }, + "value_flow": { + "doc_stack": "f -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFNOTRETALT", + "doc": { + "category": "cont_conditional", + "description": "Performs `RETALT` if integer `f=0`.", + "gas": "26", + "fift": "IFNOTRETALT" + }, + "bytecode": { + "doc_opcode": "E309", + "tlb": "#E309", + "prefix": "E309", + "operands": [] + }, + "value_flow": { + "doc_stack": "f -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFREFELSE", + "doc": { + "category": "cont_conditional", + "description": "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.", + "gas": "26/126/51", + "fift": "[ref] IFREFELSE" + }, + "bytecode": { + "doc_opcode": "E30D", + "tlb": "#E30D c:^Cell", + "prefix": "E30D", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFELSEREF", + "doc": { + "category": "cont_conditional", + "description": "Equivalent to `PUSHREFCONT` `IFELSE`.", + "gas": "26/126/51", + "fift": "[ref] IFELSEREF" + }, + "bytecode": { + "doc_opcode": "E30E", + "tlb": "#E30E c:^Cell", + "prefix": "E30E", + "operands": [ + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "f c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFREFELSEREF", + "doc": { + "category": "cont_conditional", + "description": "Equivalent to `PUSHREFCONT` `PUSHREFCONT` `IFELSE`.", + "gas": "126/51", + "fift": "[ref] [ref] IFREFELSEREF" + }, + "bytecode": { + "doc_opcode": "E30F", + "tlb": "#E30F c1:^Cell c2:^Cell", + "prefix": "E30F", + "operands": [] + }, + "value_flow": { + "doc_stack": "f -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "IFBITJMP", + "doc": { + "category": "cont_conditional", + "description": "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.", + "gas": "26", + "fift": "[n] IFBITJMP" + }, + "bytecode": { + "doc_opcode": "E39_n", + "tlb": "#E39_ n:uint5", + "prefix": "E39_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 5 + } + } + ] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "IFNBITJMP", + "doc": { + "category": "cont_conditional", + "description": "Jumps to `c` if bit `0 <= n <= 31` is not set in integer `x`.", + "gas": "26", + "fift": "[n] IFNBITJMP" + }, + "bytecode": { + "doc_opcode": "E3B_n", + "tlb": "#E3B_ n:uint5", + "prefix": "E3B_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 5 + } + } + ] + }, + "value_flow": { + "doc_stack": "x c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "IFBITJMPREF", + "doc": { + "category": "cont_conditional", + "description": "Performs a `JMPREF` if bit `0 <= n <= 31` is set in integer `x`.", + "gas": "126/51", + "fift": "[ref] [n] IFBITJMPREF" + }, + "bytecode": { + "doc_opcode": "E3D_n", + "tlb": "#E3D_ n:uint5 c:^Cell", + "prefix": "E3D_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 5 + } + }, + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "IFNBITJMPREF", + "doc": { + "category": "cont_conditional", + "description": "Performs a `JMPREF` if bit `0 <= n <= 31` is not set in integer `x`.", + "gas": "126/51", + "fift": "[ref] [n] IFNBITJMPREF" + }, + "bytecode": { + "doc_opcode": "E3F_n", + "tlb": "#E3F_ n:uint5 c:^Cell", + "prefix": "E3F_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 5 + } + }, + { + "name": "c", + "loader": "ref", + "loader_args": {} + } + ] + }, + "value_flow": { + "doc_stack": "x - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "REPEAT", + "doc": { + "category": "cont_loops", + "description": "Executes continuation `c` `n` times, if integer `n` is non-negative. If `n>=2^31` or `n<-2^31`, generates a range check exception.\nNotice 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.", + "gas": "18", + "fift": "REPEAT", + "fift_examples": [ + { + "fift": "REPEAT:<{ code }> <{ code }>REPEAT", + "description": "Equivalent to `<{ code }> CONT` `REPEAT`." + } + ] + }, + "bytecode": { + "doc_opcode": "E4", + "tlb": "#E4", + "prefix": "E4", + "operands": [] + }, + "value_flow": { + "doc_stack": "n c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "REPEATEND", + "doc": { + "category": "cont_loops", + "description": "Similar to `REPEAT`, but it is applied to the current continuation `cc`.", + "gas": "18", + "fift": "REPEATEND\nREPEAT:" + }, + "bytecode": { + "doc_opcode": "E5", + "tlb": "#E5", + "prefix": "E5", + "operands": [] + }, + "value_flow": { + "doc_stack": "n - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "UNTIL", + "doc": { + "category": "cont_loops", + "description": "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.", + "gas": "18", + "fift": "UNTIL", + "fift_examples": [ + { + "fift": "UNTIL:<{ code }> <{ code }>UNTIL", + "description": "Equivalent to `<{ code }> CONT` `UNTIL`." + } + ] + }, + "bytecode": { + "doc_opcode": "E6", + "tlb": "#E6", + "prefix": "E6", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "UNTILEND", + "doc": { + "category": "cont_loops", + "description": "Similar to `UNTIL`, but executes the current continuation `cc` in a loop. When the loop exit condition is satisfied, performs a `RET`.", + "gas": "18", + "fift": "UNTILEND\nUNTIL:" + }, + "bytecode": { + "doc_opcode": "E7", + "tlb": "#E7", + "prefix": "E7", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "WHILE", + "doc": { + "category": "cont_loops", + "description": "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.", + "gas": "18", + "fift": "WHILE", + "fift_examples": [ + { + "fift": "WHILE:<{ cond }>DO<{ code }>", + "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILE`." + } + ] + }, + "bytecode": { + "doc_opcode": "E8", + "tlb": "#E8", + "prefix": "E8", + "operands": [] + }, + "value_flow": { + "doc_stack": "c' c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "WHILEEND", + "doc": { + "category": "cont_loops", + "description": "Similar to `WHILE`, but uses the current continuation `cc` as the loop body.", + "gas": "18", + "fift": "WHILEEND" + }, + "bytecode": { + "doc_opcode": "E9", + "tlb": "#E9", + "prefix": "E9", + "operands": [] + }, + "value_flow": { + "doc_stack": "c' - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "AGAIN", + "doc": { + "category": "cont_loops", + "description": "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`).", + "gas": "18", + "fift": "AGAIN", + "fift_examples": [ + { + "fift": "AGAIN:<{ code }> <{ code }>AGAIN", + "description": "Equivalent to `<{ code }> CONT` `AGAIN`." + } + ] + }, + "bytecode": { + "doc_opcode": "EA", + "tlb": "#EA", + "prefix": "EA", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "AGAINEND", + "doc": { + "category": "cont_loops", + "description": "Similar to `AGAIN`, but performed with respect to the current continuation `cc`.", + "gas": "18", + "fift": "AGAINEND\nAGAIN:" + }, + "bytecode": { + "doc_opcode": "EB", + "tlb": "#EB", + "prefix": "EB", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "REPEATBRK", + "doc": { + "category": "cont_loops", + "description": "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.", + "gas": "26", + "fift": "REPEATBRK", + "fift_examples": [ + { + "fift": "REPEATBRK:<{ code }> <{ code }>REPEATBRK", + "description": "Equivalent to `<{ code }> CONT` `REPEATBRK`." + } + ] + }, + "bytecode": { + "doc_opcode": "E314", + "tlb": "#E314", + "prefix": "E314", + "operands": [] + }, + "value_flow": { + "doc_stack": "n c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "REPEATENDBRK", + "doc": { + "category": "cont_loops", + "description": "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`.", + "gas": "26", + "fift": "REPEATENDBRK" + }, + "bytecode": { + "doc_opcode": "E315", + "tlb": "#E315", + "prefix": "E315", + "operands": [] + }, + "value_flow": { + "doc_stack": "n -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "UNTILBRK", + "doc": { + "category": "cont_loops", + "description": "Similar to `UNTIL`, but also modifies `c1` in the same way as `REPEATBRK`.", + "gas": "26", + "fift": "UNTILBRK", + "fift_examples": [ + { + "fift": "UNTILBRK:<{ code }>", + "description": "Equivalent to `<{ code }> CONT` `UNTILBRK`." + } + ] + }, + "bytecode": { + "doc_opcode": "E316", + "tlb": "#E316", + "prefix": "E316", + "operands": [] + }, + "value_flow": { + "doc_stack": "c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "UNTILENDBRK", + "doc": { + "category": "cont_loops", + "description": "Equivalent to `SAMEALTSAVE` `UNTILEND`.", + "gas": "26", + "fift": "UNTILENDBRK\nUNTILBRK:" + }, + "bytecode": { + "doc_opcode": "E317", + "tlb": "#E317", + "prefix": "E317", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "WHILEBRK", + "doc": { + "category": "cont_loops", + "description": "Similar to `WHILE`, but also modifies `c1` in the same way as `REPEATBRK`.", + "gas": "26", + "fift": "WHILEBRK", + "fift_examples": [ + { + "fift": "WHILEBRK:<{ cond }>DO<{ code }>", + "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILEBRK`." + } + ] + }, + "bytecode": { + "doc_opcode": "E318", + "tlb": "#E318", + "prefix": "E318", + "operands": [] + }, + "value_flow": { + "doc_stack": "c' c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "WHILEENDBRK", + "doc": { + "category": "cont_loops", + "description": "Equivalent to `SAMEALTSAVE` `WHILEEND`.", + "gas": "26", + "fift": "WHILEENDBRK" + }, + "bytecode": { + "doc_opcode": "E319", + "tlb": "#E319", + "prefix": "E319", + "operands": [] + }, + "value_flow": { + "doc_stack": "c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "AGAINBRK", + "doc": { + "category": "cont_loops", + "description": "Similar to `AGAIN`, but also modifies `c1` in the same way as `REPEATBRK`.", + "gas": "26", + "fift": "AGAINBRK", + "fift_examples": [ + { + "fift": "AGAINBRK:<{ code }>", + "description": "Equivalent to `<{ code }> CONT` `AGAINBRK`." + } + ] + }, + "bytecode": { + "doc_opcode": "E31A", + "tlb": "#E31A", + "prefix": "E31A", + "operands": [] + }, + "value_flow": { + "doc_stack": "c -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "AGAINENDBRK", + "doc": { + "category": "cont_loops", + "description": "Equivalent to `SAMEALTSAVE` `AGAINEND`.", + "gas": "26", + "fift": "AGAINENDBRK\nAGAINBRK:" + }, + "bytecode": { + "doc_opcode": "E31B", + "tlb": "#E31B", + "prefix": "E31B", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "SETCONTARGS_N", + "doc": { + "category": "cont_stack", + "description": "Similar to `[r] -1 SETCONTARGS`, but 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.", + "gas": "26+s\u0432\u0402\u045c", + "fift": "[r] [n] SETCONTARGS" + }, + "bytecode": { + "doc_opcode": "ECrn", + "tlb": "#EC r:uint4 n:uint4", + "prefix": "EC", + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x_1 x_2...x_r c - c'", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "r" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "RETURNARGS", + "doc": { + "category": "cont_stack", + "description": "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.", + "gas": "26+s\u0432\u0402\u045c", + "fift": "[p] RETURNARGS" + }, + "bytecode": { + "doc_opcode": "ED0p", + "tlb": "#ED0 p:uint4", + "prefix": "ED0", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "-" + } + }, + { + "mnemonic": "RETURNVARARGS", + "doc": { + "category": "cont_stack", + "description": "Similar to `RETURNARGS`, but with Integer `0 <= p <= 255` taken from the stack.", + "gas": "26+s\u0432\u0402\u045c", + "fift": "RETURNVARARGS" + }, + "bytecode": { + "doc_opcode": "ED10", + "tlb": "#ED10", + "prefix": "ED10", + "operands": [] + }, + "value_flow": { + "doc_stack": "p -" + } + }, + { + "mnemonic": "SETCONTVARARGS", + "doc": { + "category": "cont_stack", + "description": "Similar to `SETCONTARGS`, but with `0 <= r <= 255` and `-1 <= n <= 255` taken from the stack.", + "gas": "26+s\u0432\u0402\u045c", + "fift": "SETCONTVARARGS" + }, + "bytecode": { + "doc_opcode": "ED11", + "tlb": "#ED11", + "prefix": "ED11", + "operands": [] + }, + "value_flow": { + "doc_stack": "x_1 x_2...x_r c r n - c'", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "r" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "SETNUMVARARGS", + "doc": { + "category": "cont_stack", + "description": "`-1 <= n <= 255`\nIf `n=-1`, this operation does nothing (`c'=c`).\nOtherwise its action is similar to `[n] SETNUMARGS`, but with `n` taken from the stack.", + "gas": "26", + "fift": "SETNUMVARARGS" + }, + "bytecode": { + "doc_opcode": "ED12", + "tlb": "#ED12", + "prefix": "ED12", + "operands": [] + }, + "value_flow": { + "doc_stack": "c n - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "BLESS", + "doc": { + "category": "cont_create", + "description": "Transforms a _Slice_ `s` into a simple ordinary continuation `c`, with `c.code=s` and an empty stack and savelist.", + "gas": "26", + "fift": "BLESS" + }, + "bytecode": { + "doc_opcode": "ED1E", + "tlb": "#ED1E", + "prefix": "ED1E", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - c", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "BLESSVARARGS", + "doc": { + "category": "cont_create", + "description": "Equivalent to `ROT` `BLESS` `ROTREV` `SETCONTVARARGS`.", + "gas": "26+s\u0432\u0402\u045c", + "fift": "BLESSVARARGS" + }, + "bytecode": { + "doc_opcode": "ED1F", + "tlb": "#ED1F", + "prefix": "ED1F", + "operands": [] + }, + "value_flow": { + "doc_stack": "x_1...x_r s r n - c", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "r" + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "r", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "BLESSARGS", + "doc": { + "category": "cont_create", + "description": "`0 <= r <= 15`, `-1 <= n <= 14`\nEquivalent to `BLESS` `[r] [n] SETCONTARGS`.\nThe value of `n` is represented inside the instruction by the 4-bit integer `n mod 16`.", + "gas": "26", + "fift": "[r] [n] BLESSARGS" + }, + "bytecode": { + "doc_opcode": "EErn", + "tlb": "#EE r:uint4 n:uint4", + "prefix": "EE", + "operands": [ + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x_1...x_r s - c", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "x", + "length_var": "r" + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "PUSHCTR", + "doc": { + "category": "cont_registers", + "description": "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.", + "gas": "26", + "fift": "c[i] PUSHCTR\nc[i] PUSH" + }, + "bytecode": { + "doc_opcode": "ED4i", + "tlb": "#ED4 i:uint4", + "prefix": "ED4", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "- x", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "POPCTR", + "doc": { + "category": "cont_registers", + "description": "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.", + "gas": "26", + "fift": "c[i] POPCTR\nc[i] POP" + }, + "bytecode": { + "doc_opcode": "ED5i", + "tlb": "#ED5 i:uint4", + "prefix": "ED5", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCONTCTR", + "doc": { + "category": "cont_registers", + "description": "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`.", + "gas": "26", + "fift": "c[i] SETCONT\nc[i] SETCONTCTR" + }, + "bytecode": { + "doc_opcode": "ED6i", + "tlb": "#ED6 i:uint4", + "prefix": "ED6", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x c - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "SETRETCTR", + "doc": { + "category": "cont_registers", + "description": "Equivalent to `c0 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.", + "gas": "26", + "fift": "c[i] SETRETCTR" + }, + "bytecode": { + "doc_opcode": "ED7i", + "tlb": "#ED7 i:uint4", + "prefix": "ED7", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETALTCTR", + "doc": { + "category": "cont_registers", + "description": "Equivalent to `c1 PUSHCTR` `c[i] SETCONTCTR` `c0 POPCTR`.", + "gas": "26", + "fift": "c[i] SETALTCTR" + }, + "bytecode": { + "doc_opcode": "ED8i", + "tlb": "#ED8 i:uint4", + "prefix": "ED8", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "POPSAVE", + "doc": { + "category": "cont_registers", + "description": "Similar to `c[i] POPCTR`, but also saves the old value of `c[i]` into continuation `c0`.\nEquivalent (up to exceptions) to `c[i] SAVECTR` `c[i] POPCTR`.", + "gas": "26", + "fift": "c[i] POPSAVE\nc[i] POPCTRSAVE" + }, + "bytecode": { + "doc_opcode": "ED9i", + "tlb": "#ED9 i:uint4", + "prefix": "ED9", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "x -", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SAVE", + "doc": { + "category": "cont_registers", + "description": "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`.", + "gas": "26", + "fift": "c[i] SAVE\nc[i] SAVECTR" + }, + "bytecode": { + "doc_opcode": "EDAi", + "tlb": "#EDA i:uint4", + "prefix": "EDA", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "SAVEALT", + "doc": { + "category": "cont_registers", + "description": "Similar to `c[i] SAVE`, but saves the current value of `c[i]` into the savelist of `c1`, not `c0`.", + "gas": "26", + "fift": "c[i] SAVEALT\nc[i] SAVEALTCTR" + }, + "bytecode": { + "doc_opcode": "EDBi", + "tlb": "#EDB i:uint4", + "prefix": "EDB", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "SAVEBOTH", + "doc": { + "category": "cont_registers", + "description": "Equivalent to `DUP` `c[i] SAVE` `c[i] SAVEALT`.", + "gas": "26", + "fift": "c[i] SAVEBOTH\nc[i] SAVEBOTHCTR" + }, + "bytecode": { + "doc_opcode": "EDCi", + "tlb": "#EDC i:uint4", + "prefix": "EDC", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "PUSHCTRX", + "doc": { + "category": "cont_registers", + "description": "Similar to `c[i] PUSHCTR`, but with `i`, `0 <= i <= 255`, taken from the stack.\nNotice that this primitive is one of the few \u0432\u0402\u045aexotic'' 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`.", + "gas": "26", + "fift": "PUSHCTRX" + }, + "bytecode": { + "doc_opcode": "EDE0", + "tlb": "#EDE0", + "prefix": "EDE0", + "operands": [] + }, + "value_flow": { + "doc_stack": "i - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "POPCTRX", + "doc": { + "category": "cont_registers", + "description": "Similar to `c[i] POPCTR`, but with `0 <= i <= 255` from the stack.", + "gas": "26", + "fift": "POPCTRX" + }, + "bytecode": { + "doc_opcode": "EDE1", + "tlb": "#EDE1", + "prefix": "EDE1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCONTCTRX", + "doc": { + "category": "cont_registers", + "description": "Similar to `c[i] SETCONTCTR`, but with `0 <= i <= 255` from the stack.", + "gas": "26", + "fift": "SETCONTCTRX" + }, + "bytecode": { + "doc_opcode": "EDE2", + "tlb": "#EDE2", + "prefix": "EDE2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x c i - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "COMPOS", + "doc": { + "category": "cont_registers", + "description": "Computes the composition `compose0(c, c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045aperform `c`, and, if successful, perform `c'`'' (if `c` is a boolean circuit) or simply \u0432\u0402\u045aperform `c`, then `c'`''. Equivalent to `SWAP` `c0 SETCONT`.", + "gas": "26", + "fift": "COMPOS\nBOOLAND" + }, + "bytecode": { + "doc_opcode": "EDF0", + "tlb": "#EDF0", + "prefix": "EDF0", + "operands": [] + }, + "value_flow": { + "doc_stack": "c c' - c''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c3", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "COMPOSALT", + "doc": { + "category": "cont_registers", + "description": "Computes the alternative composition `compose1(c, c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045aperform `c`, and, if not successful, perform `c'`'' (if `c` is a boolean circuit). Equivalent to `SWAP` `c1 SETCONT`.", + "gas": "26", + "fift": "COMPOSALT\nBOOLOR" + }, + "bytecode": { + "doc_opcode": "EDF1", + "tlb": "#EDF1", + "prefix": "EDF1", + "operands": [] + }, + "value_flow": { + "doc_stack": "c c' - c''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c3", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "COMPOSBOTH", + "doc": { + "category": "cont_registers", + "description": "Computes composition `compose1(compose0(c, c\u0432\u0402\u2122), c\u0432\u0402\u2122)`, which has the meaning of \u0432\u0402\u045acompute boolean circuit `c`, then compute `c'`, regardless of the result of `c`''.", + "gas": "26", + "fift": "COMPOSBOTH" + }, + "bytecode": { + "doc_opcode": "EDF2", + "tlb": "#EDF2", + "prefix": "EDF2", + "operands": [] + }, + "value_flow": { + "doc_stack": "c c' - c''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c3", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "ATEXIT", + "doc": { + "category": "cont_registers", + "description": "Sets `c0` to `compose0(c, c0)`. In other words, `c` will be executed before exiting current subroutine.", + "gas": "26", + "fift": "ATEXIT", + "fift_examples": [ + { + "fift": "ATEXIT:<{ code }> <{ code }>ATEXIT", + "description": "Equivalent to `<{ code }> CONT` `ATEXIT`." + } + ] + }, + "bytecode": { + "doc_opcode": "EDF3", + "tlb": "#EDF3", + "prefix": "EDF3", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "ATEXITALT", + "doc": { + "category": "cont_registers", + "description": "Sets `c1` to `compose1(c, c1)`. In other words, `c` will be executed before exiting current subroutine by its alternative return path.", + "gas": "26", + "fift": "ATEXITALT", + "fift_examples": [ + { + "fift": "ATEXITALT:<{ code }> <{ code }>ATEXITALT", + "description": "Equivalent to `<{ code }> CONT` `ATEXITALT`." + } + ] + }, + "bytecode": { + "doc_opcode": "EDF4", + "tlb": "#EDF4", + "prefix": "EDF4", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETEXITALT", + "doc": { + "category": "cont_registers", + "description": "Sets `c1` to `compose1(compose0(c, c0), c1)`,\nIn 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.", + "gas": "26", + "fift": "SETEXITALT" + }, + "bytecode": { + "doc_opcode": "EDF5", + "tlb": "#EDF5", + "prefix": "EDF5", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "THENRET", + "doc": { + "category": "cont_registers", + "description": "Computes `compose0(c, c0)`.", + "gas": "26", + "fift": "THENRET" + }, + "bytecode": { + "doc_opcode": "EDF6", + "tlb": "#EDF6", + "prefix": "EDF6", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "THENRETALT", + "doc": { + "category": "cont_registers", + "description": "Computes `compose0(c, c1)`", + "gas": "26", + "fift": "THENRETALT" + }, + "bytecode": { + "doc_opcode": "EDF7", + "tlb": "#EDF7", + "prefix": "EDF7", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - c'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "INVERT", + "doc": { + "category": "cont_registers", + "description": "Interchanges `c0` and `c1`.", + "gas": "26", + "fift": "INVERT" + }, + "bytecode": { + "doc_opcode": "EDF8", + "tlb": "#EDF8", + "prefix": "EDF8", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "BOOLEVAL", + "doc": { + "category": "cont_registers", + "description": "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.", + "gas": "26", + "fift": "BOOLEVAL" + }, + "bytecode": { + "doc_opcode": "EDF9", + "tlb": "#EDF9", + "prefix": "EDF9", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SAMEALT", + "doc": { + "category": "cont_registers", + "description": "Sets `c1` to `c0`. Equivalent to `c0 PUSHCTR` `c1 POPCTR`.", + "gas": "26", + "fift": "SAMEALT" + }, + "bytecode": { + "doc_opcode": "EDFA", + "tlb": "#EDFA", + "prefix": "EDFA", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "SAMEALTSAVE", + "doc": { + "category": "cont_registers", + "description": "Sets `c1` to `c0`, but first saves the old value of `c1` into the savelist of `c0`.\nEquivalent to `c1 SAVE` `SAMEALT`.", + "gas": "26", + "fift": "SAMEALTSAVE" + }, + "bytecode": { + "doc_opcode": "EDFB", + "tlb": "#EDFB", + "prefix": "EDFB", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "CALLDICT", + "doc": { + "category": "cont_dict", + "description": "Calls the continuation in `c3`, pushing integer `0 <= nn <= 255` into its stack as an argument.\nApproximately equivalent to `[nn] PUSHINT` `c3 PUSHCTR` `EXECUTE`.", + "gas": "", + "fift": "[nn] CALL\n[nn] CALLDICT" + }, + "bytecode": { + "doc_opcode": "F0nn", + "tlb": "#F0 n:uint8", + "prefix": "F0", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "- nn", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CALLDICT_LONG", + "doc": { + "category": "cont_dict", + "description": "For `0 <= n < 2^14`, an encoding of `[n] CALL` for larger values of `n`.", + "gas": "", + "fift": "[n] CALL\n[n] CALLDICT" + }, + "bytecode": { + "doc_opcode": "F12_n", + "tlb": "#F12_ n:uint14", + "prefix": "F12_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 14 + } + } + ] + }, + "value_flow": { + "doc_stack": "- n", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "JMPDICT", + "doc": { + "category": "cont_dict", + "description": "Jumps to the continuation in `c3`, pushing integer `0 <= n < 2^14` as its argument.\nApproximately equivalent to `n PUSHINT` `c3 PUSHCTR` `JMPX`.", + "gas": "", + "fift": "[n] JMP" + }, + "bytecode": { + "doc_opcode": "F16_n", + "tlb": "#F16_ n:uint14", + "prefix": "F16_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 14 + } + } + ] + }, + "value_flow": { + "doc_stack": " - n", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PREPAREDICT", + "doc": { + "category": "cont_dict", + "description": "Equivalent to `n PUSHINT` `c3 PUSHCTR`, for `0 <= n < 2^14`.\nIn this way, `[n] CALL` is approximately equivalent to `[n] PREPARE` `EXECUTE`, and `[n] JMP` is approximately equivalent to `[n] PREPARE` `JMPX`.\nOne might use, for instance, `CALLXARGS` or `CALLCC` instead of `EXECUTE` here.", + "gas": "", + "fift": "[n] PREPARE\n[n] PREPAREDICT" + }, + "bytecode": { + "doc_opcode": "F1A_n", + "tlb": "#F1A_ n:uint14", + "prefix": "F1A_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 14 + } + } + ] + }, + "value_flow": { + "doc_stack": " - n c", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + } + ] + } + } + }, + { + "mnemonic": "THROW_SHORT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n <= 63` with parameter zero.\nIn other words, it transfers control to the continuation in `c2`, pushing `0` and `n` into its stack, and discarding the old stack altogether.", + "gas": "76", + "fift": "[n] THROW" + }, + "bytecode": { + "doc_opcode": "F22_n", + "tlb": "#F22_ n:uint6", + "prefix": "F22_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 6 + } + } + ] + }, + "value_flow": { + "doc_stack": " - 0 n", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWIF_SHORT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n <= 63` with parameter zero only if integer `f!=0`.", + "gas": "26/76", + "fift": "[n] THROWIF" + }, + "bytecode": { + "doc_opcode": "F26_n", + "tlb": "#F26_ n:uint6", + "prefix": "F26_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 6 + } + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "THROWIFNOT_SHORT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n <= 63` with parameter zero only if integer `f=0`.", + "gas": "26/76", + "fift": "[n] THROWIFNOT" + }, + "bytecode": { + "doc_opcode": "F2A_n", + "tlb": "#F2A_ n:uint6", + "prefix": "F2A_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 6 + } + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "THROW", + "doc": { + "category": "exceptions", + "description": "For `0 <= n < 2^11`, an encoding of `[n] THROW` for larger values of `n`.", + "gas": "84", + "fift": "[n] THROW" + }, + "bytecode": { + "doc_opcode": "F2C4_n", + "tlb": "#F2C4_ n:uint11", + "prefix": "F2C4_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "- 0 nn", + "inputs": { + "stack": [ + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARG", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n < 2^11` with parameter `x`, by copying `x` and `n` into the stack of `c2` and transferring control to `c2`.", + "gas": "84", + "fift": "[n] THROWARG" + }, + "bytecode": { + "doc_opcode": "F2CC_n", + "tlb": "#F2CC_ n:uint11", + "prefix": "F2CC_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - x nn", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWIF", + "doc": { + "category": "exceptions", + "description": "For `0 <= n < 2^11`, an encoding of `[n] THROWIF` for larger values of `n`.", + "gas": "34/84", + "fift": "[n] THROWIF" + }, + "bytecode": { + "doc_opcode": "F2D4_n", + "tlb": "#F2D4_ n:uint11", + "prefix": "F2D4_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARGIF", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= nn < 2^11` with parameter `x` only if integer `f!=0`.", + "gas": "34/84", + "fift": "[n] THROWARGIF" + }, + "bytecode": { + "doc_opcode": "F2DC_n", + "tlb": "#F2DC_ n:uint11", + "prefix": "F2DC_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "x f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWIFNOT", + "doc": { + "category": "exceptions", + "description": "For `0 <= n < 2^11`, an encoding of `[n] THROWIFNOT` for larger values of `n`.", + "gas": "34/84", + "fift": "[n] THROWIFNOT" + }, + "bytecode": { + "doc_opcode": "F2E4_n", + "tlb": "#F2E4_ n:uint11", + "prefix": "F2E4_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARGIFNOT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n < 2^11` with parameter `x` only if integer `f=0`.", + "gas": "34/84", + "fift": "[n] THROWARGIFNOT" + }, + "bytecode": { + "doc_opcode": "F2EC_n", + "tlb": "#F2EC_ n:uint11", + "prefix": "F2EC_", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 11 + } + } + ] + }, + "value_flow": { + "doc_stack": "x f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWANY", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n < 2^16` with parameter zero.\nApproximately equivalent to `ZERO` `SWAP` `THROWARGANY`.", + "gas": "76", + "fift": "THROWANY" + }, + "bytecode": { + "doc_opcode": "F2F0", + "tlb": "#F2F0", + "prefix": "F2F0", + "operands": [] + }, + "value_flow": { + "doc_stack": "n - 0 n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARGANY", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n < 2^16` with parameter `x`, transferring control to the continuation in `c2`.\nApproximately equivalent to `c2 PUSHCTR` `2 JMPXARGS`.", + "gas": "76", + "fift": "THROWARGANY" + }, + "bytecode": { + "doc_opcode": "F2F1", + "tlb": "#F2F1", + "prefix": "F2F1", + "operands": [] + }, + "value_flow": { + "doc_stack": "x n - x n", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWANYIF", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n < 2^16` with parameter zero only if `f!=0`.", + "gas": "26/76", + "fift": "THROWANYIF" + }, + "bytecode": { + "doc_opcode": "F2F2", + "tlb": "#F2F2", + "prefix": "F2F2", + "operands": [] + }, + "value_flow": { + "doc_stack": "n f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARGANYIF", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n<2^16` with parameter `x` only if `f!=0`.", + "gas": "26/76", + "fift": "THROWARGANYIF" + }, + "bytecode": { + "doc_opcode": "F2F3", + "tlb": "#F2F3", + "prefix": "F2F3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x n f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWANYIFNOT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n<2^16` with parameter zero only if `f=0`.", + "gas": "26/76", + "fift": "THROWANYIFNOT" + }, + "bytecode": { + "doc_opcode": "F2F4", + "tlb": "#F2F4", + "prefix": "F2F4", + "operands": [] + }, + "value_flow": { + "doc_stack": "n f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "THROWARGANYIFNOT", + "doc": { + "category": "exceptions", + "description": "Throws exception `0 <= n<2^16` with parameter `x` only if `f=0`.", + "gas": "26/76", + "fift": "THROWARGANYIFNOT" + }, + "bytecode": { + "doc_opcode": "F2F5", + "tlb": "#F2F5", + "prefix": "F2F5", + "operands": [] + }, + "value_flow": { + "doc_stack": "x n f - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "f", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "TRY", + "doc": { + "category": "exceptions", + "description": "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.", + "gas": "26", + "fift": "TRY", + "fift_examples": [ + { + "fift": "TRY:<{ code1 }>CATCH<{ code2 }>", + "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `TRY`." + } + ] + }, + "bytecode": { + "doc_opcode": "F2FF", + "tlb": "#F2FF", + "prefix": "F2FF", + "operands": [] + }, + "value_flow": { + "doc_stack": "c c' - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "TRYARGS", + "doc": { + "category": "exceptions", + "description": "Similar to `TRY`, but with `[p] [r] CALLXARGS` internally used instead of `EXECUTE`.\nIn 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.", + "gas": "26", + "fift": "[p] [r] TRYARGS" + }, + "bytecode": { + "doc_opcode": "F3pr", + "tlb": "#F3 p:uint4 r:uint4", + "prefix": "F3", + "operands": [ + { + "name": "p", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "r", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "c c' - ", + "inputs": { + "stack": [ + { + "type": "tuple", + "name": "args", + "length_var": "p" + }, + { + "type": "simple", + "name": "c", + "value_types": ["Continuation"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Continuation"] + } + ] + }, + "outputs": { + "stack": [ + ] + } + } + }, + { + "mnemonic": "STDICT", + "doc": { + "category": "dict_serial", + "description": "Stores dictionary `D` into _Builder_ `b`, returing the resulting _Builder_ `b'`.\nIn 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.", + "gas": "26", + "fift": "STDICT\nSTOPTREF" + }, + "bytecode": { + "doc_opcode": "F400", + "tlb": "#F400", + "prefix": "F400", + "operands": [] + }, + "value_flow": { + "doc_stack": "D b - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "SKIPDICT", + "doc": { + "category": "dict_serial", + "description": "Equivalent to `LDDICT` `NIP`.", + "gas": "26", + "fift": "SKIPDICT\nSKIPOPTREF" + }, + "bytecode": { + "doc_opcode": "F401", + "tlb": "#F401", + "prefix": "F401", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDDICTS", + "doc": { + "category": "dict_serial", + "description": "Loads (parses) a (_Slice_-represented) dictionary `s'` from _Slice_ `s`, and returns the remainder of `s` as `s''`.\nThis is a \u0432\u0402\u045asplit function'' for all `HashmapE(n,X)` dictionary types.", + "gas": "26", + "fift": "LDDICTS" + }, + "bytecode": { + "doc_opcode": "F402", + "tlb": "#F402", + "prefix": "F402", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s' s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDDICTS", + "doc": { + "category": "dict_serial", + "description": "Preloads a (_Slice_-represented) dictionary `s'` from _Slice_ `s`.\nApproximately equivalent to `LDDICTS` `DROP`.", + "gas": "26", + "fift": "PLDDICTS" + }, + "bytecode": { + "doc_opcode": "F403", + "tlb": "#F403", + "prefix": "F403", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDDICT", + "doc": { + "category": "dict_serial", + "description": "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.", + "gas": "26", + "fift": "LDDICT\nLDOPTREF" + }, + "bytecode": { + "doc_opcode": "F404", + "tlb": "#F404", + "prefix": "F404", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - D s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PLDDICT", + "doc": { + "category": "dict_serial", + "description": "Preloads a dictionary `D` from _Slice_ `s`.\nApproximately equivalent to `LDDICT` `DROP`.", + "gas": "26", + "fift": "PLDDICT\nPLDOPTREF" + }, + "bytecode": { + "doc_opcode": "F405", + "tlb": "#F405", + "prefix": "F405", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - D", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "LDDICTQ", + "doc": { + "category": "dict_serial", + "description": "A quiet version of `LDDICT`.", + "gas": "26", + "fift": "LDDICTQ" + }, + "bytecode": { + "doc_opcode": "F406", + "tlb": "#F406", + "prefix": "F406", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - D s' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Integer"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PLDDICTQ", + "doc": { + "category": "dict_serial", + "description": "A quiet version of `PLDDICT`.", + "gas": "26", + "fift": "PLDDICTQ" + }, + "bytecode": { + "doc_opcode": "F407", + "tlb": "#F407", + "prefix": "F407", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - D -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGET", + "doc": { + "category": "dict_get", + "description": "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.\nOn success, returns the value found as a _Slice_ `x`.", + "gas": "", + "fift": "DICTGET" + }, + "bytecode": { + "doc_opcode": "F40A", + "tlb": "#F40A", + "prefix": "F40A", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETREF", + "doc": { + "category": "dict_get", + "description": "Similar to `DICTGET`, but with a `LDREF` `ENDS` applied to `x` on success.\nThis operation is useful for dictionaries of type `HashmapE(n,^Y)`.", + "gas": "", + "fift": "DICTGETREF" + }, + "bytecode": { + "doc_opcode": "F40B", + "tlb": "#F40B", + "prefix": "F40B", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - c -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "mnemonic": "DICTIGET", + "doc": { + "category": "dict_get", + "description": "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.", + "gas": "", + "fift": "DICTIGET" + }, + "bytecode": { + "doc_opcode": "F40C", + "tlb": "#F40C", + "prefix": "F40C", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETREF", + "doc": { + "category": "dict_get", + "description": "Combines `DICTIGET` with `DICTGETREF`: it uses signed `n`-bit _Integer_ `i` as a key and returns a _Cell_ instead of a _Slice_ on success.", + "gas": "", + "fift": "DICTIGETREF" + }, + "bytecode": { + "doc_opcode": "F40D", + "tlb": "#F40D", + "prefix": "F40D", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - c -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGET", + "doc": { + "category": "dict_get", + "description": "Similar to `DICTIGET`, but with _unsigned_ (big-endian) `n`-bit _Integer_ `i` used as a key.", + "gas": "", + "fift": "DICTUGET" + }, + "bytecode": { + "doc_opcode": "F40E", + "tlb": "#F40E", + "prefix": "F40E", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETREF", + "doc": { + "category": "dict_get", + "description": "Similar to `DICTIGETREF`, but with an unsigned `n`-bit _Integer_ key `i`.", + "gas": "", + "fift": "DICTUGETREF" + }, + "bytecode": { + "doc_opcode": "F40F", + "tlb": "#F40F", + "prefix": "F40F", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - c -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTSET", + "doc": { + "category": "dict_set", + "description": "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'`.", + "gas": "", + "fift": "DICTSET" + }, + "bytecode": { + "doc_opcode": "F412", + "tlb": "#F412", + "prefix": "F412", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETREF", + "doc": { + "category": "dict_set", + "description": "Similar to `DICTSET`, but with the value set to a reference to _Cell_ `c`.", + "gas": "", + "fift": "DICTSETREF" + }, + "bytecode": { + "doc_opcode": "F413", + "tlb": "#F413", + "prefix": "F413", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTISET", + "doc": { + "category": "dict_set", + "description": "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.", + "gas": "", + "fift": "DICTISET" + }, + "bytecode": { + "doc_opcode": "F414", + "tlb": "#F414", + "prefix": "F414", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETREF", + "doc": { + "category": "dict_set", + "description": "Similar to `DICTSETREF`, but with the key a signed `n`-bit integer as in `DICTISET`.", + "gas": "", + "fift": "DICTISETREF" + }, + "bytecode": { + "doc_opcode": "F415", + "tlb": "#F415", + "prefix": "F415", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSET", + "doc": { + "category": "dict_set", + "description": "Similar to `DICTISET`, but with `i` an _unsigned_ `n`-bit integer.", + "gas": "", + "fift": "DICTUSET" + }, + "bytecode": { + "doc_opcode": "F416", + "tlb": "#F416", + "prefix": "F416", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETREF", + "doc": { + "category": "dict_set", + "description": "Similar to `DICTISETREF`, but with `i` unsigned.", + "gas": "", + "fift": "DICTUSETREF" + }, + "bytecode": { + "doc_opcode": "F417", + "tlb": "#F417", + "prefix": "F417", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETGET", + "doc": { + "category": "dict_set", + "description": "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.", + "gas": "", + "fift": "DICTSETGET" + }, + "bytecode": { + "doc_opcode": "F41A", + "tlb": "#F41A", + "prefix": "F41A", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETGETREF", + "doc": { + "category": "dict_set", + "description": "Combines `DICTSETREF` with `DICTGETREF` similarly to `DICTSETGET`.", + "gas": "", + "fift": "DICTSETGETREF" + }, + "bytecode": { + "doc_opcode": "F41B", + "tlb": "#F41B", + "prefix": "F41B", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D' c' -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETGET", + "doc": { + "category": "dict_set", + "description": "`DICTISETGET`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTISETGET" + }, + "bytecode": { + "doc_opcode": "F41C", + "tlb": "#F41C", + "prefix": "F41C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTISETGETREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTISETGETREF" + }, + "bytecode": { + "doc_opcode": "F41D", + "tlb": "#F41D", + "prefix": "F41D", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' c' -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETGET", + "doc": { + "category": "dict_set", + "description": "`DICTISETGET`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUSETGET" + }, + "bytecode": { + "doc_opcode": "F41E", + "tlb": "#F41E", + "prefix": "F41E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTISETGETREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUSETGETREF" + }, + "bytecode": { + "doc_opcode": "F41F", + "tlb": "#F41F", + "prefix": "F41F", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' c' -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACE", + "doc": { + "category": "dict_set", + "description": "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`.", + "gas": "", + "fift": "DICTREPLACE" + }, + "bytecode": { + "doc_opcode": "F422", + "tlb": "#F422", + "prefix": "F422", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACEREF", + "doc": { + "category": "dict_set", + "description": "A _Replace_ counterpart of `DICTSETREF`.", + "gas": "", + "fift": "DICTREPLACEREF" + }, + "bytecode": { + "doc_opcode": "F423", + "tlb": "#F423", + "prefix": "F423", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACE", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACE`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIREPLACE" + }, + "bytecode": { + "doc_opcode": "F424", + "tlb": "#F424", + "prefix": "F424", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACEREF", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIREPLACEREF" + }, + "bytecode": { + "doc_opcode": "F425", + "tlb": "#F425", + "prefix": "F425", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACE", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACE`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUREPLACE" + }, + "bytecode": { + "doc_opcode": "F426", + "tlb": "#F426", + "prefix": "F426", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACEREF", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUREPLACEREF" + }, + "bytecode": { + "doc_opcode": "F427", + "tlb": "#F427", + "prefix": "F427", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACEGET", + "doc": { + "category": "dict_set", + "description": "A _Replace_ counterpart of `DICTSETGET`: on success, also returns the old value associated with the key in question.", + "gas": "", + "fift": "DICTREPLACEGET" + }, + "bytecode": { + "doc_opcode": "F42A", + "tlb": "#F42A", + "prefix": "F42A", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACEGETREF", + "doc": { + "category": "dict_set", + "description": "A _Replace_ counterpart of `DICTSETGETREF`.", + "gas": "", + "fift": "DICTREPLACEGETREF" + }, + "bytecode": { + "doc_opcode": "F42B", + "tlb": "#F42B", + "prefix": "F42B", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D' c' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACEGET", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEGET`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIREPLACEGET" + }, + "bytecode": { + "doc_opcode": "F42C", + "tlb": "#F42C", + "prefix": "F42C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACEGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEGETREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIREPLACEGETREF" + }, + "bytecode": { + "doc_opcode": "F42D", + "tlb": "#F42D", + "prefix": "F42D", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' c' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACEGET", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEGET`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUREPLACEGET" + }, + "bytecode": { + "doc_opcode": "F42E", + "tlb": "#F42E", + "prefix": "F42E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACEGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTREPLACEGETREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUREPLACEGETREF" + }, + "bytecode": { + "doc_opcode": "F42F", + "tlb": "#F42F", + "prefix": "F42F", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' c' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADD", + "doc": { + "category": "dict_set", + "description": "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`.", + "gas": "", + "fift": "DICTADD" + }, + "bytecode": { + "doc_opcode": "F432", + "tlb": "#F432", + "prefix": "F432", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADDREF", + "doc": { + "category": "dict_set", + "description": "An _Add_ counterpart of `DICTSETREF`.", + "gas": "", + "fift": "DICTADDREF" + }, + "bytecode": { + "doc_opcode": "F433", + "tlb": "#F433", + "prefix": "F433", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADD", + "doc": { + "category": "dict_set", + "description": "`DICTADD`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIADD" + }, + "bytecode": { + "doc_opcode": "F434", + "tlb": "#F434", + "prefix": "F434", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADDREF", + "doc": { + "category": "dict_set", + "description": "`DICTADDREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIADDREF" + }, + "bytecode": { + "doc_opcode": "F435", + "tlb": "#F435", + "prefix": "F435", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADD", + "doc": { + "category": "dict_set", + "description": "`DICTADD`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUADD" + }, + "bytecode": { + "doc_opcode": "F436", + "tlb": "#F436", + "prefix": "F436", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADDREF", + "doc": { + "category": "dict_set", + "description": "`DICTADDREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUADDREF" + }, + "bytecode": { + "doc_opcode": "F437", + "tlb": "#F437", + "prefix": "F437", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADDGET", + "doc": { + "category": "dict_set", + "description": "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.", + "gas": "", + "fift": "DICTADDGET" + }, + "bytecode": { + "doc_opcode": "F43A", + "tlb": "#F43A", + "prefix": "F43A", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADDGETREF", + "doc": { + "category": "dict_set", + "description": "An _Add_ counterpart of `DICTSETGETREF`.", + "gas": "", + "fift": "DICTADDGETREF" + }, + "bytecode": { + "doc_opcode": "F43B", + "tlb": "#F43B", + "prefix": "F43B", + "operands": [] + }, + "value_flow": { + "doc_stack": "c k D n - D' -1 or D c' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADDGET", + "doc": { + "category": "dict_set", + "description": "`DICTADDGET`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIADDGET" + }, + "bytecode": { + "doc_opcode": "F43C", + "tlb": "#F43C", + "prefix": "F43C", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADDGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTADDGETREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIADDGETREF" + }, + "bytecode": { + "doc_opcode": "F43D", + "tlb": "#F43D", + "prefix": "F43D", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D c' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADDGET", + "doc": { + "category": "dict_set", + "description": "`DICTADDGET`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUADDGET" + }, + "bytecode": { + "doc_opcode": "F43E", + "tlb": "#F43E", + "prefix": "F43E", + "operands": [] + }, + "value_flow": { + "doc_stack": "x i D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADDGETREF", + "doc": { + "category": "dict_set", + "description": "`DICTADDGETREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUADDGETREF" + }, + "bytecode": { + "doc_opcode": "F43F", + "tlb": "#F43F", + "prefix": "F43F", + "operands": [] + }, + "value_flow": { + "doc_stack": "c i D n - D' -1 or D c' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTSETB" + }, + "bytecode": { + "doc_opcode": "F441", + "tlb": "#F441", + "prefix": "F441", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTISETB" + }, + "bytecode": { + "doc_opcode": "F442", + "tlb": "#F442", + "prefix": "F442", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUSETB" + }, + "bytecode": { + "doc_opcode": "F443", + "tlb": "#F443", + "prefix": "F443", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTSETGETB" + }, + "bytecode": { + "doc_opcode": "F445", + "tlb": "#F445", + "prefix": "F445", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTISETGETB" + }, + "bytecode": { + "doc_opcode": "F446", + "tlb": "#F446", + "prefix": "F446", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUSETGETB" + }, + "bytecode": { + "doc_opcode": "F447", + "tlb": "#F447", + "prefix": "F447", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' y -1 or D' 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACEB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTREPLACEB" + }, + "bytecode": { + "doc_opcode": "F449", + "tlb": "#F449", + "prefix": "F449", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACEB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTIREPLACEB" + }, + "bytecode": { + "doc_opcode": "F44A", + "tlb": "#F44A", + "prefix": "F44A", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACEB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUREPLACEB" + }, + "bytecode": { + "doc_opcode": "F44B", + "tlb": "#F44B", + "prefix": "F44B", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREPLACEGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTREPLACEGETB" + }, + "bytecode": { + "doc_opcode": "F44D", + "tlb": "#F44D", + "prefix": "F44D", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREPLACEGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTIREPLACEGETB" + }, + "bytecode": { + "doc_opcode": "F44E", + "tlb": "#F44E", + "prefix": "F44E", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREPLACEGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUREPLACEGETB" + }, + "bytecode": { + "doc_opcode": "F44F", + "tlb": "#F44F", + "prefix": "F44F", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' y -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADDB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTADDB" + }, + "bytecode": { + "doc_opcode": "F451", + "tlb": "#F451", + "prefix": "F451", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADDB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTIADDB" + }, + "bytecode": { + "doc_opcode": "F452", + "tlb": "#F452", + "prefix": "F452", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADDB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUADDB" + }, + "bytecode": { + "doc_opcode": "F453", + "tlb": "#F453", + "prefix": "F453", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTADDGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTADDGETB" + }, + "bytecode": { + "doc_opcode": "F455", + "tlb": "#F455", + "prefix": "F455", + "operands": [] + }, + "value_flow": { + "doc_stack": "b k D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIADDGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTIADDGETB" + }, + "bytecode": { + "doc_opcode": "F456", + "tlb": "#F456", + "prefix": "F456", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUADDGETB", + "doc": { + "category": "dict_set_builder", + "description": "", + "gas": "", + "fift": "DICTUADDGETB" + }, + "bytecode": { + "doc_opcode": "F457", + "tlb": "#F457", + "prefix": "F457", + "operands": [] + }, + "value_flow": { + "doc_stack": "b i D n - D' -1 or D y 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTDEL", + "doc": { + "category": "dict_delete", + "description": "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`.", + "gas": "", + "fift": "DICTDEL" + }, + "bytecode": { + "doc_opcode": "F459", + "tlb": "#F459", + "prefix": "F459", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIDEL", + "doc": { + "category": "dict_delete", + "description": "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` (\u0432\u0402\u045akey not found, dictionary unmodified'').", + "gas": "", + "fift": "DICTIDEL" + }, + "bytecode": { + "doc_opcode": "F45A", + "tlb": "#F45A", + "prefix": "F45A", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUDEL", + "doc": { + "category": "dict_delete", + "description": "Similar to `DICTIDEL`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUDEL" + }, + "bytecode": { + "doc_opcode": "F45B", + "tlb": "#F45B", + "prefix": "F45B", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTDELGET", + "doc": { + "category": "dict_delete", + "description": "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`.", + "gas": "", + "fift": "DICTDELGET" + }, + "bytecode": { + "doc_opcode": "F462", + "tlb": "#F462", + "prefix": "F462", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - D' x -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTDELGETREF", + "doc": { + "category": "dict_delete", + "description": "Similar to `DICTDELGET`, but with `LDREF` `ENDS` applied to `x` on success, so that the value returned `c` is a _Cell_.", + "gas": "", + "fift": "DICTDELGETREF" + }, + "bytecode": { + "doc_opcode": "F463", + "tlb": "#F463", + "prefix": "F463", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - D' c -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIDELGET", + "doc": { + "category": "dict_delete", + "description": "`DICTDELGET`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIDELGET" + }, + "bytecode": { + "doc_opcode": "F464", + "tlb": "#F464", + "prefix": "F464", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' x -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIDELGETREF", + "doc": { + "category": "dict_delete", + "description": "`DICTDELGETREF`, but with `i` a signed `n`-bit integer.", + "gas": "", + "fift": "DICTIDELGETREF" + }, + "bytecode": { + "doc_opcode": "F465", + "tlb": "#F465", + "prefix": "F465", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' c -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUDELGET", + "doc": { + "category": "dict_delete", + "description": "`DICTDELGET`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUDELGET" + }, + "bytecode": { + "doc_opcode": "F466", + "tlb": "#F466", + "prefix": "F466", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' x -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUDELGETREF", + "doc": { + "category": "dict_delete", + "description": "`DICTDELGETREF`, but with `i` an unsigned `n`-bit integer.", + "gas": "", + "fift": "DICTUDELGETREF" + }, + "bytecode": { + "doc_opcode": "F467", + "tlb": "#F467", + "prefix": "F467", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - D' c -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "A variant of `DICTGETREF` that returns _Null_ instead of the value `c^?` if the key `k` is absent from dictionary `D`.", + "gas": "", + "fift": "DICTGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F469", + "tlb": "#F469", + "prefix": "F469", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "`DICTGETOPTREF`, but with `i` a signed `n`-bit integer. If the key `i` is out of range, also returns _Null_.", + "gas": "", + "fift": "DICTIGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F46A", + "tlb": "#F46A", + "prefix": "F46A", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "`DICTGETOPTREF`, but with `i` an unsigned `n`-bit integer. If the key `i` is out of range, also returns _Null_.", + "gas": "", + "fift": "DICTUGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F46B", + "tlb": "#F46B", + "prefix": "F46B", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "DICTSETGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "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).", + "gas": "", + "fift": "DICTSETGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F46D", + "tlb": "#F46D", + "prefix": "F46D", + "operands": [] + }, + "value_flow": { + "doc_stack": "c^? k D n - D' ~c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "DICTISETGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "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.", + "gas": "", + "fift": "DICTISETGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F46E", + "tlb": "#F46E", + "prefix": "F46E", + "operands": [] + }, + "value_flow": { + "doc_stack": "c^? i D n - D' ~c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "DICTUSETGETOPTREF", + "doc": { + "category": "dict_mayberef", + "description": "Similar to primitive `DICTSETGETOPTREF`, but using unsigned `n`-bit _Integer_ `i` as a key.", + "gas": "", + "fift": "DICTUSETGETOPTREF" + }, + "bytecode": { + "doc_opcode": "F46F", + "tlb": "#F46F", + "prefix": "F46F", + "operands": [] + }, + "value_flow": { + "doc_stack": "c^? i D n - D' ~c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c2", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTSET", + "doc": { + "category": "dict_prefix", + "description": "", + "gas": "", + "fift": "PFXDICTSET" + }, + "bytecode": { + "doc_opcode": "F470", + "tlb": "#F470", + "prefix": "F470", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTREPLACE", + "doc": { + "category": "dict_prefix", + "description": "", + "gas": "", + "fift": "PFXDICTREPLACE" + }, + "bytecode": { + "doc_opcode": "F471", + "tlb": "#F471", + "prefix": "F471", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTADD", + "doc": { + "category": "dict_prefix", + "description": "", + "gas": "", + "fift": "PFXDICTADD" + }, + "bytecode": { + "doc_opcode": "F472", + "tlb": "#F472", + "prefix": "F472", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTDEL", + "doc": { + "category": "dict_prefix", + "description": "", + "gas": "", + "fift": "PFXDICTDEL" + }, + "bytecode": { + "doc_opcode": "F473", + "tlb": "#F473", + "prefix": "F473", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - D' -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETNEXT", + "doc": { + "category": "dict_next", + "description": "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_).", + "gas": "", + "fift": "DICTGETNEXT" + }, + "bytecode": { + "doc_opcode": "F474", + "tlb": "#F474", + "prefix": "F474", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - x' k' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETNEXTEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETNEXT`, but computes the minimal key `k'` that is lexicographically greater than or equal to `k`.", + "gas": "", + "fift": "DICTGETNEXTEQ" + }, + "bytecode": { + "doc_opcode": "F475", + "tlb": "#F475", + "prefix": "F475", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - x' k' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETPREV", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETNEXT`, but computes the maximal key `k'` lexicographically smaller than `k`.", + "gas": "", + "fift": "DICTGETPREV" + }, + "bytecode": { + "doc_opcode": "F476", + "tlb": "#F476", + "prefix": "F476", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - x' k' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTGETPREVEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETPREV`, but computes the maximal key `k'` lexicographically smaller than or equal to `k`.", + "gas": "", + "fift": "DICTGETPREVEQ" + }, + "bytecode": { + "doc_opcode": "F477", + "tlb": "#F477", + "prefix": "F477", + "operands": [] + }, + "value_flow": { + "doc_stack": "k D n - x' k' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k2", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETNEXT", + "doc": { + "category": "dict_next", + "description": "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).", + "gas": "", + "fift": "DICTIGETNEXT" + }, + "bytecode": { + "doc_opcode": "F478", + "tlb": "#F478", + "prefix": "F478", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETNEXTEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETNEXTEQ`, but interprets keys as signed `n`-bit integers.", + "gas": "", + "fift": "DICTIGETNEXTEQ" + }, + "bytecode": { + "doc_opcode": "F479", + "tlb": "#F479", + "prefix": "F479", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETPREV", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETPREV`, but interprets keys as signed `n`-bit integers.", + "gas": "", + "fift": "DICTIGETPREV" + }, + "bytecode": { + "doc_opcode": "F47A", + "tlb": "#F47A", + "prefix": "F47A", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETPREVEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETPREVEQ`, but interprets keys as signed `n`-bit integers.", + "gas": "", + "fift": "DICTIGETPREVEQ" + }, + "bytecode": { + "doc_opcode": "F47B", + "tlb": "#F47B", + "prefix": "F47B", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETNEXT", + "doc": { + "category": "dict_next", + "description": "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).", + "gas": "", + "fift": "DICTUGETNEXT" + }, + "bytecode": { + "doc_opcode": "F47C", + "tlb": "#F47C", + "prefix": "F47C", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETNEXTEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETNEXTEQ`, but interprets keys as unsigned `n`-bit integers.", + "gas": "", + "fift": "DICTUGETNEXTEQ" + }, + "bytecode": { + "doc_opcode": "F47D", + "tlb": "#F47D", + "prefix": "F47D", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETPREV", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETPREV`, but interprets keys as unsigned `n`-bit integers.", + "gas": "", + "fift": "DICTUGETPREV" + }, + "bytecode": { + "doc_opcode": "F47E", + "tlb": "#F47E", + "prefix": "F47E", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUGETPREVEQ", + "doc": { + "category": "dict_next", + "description": "Similar to `DICTGETPREVEQ`, but interprets keys a unsigned `n`-bit integers.", + "gas": "", + "fift": "DICTUGETPREVEQ" + }, + "bytecode": { + "doc_opcode": "F47F", + "tlb": "#F47F", + "prefix": "F47F", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - x' i' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i2", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTMIN", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTMIN" + }, + "bytecode": { + "doc_opcode": "F482", + "tlb": "#F482", + "prefix": "F482", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x k -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTMIN`, but returns the only reference in the value as a _Cell_ `c`.", + "gas": "", + "fift": "DICTMINREF" + }, + "bytecode": { + "doc_opcode": "F483", + "tlb": "#F483", + "prefix": "F483", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c k -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIMIN", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTIMIN" + }, + "bytecode": { + "doc_opcode": "F484", + "tlb": "#F484", + "prefix": "F484", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTIMIN`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTIMINREF" + }, + "bytecode": { + "doc_opcode": "F485", + "tlb": "#F485", + "prefix": "F485", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUMIN", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTMIN`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", + "gas": "", + "fift": "DICTUMIN" + }, + "bytecode": { + "doc_opcode": "F486", + "tlb": "#F486", + "prefix": "F486", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTUMIN`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTUMINREF" + }, + "bytecode": { + "doc_opcode": "F487", + "tlb": "#F487", + "prefix": "F487", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTMAX", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTMAX" + }, + "bytecode": { + "doc_opcode": "F48A", + "tlb": "#F48A", + "prefix": "F48A", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x k -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTMAX`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTMAXREF" + }, + "bytecode": { + "doc_opcode": "F48B", + "tlb": "#F48B", + "prefix": "F48B", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c k -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIMAX", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTIMAX" + }, + "bytecode": { + "doc_opcode": "F48C", + "tlb": "#F48C", + "prefix": "F48C", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTIMAX`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTIMAXREF" + }, + "bytecode": { + "doc_opcode": "F48D", + "tlb": "#F48D", + "prefix": "F48D", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUMAX", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTMAX`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", + "gas": "", + "fift": "DICTUMAX" + }, + "bytecode": { + "doc_opcode": "F48E", + "tlb": "#F48E", + "prefix": "F48E", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - x i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTUMAX`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTUMAXREF" + }, + "bytecode": { + "doc_opcode": "F48F", + "tlb": "#F48F", + "prefix": "F48F", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - c i -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREMMIN", + "doc": { + "category": "dict_min", + "description": "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'`.", + "gas": "", + "fift": "DICTREMMIN" + }, + "bytecode": { + "doc_opcode": "F492", + "tlb": "#F492", + "prefix": "F492", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x k -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREMMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTREMMIN`, but returns the only reference in the value as a _Cell_ `c`.", + "gas": "", + "fift": "DICTREMMINREF" + }, + "bytecode": { + "doc_opcode": "F493", + "tlb": "#F493", + "prefix": "F493", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c k -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREMMIN", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTIREMMIN" + }, + "bytecode": { + "doc_opcode": "F494", + "tlb": "#F494", + "prefix": "F494", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREMMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTIREMMIN`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTIREMMINREF" + }, + "bytecode": { + "doc_opcode": "F495", + "tlb": "#F495", + "prefix": "F495", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREMMIN", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTREMMIN`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", + "gas": "", + "fift": "DICTUREMMIN" + }, + "bytecode": { + "doc_opcode": "F496", + "tlb": "#F496", + "prefix": "F496", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREMMINREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTUREMMIN`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTUREMMINREF" + }, + "bytecode": { + "doc_opcode": "F497", + "tlb": "#F497", + "prefix": "F497", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREMMAX", + "doc": { + "category": "dict_min", + "description": "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'`.", + "gas": "", + "fift": "DICTREMMAX" + }, + "bytecode": { + "doc_opcode": "F49A", + "tlb": "#F49A", + "prefix": "F49A", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x k -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTREMMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTREMMAX`, but returns the only reference in the value as a _Cell_ `c`.", + "gas": "", + "fift": "DICTREMMAXREF" + }, + "bytecode": { + "doc_opcode": "F49B", + "tlb": "#F49B", + "prefix": "F49B", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c k -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREMMAX", + "doc": { + "category": "dict_min", + "description": "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`.", + "gas": "", + "fift": "DICTIREMMAX" + }, + "bytecode": { + "doc_opcode": "F49C", + "tlb": "#F49C", + "prefix": "F49C", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIREMMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTIREMMAX`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTIREMMAXREF" + }, + "bytecode": { + "doc_opcode": "F49D", + "tlb": "#F49D", + "prefix": "F49D", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREMMAX", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTREMMAX`, but returns the key as an unsigned `n`-bit _Integer_ `i`.", + "gas": "", + "fift": "DICTUREMMAX" + }, + "bytecode": { + "doc_opcode": "F49E", + "tlb": "#F49E", + "prefix": "F49E", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' x i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTUREMMAXREF", + "doc": { + "category": "dict_min", + "description": "Similar to `DICTUREMMAX`, but returns the only reference in the value.", + "gas": "", + "fift": "DICTUREMMAXREF" + }, + "bytecode": { + "doc_opcode": "F49F", + "tlb": "#F49F", + "prefix": "F49F", + "operands": [] + }, + "value_flow": { + "doc_stack": "D n - D' c i -1 or D 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "DICTIGETJMP", + "doc": { + "category": "dict_special", + "description": "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.", + "gas": "", + "fift": "DICTIGETJMP" + }, + "bytecode": { + "doc_opcode": "F4A0", + "tlb": "#F4A0", + "prefix": "F4A0", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DICTUGETJMP", + "doc": { + "category": "dict_special", + "description": "Similar to `DICTIGETJMP`, but performs `DICTUGET` instead of `DICTIGET`.", + "gas": "", + "fift": "DICTUGETJMP" + }, + "bytecode": { + "doc_opcode": "F4A1", + "tlb": "#F4A1", + "prefix": "F4A1", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DICTIGETEXEC", + "doc": { + "category": "dict_special", + "description": "Similar to `DICTIGETJMP`, but with `EXECUTE` instead of `JMPX`.", + "gas": "", + "fift": "DICTIGETEXEC" + }, + "bytecode": { + "doc_opcode": "F4A2", + "tlb": "#F4A2", + "prefix": "F4A2", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DICTUGETEXEC", + "doc": { + "category": "dict_special", + "description": "Similar to `DICTUGETJMP`, but with `EXECUTE` instead of `JMPX`.", + "gas": "", + "fift": "DICTUGETEXEC" + }, + "bytecode": { + "doc_opcode": "F4A3", + "tlb": "#F4A3", + "prefix": "F4A3", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DICTPUSHCONST", + "doc": { + "category": "dict_special", + "description": "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.", + "gas": "34", + "fift": "[ref] [n] DICTPUSHCONST" + }, + "bytecode": { + "doc_opcode": "F4A6_n", + "tlb": "#F4A6_ d:^Cell n:uint10", + "prefix": "F4A6_", + "operands": [ + { + "name": "d", + "loader": "ref", + "loader_args": {} + }, + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 10 + } + } + ] + }, + "value_flow": { + "doc_stack": " - D n", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTGETQ", + "doc": { + "category": "dict_special", + "description": "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.", + "gas": "", + "fift": "PFXDICTGETQ" + }, + "bytecode": { + "doc_opcode": "F4A8", + "tlb": "#F4A8", + "prefix": "F4A8", + "operands": [] + }, + "value_flow": { + "doc_stack": "s D n - s' x s'' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTGET", + "doc": { + "category": "dict_special", + "description": "Similar to `PFXDICTGET`, but throws a cell deserialization failure exception on failure.", + "gas": "", + "fift": "PFXDICTGET" + }, + "bytecode": { + "doc_opcode": "F4A9", + "tlb": "#F4A9", + "prefix": "F4A9", + "operands": [] + }, + "value_flow": { + "doc_stack": "s D n - s' x s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTGETJMP", + "doc": { + "category": "dict_special", + "description": "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.", + "gas": "", + "fift": "PFXDICTGETJMP" + }, + "bytecode": { + "doc_opcode": "F4AA", + "tlb": "#F4AA", + "prefix": "F4AA", + "operands": [] + }, + "value_flow": { + "doc_stack": "s D n - s' s'' or s" + } + }, + { + "mnemonic": "PFXDICTGETEXEC", + "doc": { + "category": "dict_special", + "description": "Similar to `PFXDICTGETJMP`, but `EXEC`utes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.", + "gas": "", + "fift": "PFXDICTGETEXEC" + }, + "bytecode": { + "doc_opcode": "F4AB", + "tlb": "#F4AB", + "prefix": "F4AB", + "operands": [] + }, + "value_flow": { + "doc_stack": "s D n - s' s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "PFXDICTCONSTGETJMP", + "doc": { + "category": "dict_special", + "description": "Combines `[n] DICTPUSHCONST` for `0 <= n <= 1023` with `PFXDICTGETJMP`.", + "gas": "", + "fift": "[ref] [n] PFXDICTCONSTGETJMP\n[ref] [n] PFXDICTSWITCH" + }, + "bytecode": { + "doc_opcode": "F4AE_n", + "tlb": "#F4AE_ d:^Cell n:uint10", + "prefix": "F4AE_", + "operands": [ + { + "name": "d", + "loader": "ref", + "loader_args": {} + }, + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 10 + } + } + ] + }, + "value_flow": { + "doc_stack": "s - s' s'' or s" + } + }, + { + "mnemonic": "DICTIGETJMPZ", + "doc": { + "category": "dict_special", + "description": "A variant of `DICTIGETJMP` that returns index `i` on failure.", + "gas": "", + "fift": "DICTIGETJMPZ" + }, + "bytecode": { + "doc_opcode": "F4BC", + "tlb": "#F4BC", + "prefix": "F4BC", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - i or nothing" + } + }, + { + "mnemonic": "DICTUGETJMPZ", + "doc": { + "category": "dict_special", + "description": "A variant of `DICTUGETJMP` that returns index `i` on failure.", + "gas": "", + "fift": "DICTUGETJMPZ" + }, + "bytecode": { + "doc_opcode": "F4BD", + "tlb": "#F4BD", + "prefix": "F4BD", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - i or nothing" + } + }, + { + "mnemonic": "DICTIGETEXECZ", + "doc": { + "category": "dict_special", + "description": "A variant of `DICTIGETEXEC` that returns index `i` on failure.", + "gas": "", + "fift": "DICTIGETEXECZ" + }, + "bytecode": { + "doc_opcode": "F4BE", + "tlb": "#F4BE", + "prefix": "F4BE", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - i or nothing" + } + }, + { + "mnemonic": "DICTUGETEXECZ", + "doc": { + "category": "dict_special", + "description": "A variant of `DICTUGETEXEC` that returns index `i` on failure.", + "gas": "", + "fift": "DICTUGETEXECZ" + }, + "bytecode": { + "doc_opcode": "F4BF", + "tlb": "#F4BF", + "prefix": "F4BF", + "operands": [] + }, + "value_flow": { + "doc_stack": "i D n - i or nothing" + } + }, + { + "mnemonic": "SUBDICTGET", + "doc": { + "category": "dict_sub", + "description": "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'`.", + "gas": "", + "fift": "SUBDICTGET" + }, + "bytecode": { + "doc_opcode": "F4B1", + "tlb": "#F4B1", + "prefix": "F4B1", + "operands": [] + }, + "value_flow": { + "doc_stack": "k l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "SUBDICTIGET", + "doc": { + "category": "dict_sub", + "description": "Variant of `SUBDICTGET` with the prefix represented by a signed big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 257`.", + "gas": "", + "fift": "SUBDICTIGET" + }, + "bytecode": { + "doc_opcode": "F4B2", + "tlb": "#F4B2", + "prefix": "F4B2", + "operands": [] + }, + "value_flow": { + "doc_stack": "x l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "SUBDICTUGET", + "doc": { + "category": "dict_sub", + "description": "Variant of `SUBDICTGET` with the prefix represented by an unsigned big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 256`.", + "gas": "", + "fift": "SUBDICTUGET" + }, + "bytecode": { + "doc_opcode": "F4B3", + "tlb": "#F4B3", + "prefix": "F4B3", + "operands": [] + }, + "value_flow": { + "doc_stack": "x l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "SUBDICTRPGET", + "doc": { + "category": "dict_sub", + "description": "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)`.", + "gas": "", + "fift": "SUBDICTRPGET" + }, + "bytecode": { + "doc_opcode": "F4B5", + "tlb": "#F4B5", + "prefix": "F4B5", + "operands": [] + }, + "value_flow": { + "doc_stack": "k l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "SUBDICTIRPGET", + "doc": { + "category": "dict_sub", + "description": "Variant of `SUBDICTRPGET` with the prefix represented by a signed big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 257`.", + "gas": "", + "fift": "SUBDICTIRPGET" + }, + "bytecode": { + "doc_opcode": "F4B6", + "tlb": "#F4B6", + "prefix": "F4B6", + "operands": [] + }, + "value_flow": { + "doc_stack": "x l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "SUBDICTURPGET", + "doc": { + "category": "dict_sub", + "description": "Variant of `SUBDICTRPGET` with the prefix represented by an unsigned big-endian `l`-bit _Integer_ `x`, where necessarily `l <= 256`.", + "gas": "", + "fift": "SUBDICTURPGET" + }, + "bytecode": { + "doc_opcode": "F4B7", + "tlb": "#F4B7", + "prefix": "F4B7", + "operands": [] + }, + "value_flow": { + "doc_stack": "x l D n - D'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "l", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Slice", "Null"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "D2", + "value_types": ["Slice", "Null"] + } + ] + } + } + }, + { + "mnemonic": "ACCEPT", + "doc": { + "category": "app_gas", + "description": "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.\nIn 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.", + "gas": "26", + "fift": "ACCEPT" + }, + "bytecode": { + "doc_opcode": "F800", + "tlb": "#F800", + "prefix": "F800", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETGASLIMIT", + "doc": { + "category": "app_gas", + "description": "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`.", + "gas": "26", + "fift": "SETGASLIMIT" + }, + "bytecode": { + "doc_opcode": "F801", + "tlb": "#F801", + "prefix": "F801", + "operands": [] + }, + "value_flow": { + "doc_stack": "g - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "g", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "COMMIT", + "doc": { + "category": "app_gas", + "description": "Commits the current state of registers `c4` (\u0432\u0402\u045apersistent data'') and `c5` (\u0432\u0402\u045aactions'') so that the current execution is considered \u0432\u0402\u045asuccessful'' with the saved values even if an exception is thrown later.", + "gas": "26", + "fift": "COMMIT" + }, + "bytecode": { + "doc_opcode": "F80F", + "tlb": "#F80F", + "prefix": "F80F", + "operands": [] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "RANDU256", + "doc": { + "category": "app_rnd", + "description": "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`.", + "gas": "26+|c7|+|c1_1|", + "fift": "RANDU256" + }, + "bytecode": { + "doc_opcode": "F810", + "tlb": "#F810", + "prefix": "F810", + "operands": [] + }, + "value_flow": { + "doc_stack": "- x", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "RAND", + "doc": { + "category": "app_rnd", + "description": "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.\nEquivalent to `RANDU256` `256 MULRSHIFT`.", + "gas": "26+|c7|+|c1_1|", + "fift": "RAND" + }, + "bytecode": { + "doc_opcode": "F811", + "tlb": "#F811", + "prefix": "F811", + "operands": [] + }, + "value_flow": { + "doc_stack": "y - z", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SETRAND", + "doc": { + "category": "app_rnd", + "description": "Sets the random seed to unsigned 256-bit _Integer_ `x`.", + "gas": "26+|c7|+|c1_1|", + "fift": "SETRAND" + }, + "bytecode": { + "doc_opcode": "F814", + "tlb": "#F814", + "prefix": "F814", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "ADDRAND", + "doc": { + "category": "app_rnd", + "description": "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`.", + "gas": "26", + "fift": "ADDRAND\nRANDOMIZE" + }, + "bytecode": { + "doc_opcode": "F815", + "tlb": "#F815", + "prefix": "F815", + "operands": [] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "GETPARAM", + "doc": { + "category": "app_config", + "description": "Returns the `i`-th parameter from the _Tuple_ provided at `c7` for `0 <= i <= 15`. Equivalent to `c7 PUSHCTR` `FIRST` `[i] INDEX`.\nIf one of these internal operations fails, throws an appropriate type checking or range checking exception.", + "gas": "26", + "fift": "[i] GETPARAM" + }, + "bytecode": { + "doc_opcode": "F82i", + "tlb": "#F82 i:uint4", + "prefix": "F82", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": " - x", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CONFIGDICT", + "doc": { + "category": "app_config", + "description": "Returns the global configuration dictionary along with its key length (32).\nEquivalent to `CONFIGROOT` `32 PUSHINT`.", + "gas": "26", + "fift": "CONFIGDICT" + }, + "bytecode": { + "doc_opcode": "F830", + "tlb": "#F830", + "prefix": "F830", + "operands": [] + }, + "value_flow": { + "doc_stack": " - D 32", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Slice", "Null"] + }, + { + "type": "const", + "value": 32, + "value_type": "Integer" + } + ] + } + } + }, + { + "mnemonic": "CONFIGPARAM", + "doc": { + "category": "app_config", + "description": "Returns the value of the global configuration parameter with integer index `i` as a _Cell_ `c`, and a flag to indicate success.\nEquivalent to `CONFIGDICT` `DICTIGETREF`.", + "gas": "", + "fift": "CONFIGPARAM" + }, + "bytecode": { + "doc_opcode": "F832", + "tlb": "#F832", + "prefix": "F832", + "operands": [] + }, + "value_flow": { + "doc_stack": "i - c -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CONFIGOPTPARAM", + "doc": { + "category": "app_config", + "description": "Returns the value of the global configuration parameter with integer index `i` as a _Maybe Cell_ `c^?`.\nEquivalent to `CONFIGDICT` `DICTIGETOPTREF`.", + "gas": "", + "fift": "CONFIGOPTPARAM" + }, + "bytecode": { + "doc_opcode": "F833", + "tlb": "#F833", + "prefix": "F833", + "operands": [] + }, + "value_flow": { + "doc_stack": "i - c^?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "i", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell", "Null"] + } + ] + } + } + }, + { + "mnemonic": "GETGLOBVAR", + "doc": { + "category": "app_global", + "description": "Returns the `k`-th global variable for `0 <= k < 255`.\nEquivalent to `c7 PUSHCTR` `SWAP` `INDEXVARQ`.", + "gas": "26", + "fift": "GETGLOBVAR" + }, + "bytecode": { + "doc_opcode": "F840", + "tlb": "#F840", + "prefix": "F840", + "operands": [] + }, + "value_flow": { + "doc_stack": "k - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "GETGLOB", + "doc": { + "category": "app_global", + "description": "Returns the `k`-th global variable for `1 <= k <= 31`.\nEquivalent to `c7 PUSHCTR` `[k] INDEXQ`.", + "gas": "26", + "fift": "[k] GETGLOB" + }, + "bytecode": { + "doc_opcode": "F85_k", + "tlb": "#F85_ k:(## 5) {1 <= k}", + "prefix": "F85_", + "operands_range_check": { + "length": 5, + "from": 1, + "to": 31 + }, + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 5 + } + } + ] + }, + "value_flow": { + "doc_stack": " - x", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + } + } + }, + { + "mnemonic": "SETGLOBVAR", + "doc": { + "category": "app_global", + "description": "Assigns `x` to the `k`-th global variable for `0 <= k < 255`.\nEquivalent to `c7 PUSHCTR` `ROTREV` `SETINDEXVARQ` `c7 POPCTR`.", + "gas": "26+|c7\u0432\u0402\u2122|", + "fift": "SETGLOBVAR" + }, + "bytecode": { + "doc_opcode": "F860", + "tlb": "#F860", + "prefix": "F860", + "operands": [] + }, + "value_flow": { + "doc_stack": "x k - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETGLOB", + "doc": { + "category": "app_global", + "description": "Assigns `x` to the `k`-th global variable for `1 <= k <= 31`.\nEquivalent to `c7 PUSHCTR` `SWAP` `k SETINDEXQ` `c7 POPCTR`.", + "gas": "26+|c7\u0432\u0402\u2122|", + "fift": "[k] SETGLOB" + }, + "bytecode": { + "doc_opcode": "F87_k", + "tlb": "#F87_ k:(## 5) {1 <= k}", + "prefix": "F87_", + "operands_range_check": { + "length": 5, + "from": 1, + "to": 31 + }, + "operands": [ + { + "name": "k", + "loader": "uint", + "loader_args": { + "size": 5 + } + } + ] + }, + "value_flow": { + "doc_stack": "x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x" + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "HASHCU", + "doc": { + "category": "app_crypto", + "description": "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.", + "gas": "26", + "fift": "HASHCU" + }, + "bytecode": { + "doc_opcode": "F900", + "tlb": "#F900", + "prefix": "F900", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "HASHSU", + "doc": { + "category": "app_crypto", + "description": "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`.", + "gas": "526", + "fift": "HASHSU" + }, + "bytecode": { + "doc_opcode": "F901", + "tlb": "#F901", + "prefix": "F901", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SHA256U", + "doc": { + "category": "app_crypto", + "description": "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`.", + "gas": "26", + "fift": "SHA256U" + }, + "bytecode": { + "doc_opcode": "F902", + "tlb": "#F902", + "prefix": "F902", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CHKSIGNU", + "doc": { + "category": "app_crypto", + "description": "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).\nThe 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.\nNotice 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`.", + "gas": "26", + "fift": "CHKSIGNU" + }, + "bytecode": { + "doc_opcode": "F910", + "tlb": "#F910", + "prefix": "F910", + "operands": [] + }, + "value_flow": { + "doc_stack": "h s k - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "h", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CHKSIGNS", + "doc": { + "category": "app_crypto", + "description": "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.", + "gas": "26", + "fift": "CHKSIGNS" + }, + "bytecode": { + "doc_opcode": "F911", + "tlb": "#F911", + "prefix": "F911", + "operands": [] + }, + "value_flow": { + "doc_stack": "d s k - ?", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "d", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "k", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "result", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CDATASIZEQ", + "doc": { + "category": "app_misc", + "description": "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`.", + "gas": "", + "fift": "CDATASIZEQ" + }, + "bytecode": { + "doc_opcode": "F940", + "tlb": "#F940", + "prefix": "F940", + "operands": [] + }, + "value_flow": { + "doc_stack": "c n - x y z -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "CDATASIZE", + "doc": { + "category": "app_misc", + "description": "A non-quiet version of `CDATASIZEQ` that throws a cell overflow exception (8) on failure.", + "gas": "", + "fift": "CDATASIZE" + }, + "bytecode": { + "doc_opcode": "F941", + "tlb": "#F941", + "prefix": "F941", + "operands": [] + }, + "value_flow": { + "doc_stack": "c n - x y z", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDATASIZEQ", + "doc": { + "category": "app_misc", + "description": "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`.", + "gas": "", + "fift": "SDATASIZEQ" + }, + "bytecode": { + "doc_opcode": "F942", + "tlb": "#F942", + "prefix": "F942", + "operands": [] + }, + "value_flow": { + "doc_stack": "s n - x y z -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SDATASIZE", + "doc": { + "category": "app_misc", + "description": "A non-quiet version of `SDATASIZEQ` that throws a cell overflow exception (8) on failure.", + "gas": "", + "fift": "SDATASIZE" + }, + "bytecode": { + "doc_opcode": "F943", + "tlb": "#F943", + "prefix": "F943", + "operands": [] + }, + "value_flow": { + "doc_stack": "s n - x y z", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "n", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "z", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "LDGRAMS", + "doc": { + "category": "app_currency", + "description": "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`.\nThe net effect is approximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDUX`.", + "gas": "26", + "fift": "LDGRAMS\nLDVARUINT16" + }, + "bytecode": { + "doc_opcode": "FA00", + "tlb": "#FA00", + "prefix": "FA00", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDVARINT16", + "doc": { + "category": "app_currency", + "description": "Similar to `LDVARUINT16`, but loads a _signed_ _Integer_ `x`.\nApproximately equivalent to `4 LDU` `SWAP` `3 LSHIFT#` `LDIX`.", + "gas": "26", + "fift": "LDVARINT16" + }, + "bytecode": { + "doc_opcode": "FA01", + "tlb": "#FA01", + "prefix": "FA01", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "STGRAMS", + "doc": { + "category": "app_currency", + "description": "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.", + "gas": "26", + "fift": "STGRAMS\nSTVARUINT16" + }, + "bytecode": { + "doc_opcode": "FA02", + "tlb": "#FA02", + "prefix": "FA02", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "STVARINT16", + "doc": { + "category": "app_currency", + "description": "Similar to `STVARUINT16`, but serializes a _signed_ _Integer_ `x` in the range `-2^119...2^119-1`.", + "gas": "26", + "fift": "STVARINT16" + }, + "bytecode": { + "doc_opcode": "FA03", + "tlb": "#FA03", + "prefix": "FA03", + "operands": [] + }, + "value_flow": { + "doc_stack": "b x - b'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "b", + "value_types": ["Builder"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "b2", + "value_types": ["Builder"] + } + ] + } + } + }, + { + "mnemonic": "LDMSGADDR", + "doc": { + "category": "app_addr", + "description": "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.", + "gas": "26", + "fift": "LDMSGADDR" + }, + "bytecode": { + "doc_opcode": "FA40", + "tlb": "#FA40", + "prefix": "FA40", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s' s''", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "LDMSGADDRQ", + "doc": { + "category": "app_addr", + "description": "A quiet version of `LDMSGADDR`: on success, pushes an extra `-1`; on failure, pushes the original `s` and a zero.", + "gas": "26", + "fift": "LDMSGADDRQ" + }, + "bytecode": { + "doc_opcode": "FA41", + "tlb": "#FA41", + "prefix": "FA41", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - s' s'' -1 or s 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + }, + { + "type": "simple", + "name": "s3", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "PARSEMSGADDR", + "doc": { + "category": "app_addr", + "description": "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.", + "gas": "26", + "fift": "PARSEMSGADDR" + }, + "bytecode": { + "doc_opcode": "FA42", + "tlb": "#FA42", + "prefix": "FA42", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - t", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + } + } + }, + { + "mnemonic": "PARSEMSGADDRQ", + "doc": { + "category": "app_addr", + "description": "A quiet version of `PARSEMSGADDR`: returns a zero on error instead of throwing an exception.", + "gas": "26", + "fift": "PARSEMSGADDRQ" + }, + "bytecode": { + "doc_opcode": "FA43", + "tlb": "#FA43", + "prefix": "FA43", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - t -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "t", + "value_types": ["Tuple"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "REWRITESTDADDR", + "doc": { + "category": "app_addr", + "description": "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.", + "gas": "26", + "fift": "REWRITESTDADDR" + }, + "bytecode": { + "doc_opcode": "FA44", + "tlb": "#FA44", + "prefix": "FA44", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x y", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "REWRITESTDADDRQ", + "doc": { + "category": "app_addr", + "description": "A quiet version of primitive `REWRITESTDADDR`.", + "gas": "26", + "fift": "REWRITESTDADDRQ" + }, + "bytecode": { + "doc_opcode": "FA45", + "tlb": "#FA45", + "prefix": "FA45", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x y -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "REWRITEVARADDR", + "doc": { + "category": "app_addr", + "description": "A variant of `REWRITESTDADDR` that returns the (rewritten) address as a _Slice_ `s`, even if it is not exactly 256 bit long (represented by a `msg_addr_var`).", + "gas": "26", + "fift": "REWRITEVARADDR" + }, + "bytecode": { + "doc_opcode": "FA46", + "tlb": "#FA46", + "prefix": "FA46", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s'", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s2", + "value_types": ["Slice"] + } + ] + } + } + }, + { + "mnemonic": "REWRITEVARADDRQ", + "doc": { + "category": "app_addr", + "description": "A quiet version of primitive `REWRITEVARADDR`.", + "gas": "26", + "fift": "REWRITEVARADDRQ" + }, + "bytecode": { + "doc_opcode": "FA47", + "tlb": "#FA47", + "prefix": "FA47", + "operands": [] + }, + "value_flow": { + "doc_stack": "s - x s' -1 or 0", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": ["Slice"] + } + ] + }, + "outputs": { + "stack": [ + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "s'", + "value_types": ["Slice"] + } + ] + } + ] + }, + { + "type": "simple", + "name": "status", + "value_types": ["Integer"] + } + ] + } + } + }, + { + "mnemonic": "SENDRAWMSG", + "doc": { + "category": "app_actions", + "description": "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`.", + "gas": "526", + "fift": "SENDRAWMSG" + }, + "bytecode": { + "doc_opcode": "FB00", + "tlb": "#FB00", + "prefix": "FB00", + "operands": [] + }, + "value_flow": { + "doc_stack": "c x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "RAWRESERVE", + "doc": { + "category": "app_actions", + "description": "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`.", + "gas": "526", + "fift": "RAWRESERVE" + }, + "bytecode": { + "doc_opcode": "FB02", + "tlb": "#FB02", + "prefix": "FB02", + "operands": [] + }, + "value_flow": { + "doc_stack": "x y - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "RAWRESERVEX", + "doc": { + "category": "app_actions", + "description": "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.", + "gas": "526", + "fift": "RAWRESERVEX" + }, + "bytecode": { + "doc_opcode": "FB03", + "tlb": "#FB03", + "prefix": "FB03", + "operands": [] + }, + "value_flow": { + "doc_stack": "x D y - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "D", + "value_types": ["Cell", "Null"] + }, + { + "type": "simple", + "name": "y", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCODE", + "doc": { + "category": "app_actions", + "description": "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.", + "gas": "526", + "fift": "SETCODE" + }, + "bytecode": { + "doc_opcode": "FB04", + "tlb": "#FB04", + "prefix": "FB04", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETLIBCODE", + "doc": { + "category": "app_actions", + "description": "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.", + "gas": "526", + "fift": "SETLIBCODE" + }, + "bytecode": { + "doc_opcode": "FB06", + "tlb": "#FB06", + "prefix": "FB06", + "operands": [] + }, + "value_flow": { + "doc_stack": "c x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Cell"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "CHANGELIB", + "doc": { + "category": "app_actions", + "description": "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.", + "gas": "526", + "fift": "CHANGELIB" + }, + "bytecode": { + "doc_opcode": "FB07", + "tlb": "#FB07", + "prefix": "FB07", + "operands": [] + }, + "value_flow": { + "doc_stack": "h x - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "h", + "value_types": ["Integer"] + }, + { + "type": "simple", + "name": "x", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DUMPSTK", + "doc": { + "category": "debug", + "description": "Dumps the stack (at most the top 255 values) and shows the total stack depth.", + "gas": "26", + "fift": "DUMPSTK" + }, + "bytecode": { + "doc_opcode": "FE00", + "tlb": "#FE00", + "prefix": "FE00" + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DEBUG", + "doc": { + "category": "debug", + "description": "", + "gas": "26", + "fift": "{nn} DEBUG" + }, + "bytecode": { + "doc_opcode": "FEnn", + "tlb": "#FE nn:(#<= 239)", + "prefix": "FE", + "operands_range_check": { + "length": 8, + "from": 1, + "to": 19 + }, + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "STRDUMP", + "doc": { + "category": "debug", + "description": "", + "gas": "26", + "fift": "STRDUMP" + }, + "bytecode": { + "doc_opcode": "FE14", + "tlb": "#FE14", + "prefix": "FE14" + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DEBUG", + "doc": { + "category": "debug", + "description": "", + "gas": "26", + "fift": "{nn} DEBUG" + }, + "bytecode": { + "doc_opcode": "FEnn", + "tlb": "#FE nn:(#<= 239)", + "prefix": "FE", + "operands_range_check": { + "length": 8, + "from": 21, + "to": 31 + }, + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DUMP", + "doc": { + "category": "debug", + "description": "Dumps `s[i]`.", + "gas": "26", + "fift": "s[i] DUMP" + }, + "bytecode": { + "doc_opcode": "FE2i", + "tlb": "#FE2 i:uint4", + "prefix": "FE2", + "operands": [ + { + "name": "i", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DEBUG", + "doc": { + "category": "debug", + "description": "", + "gas": "26", + "fift": "{nn} DEBUG" + }, + "bytecode": { + "doc_opcode": "FEnn", + "tlb": "#FE nn:(#<= 239)", + "prefix": "FE", + "operands_range_check": { + "length": 8, + "from": 48, + "to": 239 + }, + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "DEBUGSTR", + "doc": { + "category": "debug", + "description": "`0 <= n < 16`. Length of `ssss` is `n+1` bytes.\n`{string}` is a [string literal](https://github.com/Piterden/TON-docs/blob/master/Fift.%20A%20Brief%20Introduction.md#user-content-29-string-literals).\n`DEBUGSTR`: `ssss` is the given string.\n`DEBUGSTRI`: `ssss` is one-byte integer `0 <= x <= 255` followed by the given string.", + "gas": "26", + "fift": "{string} DEBUGSTR\n{string} {x} DEBUGSTRI" + }, + "bytecode": { + "doc_opcode": "FEFnssss", + "tlb": "#FEF n:(## 4) ssss:((n * 8 + 8) * Bit)", + "prefix": "FEF", + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 4 + } + }, + { + "name": "s", + "loader": "subslice", + "loader_args": { + "bits_length_var": "n", + "bits_padding": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCP", + "doc": { + "category": "codepage", + "description": "Selects TVM codepage `0 <= nn < 240`. If the codepage is not supported, throws an invalid opcode exception.", + "gas": "26", + "fift": "[nn] SETCP" + }, + "bytecode": { + "doc_opcode": "FFnn", + "tlb": "#FF nn:(#<= 239)", + "prefix": "FF", + "operands_range_check": { + "length": 8, + "from": 0, + "to": 239 + }, + "operands": [ + { + "name": "n", + "loader": "uint", + "loader_args": { + "size": 8 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCP_SPECIAL", + "doc": { + "category": "codepage", + "description": "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.", + "gas": "26", + "fift": "[z-16] SETCP" + }, + "bytecode": { + "doc_opcode": "FFFz", + "tlb": "#FFF z:(## 4) {1 <= z}", + "prefix": "FFF", + "operands_range_check": { + "length": 4, + "from": 1, + "to": 15 + }, + "operands": [ + { + "name": "z", + "loader": "uint", + "loader_args": { + "size": 4 + } + } + ] + }, + "value_flow": { + "doc_stack": "-", + "inputs": { + "stack": [] + }, + "outputs": { + "stack": [] + } + } + }, + { + "mnemonic": "SETCPX", + "doc": { + "category": "codepage", + "description": "Selects codepage `c` with `-2^15 <= c < 2^15` passed in the top of the stack.", + "gas": "26", + "fift": "SETCPX" + }, + "bytecode": { + "doc_opcode": "FFF0", + "tlb": "#FFF0", + "prefix": "FFF0", + "operands": [] + }, + "value_flow": { + "doc_stack": "c - ", + "inputs": { + "stack": [ + { + "type": "simple", + "name": "c", + "value_types": ["Integer"] + } + ] + }, + "outputs": { + "stack": [] + } + } + } + ], + "aliases": [ + { + "mnemonic": "SWAP", + "alias_of": "XCHG_0I", + "doc_fift": "SWAP", + "doc_stack": "x y - y x", + "description": "Same as `s1 XCHG0`.", + "operands": { + "i": 1 + } + }, + { + "mnemonic": "DUP", + "alias_of": "PUSH", + "doc_fift": "DUP", + "doc_stack": "x - x x", + "description": "Same as `s0 PUSH`.", + "operands": { + "i": 0 + } + }, + { + "mnemonic": "OVER", + "alias_of": "PUSH", + "doc_fift": "OVER", + "doc_stack": "x y - x y x", + "description": "Same as `s1 PUSH`.", + "operands": { + "i": 1 + } + }, + { + "mnemonic": "DROP", + "alias_of": "POP", + "doc_fift": "DROP", + "doc_stack": "x -", + "description": "Same as `s0 POP`, discards the top-of-stack value.", + "operands": { + "i": 0 + } + }, + { + "mnemonic": "NIP", + "alias_of": "POP", + "doc_fift": "NIP", + "doc_stack": "x y - y", + "description": "Same as `s1 POP`.", + "operands": { + "i": 1 + } + }, + { + "mnemonic": "ROT2", + "alias_of": "BLKSWAP", + "doc_fift": "ROT2\n2ROT", + "doc_stack": "a b c d e f - c d e f a b", + "description": "Rotates the three topmost pairs of stack entries.", + "operands": { + "i": 1, + "j": 3 + } + }, + { + "mnemonic": "ROLL", + "alias_of": "BLKSWAP", + "doc_fift": "[i+1] ROLL", + "doc_stack": "", + "description": "Rotates the top `i+1` stack entries.\nEquivalent to `1 [i+1] BLKSWAP`.", + "operands": { + "i": 0 + } + }, + { + "mnemonic": "ROLLREV", + "alias_of": "BLKSWAP", + "doc_fift": "[i+1] -ROLL\n[i+1] ROLLREV", + "doc_stack": "", + "description": "Rotates the top `i+1` stack entries in the other direction.\nEquivalent to `[i+1] 1 BLKSWAP`.", + "operands": {} + }, + { + "mnemonic": "NIL", + "alias_of": "TUPLE", + "doc_fift": "NIL", + "doc_stack": "- t", + "description": "Pushes the only _Tuple_ `t=()` of length zero.", + "operands": { + "n": 0 + } + }, + { + "mnemonic": "SINGLE", + "alias_of": "TUPLE", + "doc_fift": "SINGLE", + "doc_stack": "x - t", + "description": "Creates a singleton `t:=(x)`, i.e., a _Tuple_ of length one.", + "operands": { + "n": 1 + } + }, + { + "mnemonic": "PAIR", + "alias_of": "TUPLE", + "doc_fift": "PAIR\nCONS", + "doc_stack": "x y - t", + "description": "Creates pair `t:=(x,y)`.", + "operands": { + "n": 2 + } + }, + { + "mnemonic": "TRIPLE", + "alias_of": "TUPLE", + "doc_fift": "TRIPLE", + "doc_stack": "x y z - t", + "description": "Creates triple `t:=(x,y,z)`.", + "operands": { + "n": 3 + } + }, + { + "mnemonic": "FIRST", + "alias_of": "INDEX", + "doc_fift": "FIRST\nCAR", + "doc_stack": "t - x", + "description": "Returns the first element of a _Tuple_.", + "operands": { + "k": 0 + } + }, + { + "mnemonic": "SECOND", + "alias_of": "INDEX", + "doc_fift": "SECOND\nCDR", + "doc_stack": "t - y", + "description": "Returns the second element of a _Tuple_.", + "operands": { + "k": 1 + } + }, + { + "mnemonic": "THIRD", + "alias_of": "INDEX", + "doc_fift": "THIRD", + "doc_stack": "t - z", + "description": "Returns the third element of a _Tuple_.", + "operands": { + "k": 2 + } + }, + { + "mnemonic": "UNSINGLE", + "alias_of": "UNTUPLE", + "doc_fift": "UNSINGLE", + "doc_stack": "t - x", + "description": "Unpacks a singleton `t=(x)`.", + "operands": { + "n": 1 + } + }, + { + "mnemonic": "UNPAIR", + "alias_of": "UNTUPLE", + "doc_fift": "UNPAIR\nUNCONS", + "doc_stack": "t - x y", + "description": "Unpacks a pair `t=(x,y)`.", + "operands": { + "n": 2 + } + }, + { + "mnemonic": "UNTRIPLE", + "alias_of": "UNTUPLE", + "doc_fift": "UNTRIPLE", + "doc_stack": "t - x y z", + "description": "Unpacks a triple `t=(x,y,z)`.", + "operands": { + "n": 3 + } + }, + { + "mnemonic": "CHKTUPLE", + "alias_of": "UNPACKFIRST", + "doc_fift": "CHKTUPLE", + "doc_stack": "t -", + "description": "Checks whether `t` is a _Tuple_. If not, throws a type check exception.", + "operands": { + "k": 0 + } + }, + { + "mnemonic": "SETFIRST", + "alias_of": "SETINDEX", + "doc_fift": "SETFIRST", + "doc_stack": "t x - t'", + "description": "Sets the first component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 0 + } + }, + { + "mnemonic": "SETSECOND", + "alias_of": "SETINDEX", + "doc_fift": "SETSECOND", + "doc_stack": "t x - t'", + "description": "Sets the second component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 1 + } + }, + { + "mnemonic": "SETTHIRD", + "alias_of": "SETINDEX", + "doc_fift": "SETTHIRD", + "doc_stack": "t x - t'", + "description": "Sets the third component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 2 + } + }, + { + "mnemonic": "FIRSTQ", + "alias_of": "INDEXQ", + "doc_fift": "FIRSTQ\nCARQ", + "doc_stack": "t - x", + "description": "Returns the first element of a _Tuple_.", + "operands": { + "k": 0 + } + }, + { + "mnemonic": "SECONDQ", + "alias_of": "INDEXQ", + "doc_fift": "SECONDQ\nCDRQ", + "doc_stack": "t - y", + "description": "Returns the second element of a _Tuple_.", + "operands": { + "k": 1 + } + }, + { + "mnemonic": "THIRDQ", + "alias_of": "INDEXQ", + "doc_fift": "THIRDQ", + "doc_stack": "t - z", + "description": "Returns the third element of a _Tuple_.", + "operands": { + "k": 2 + } + }, + { + "mnemonic": "SETFIRSTQ", + "alias_of": "SETINDEXQ", + "doc_fift": "SETFIRSTQ", + "doc_stack": "t x - t'", + "description": "Sets the first component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 0 + } + }, + { + "mnemonic": "SETSECONDQ", + "alias_of": "SETINDEXQ", + "doc_fift": "SETSECONDQ", + "doc_stack": "t x - t'", + "description": "Sets the second component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 1 + } + }, + { + "mnemonic": "SETTHIRDQ", + "alias_of": "SETINDEXQ", + "doc_fift": "SETTHIRDQ", + "doc_stack": "t x - t'", + "description": "Sets the third component of _Tuple_ `t` to `x` and returns the resulting _Tuple_ `t'`.", + "operands": { + "k": 2 + } + }, + { + "mnemonic": "CADR", + "alias_of": "INDEX2", + "doc_fift": "CADR", + "doc_stack": "t - x", + "description": "Recovers `x=(t_2)_1`.", + "operands": { + "i": 1, + "j": 0 + } + }, + { + "mnemonic": "CDDR", + "alias_of": "INDEX2", + "doc_fift": "CDDR", + "doc_stack": "t - x", + "description": "Recovers `x=(t_2)_2`.", + "operands": { + "i": 1, + "j": 1 + } + }, + { + "mnemonic": "CADDR", + "alias_of": "INDEX3", + "doc_fift": "CADDR", + "doc_stack": "t - x", + "description": "Recovers `x=t_2_2_1`.", + "operands": { + "i": 1, + "j": 1, + "k": 0 + } + }, + { + "mnemonic": "CDDDR", + "alias_of": "INDEX3", + "doc_fift": "CDDDR", + "doc_stack": "t - x", + "description": "Recovers `x=t_2_2_2`.", + "operands": { + "i": 1, + "j": 1, + "k": 1 + } + }, + { + "mnemonic": "ZERO", + "alias_of": "PUSHINT_4", + "doc_fift": "ZERO\nFALSE", + "doc_stack": "- 0", + "description": "", + "operands": { + "i": 0 + } + }, + { + "mnemonic": "ONE", + "alias_of": "PUSHINT_4", + "doc_fift": "ONE", + "doc_stack": "- 1", + "description": "", + "operands": { + "i": 1 + } + }, + { + "mnemonic": "TWO", + "alias_of": "PUSHINT_4", + "doc_fift": "TWO", + "doc_stack": "- 2", + "description": "", + "operands": { + "i": 2 + } + }, + { + "mnemonic": "TEN", + "alias_of": "PUSHINT_4", + "doc_fift": "TEN", + "doc_stack": "- 10", + "description": "", + "operands": { + "i": 10 + } + }, + { + "mnemonic": "TRUE", + "alias_of": "PUSHINT_4", + "doc_fift": "TRUE", + "doc_stack": "- -1", + "description": "", + "operands": { + "i": 15 + } + }, + { + "mnemonic": "CHKBOOL", + "alias_of": "FITS", + "doc_fift": "CHKBOOL", + "doc_stack": "x - x", + "description": "Checks whether `x` is a \u0432\u0402\u045aboolean value'' (i.e., either 0 or -1).", + "operands": { + "c": 0 + } + }, + { + "mnemonic": "CHKBIT", + "alias_of": "UFITS", + "doc_fift": "CHKBIT", + "doc_stack": "x - x", + "description": "Checks whether `x` is a binary digit (i.e., zero or one).", + "operands": { + "c": 0 + } + }, + { + "mnemonic": "ISZERO", + "alias_of": "EQINT", + "doc_fift": "ISZERO", + "doc_stack": "x - x=0", + "description": "Checks whether an integer is zero. Corresponds to Forth's `0=`.", + "operands": { + "y": 0 + } + }, + { + "mnemonic": "ISNEG", + "alias_of": "LESSINT", + "doc_fift": "ISNEG", + "doc_stack": "x - x<0", + "description": "Checks whether an integer is negative. Corresponds to Forth's `0<`.", + "operands": { + "y": 0 + } + }, + { + "mnemonic": "ISNPOS", + "alias_of": "LESSINT", + "doc_fift": "ISNPOS", + "doc_stack": "x - x<=0", + "description": "Checks whether an integer is non-positive.", + "operands": { + "y": 1 + } + }, + { + "mnemonic": "ISPOS", + "alias_of": "GTINT", + "doc_fift": "ISPOS", + "doc_stack": "x - x>0", + "description": "Checks whether an integer is positive. Corresponds to Forth's `0>`.", + "operands": { + "y": 0 + } + }, + { + "mnemonic": "ISNNEG", + "alias_of": "GTINT", + "doc_fift": "ISNNEG", + "doc_stack": "x - x >=0", + "description": "Checks whether an integer is non-negative.", + "operands": { + "y": -1 + } + }, + { + "mnemonic": "STZERO", + "alias_of": "STSLICECONST", + "doc_fift": "STZERO", + "doc_stack": "b - b'", + "description": "Stores one binary zero.", + "operands": { + "x": 0, + "y": 0, + "sss": "0" + } + }, + { + "mnemonic": "STONE", + "alias_of": "STSLICECONST", + "doc_fift": "STONE", + "doc_stack": "b - b'", + "description": "Stores one binary one.", + "operands": { + "x": 0, + "y": 0, + "sss": "1" + } + }, + { + "mnemonic": "PLDREF", + "alias_of": "PLDREFIDX", + "doc_fift": "PLDREF", + "doc_stack": "s - c", + "description": "Preloads the first cell reference of a _Slice_.", + "operands": { + "n": 0 + } + }, + { + "mnemonic": "SETNUMARGS", + "alias_of": "SETCONTARGS_N", + "doc_fift": "[n] SETNUMARGS", + "doc_stack": "c - c'", + "description": "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.", + "operands": { + "r": 0 + } + }, + { + "mnemonic": "SETCONTARGS", + "alias_of": "SETCONTARGS_N", + "doc_fift": "[r] -1 SETCONTARGS", + "doc_stack": "x_1 x_2...x_r c - c'", + "description": "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.", + "operands": { + "n": -1 + } + }, + { + "mnemonic": "BLESSNUMARGS", + "alias_of": "BLESSARGS", + "doc_fift": "[n] BLESSNUMARGS", + "doc_stack": "s - c", + "description": "Also transforms a _Slice_ `s` into a _Continuation_ `c`, but sets `c.nargs` to `0 <= n <= 14`.", + "operands": { + "r": 0 + } + }, + { + "mnemonic": "PUSHROOT", + "alias_of": "PUSHCTR", + "doc_fift": "c4 PUSHCTR\nc4 PUSH", + "doc_stack": "- x", + "description": "Pushes the \u0432\u0402\u045aglobal data root'' cell reference, thus enabling access to persistent smart-contract data.", + "operands": { + "i": 4 + } + }, + { + "mnemonic": "POPROOT", + "alias_of": "POPCTR", + "doc_fift": "c4 POPCTR\nc4 POP", + "doc_stack": "x -", + "description": "Sets the \u0432\u0402\u045aglobal data root'' cell reference, thus allowing modification of persistent smart-contract data.", + "operands": { + "i": 4 + } + }, + { + "mnemonic": "NEWDICT", + "alias_of": "NULL", + "doc_fift": "NEWDICT", + "doc_stack": " - D", + "description": "Returns a new empty dictionary.\nIt is an alternative mnemonics for `PUSHNULL`.", + "operands": {} + }, + { + "mnemonic": "DICTEMPTY", + "alias_of": "ISNULL", + "doc_fift": "DICTEMPTY", + "doc_stack": "D - ?", + "description": "Checks whether dictionary `D` is empty, and returns `-1` or `0` accordingly.\nIt is an alternative mnemonics for `ISNULL`.", + "operands": {} + }, + { + "mnemonic": "STDICTS", + "alias_of": "STSLICE", + "doc_fift": "STDICTS\n", + "doc_stack": "s b - b'", + "description": "Stores a _Slice_-represented dictionary `s` into _Builder_ `b`.\nIt is actually a synonym for `STSLICE`.", + "operands": {} + }, + { + "mnemonic": "NOW", + "alias_of": "GETPARAM", + "doc_fift": "NOW", + "doc_stack": " - x", + "description": "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.\nEquivalent to `3 GETPARAM`.", + "operands": { + "i": 3 + } + }, + { + "mnemonic": "BLOCKLT", + "alias_of": "GETPARAM", + "doc_fift": "BLOCKLT", + "doc_stack": " - x", + "description": "Returns the starting logical time of the current block.\nEquivalent to `4 GETPARAM`.", + "operands": { + "i": 4 + } + }, + { + "mnemonic": "LTIME", + "alias_of": "GETPARAM", + "doc_fift": "LTIME", + "doc_stack": " - x", + "description": "Returns the logical time of the current transaction.\nEquivalent to `5 GETPARAM`.", + "operands": { + "i": 5 + } + }, + { + "mnemonic": "RANDSEED", + "alias_of": "GETPARAM", + "doc_fift": "RANDSEED", + "doc_stack": " - x", + "description": "Returns the current random seed as an unsigned 256-bit _Integer_.\nEquivalent to `6 GETPARAM`.", + "operands": { + "i": 6 + } + }, + { + "mnemonic": "BALANCE", + "alias_of": "GETPARAM", + "doc_fift": "BALANCE", + "doc_stack": " - t", + "description": "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 \u0432\u0402\u045aextra currencies'').\nEquivalent to `7 GETPARAM`.\nNote that `RAW` primitives such as `SENDRAWMSG` do not update this field.", + "operands": { + "i": 7 + } + }, + { + "mnemonic": "MYADDR", + "alias_of": "GETPARAM", + "doc_fift": "MYADDR", + "doc_stack": " - s", + "description": "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`.\nEquivalent to `8 GETPARAM`.", + "operands": { + "i": 8 + } + }, + { + "mnemonic": "CONFIGROOT", + "alias_of": "GETPARAM", + "doc_fift": "CONFIGROOT", + "doc_stack": " - D", + "description": "Returns the _Maybe Cell_ `D` with the current global configuration dictionary. Equivalent to `9 GETPARAM `.", + "operands": { + "i": 9 + } + }, + { + "mnemonic": "SETCP0", + "alias_of": "SETCP", + "doc_fift": "SETCP0", + "doc_stack": "-", + "description": "Selects TVM (test) codepage zero as described in this document.", + "operands": { + "n": 0 + } + } + ] } \ No newline at end of file diff --git a/schema.json b/schema.json index 763a2e5..62f84a3 100644 --- a/schema.json +++ b/schema.json @@ -2,320 +2,552 @@ "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "additionalProperties": false, - "properties": { - "$schema": { - "type": "string" + "definitions": { + "alias": { + "type": "object", + "additionalProperties": false, + "properties": { + "mnemonic": { + "type": "string", + "title": "Alias name", + "examples": [ + "ROT2", + "ONE" + ] + }, + "alias_of": { + "type": "string", + "title": "Mnemonic of aliased instruction", + "examples": [ + "BLKSWAP", + "INDEX" + ] + }, + "doc_fift": { + "type": "string", + "title": "Fift usage doc", + "description": "Free-form fift usage description." + }, + "doc_stack": { + "type": "string", + "title": "Stack usage description", + "description": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value).", + "markdownDescription": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value)." + }, + "description": { + "type": "string", + "title": "Alias description", + "description": "Free-form markdown description of alias." + }, + "operands": { + "type": "object", + "title": "Fixed operands of alias", + "description": "Values of original instruction operands which are fixed in this alias. Currently it can be integer or slice without references which is represented by string of '0' and '1's. Type should be inferred from original instruction operand loaders.", + "markdownDescription": "Values of original instruction operands which are fixed in this alias. Currently it can be integer or slice without references which is represented by string of '0' and '1's. Type should be inferred from original instruction operand loaders.", + "examples": [ + { + "i": 1, + "j": 3 + } + ] + } + }, + "required": [ + "mnemonic", + "alias_of", + "operands" + ] }, - "instructions": { + "values": { + "type": "object", + "additionalProperties": false, + "properties": { + "stack": { + "$ref": "#/definitions/stack" + } + }, + "required": [ + "stack" + ] + }, + "stack": { "type": "array", + "title": "Stack values", + "description": "Stack constraints. Top of stack is the last value.", "items": { - "type": "object", - "additionalProperties": false, - "properties": { - "mnemonic": { - "type": "string", - "title": "Instruction name", - "description": "How instruction is named in [original TVM implementation](https://github.com/ton-blockchain/ton/blob/master/crypto/vm). Not necessarily unique (currently only DEBUG is not unique).", - "markdownDescription": "How instruction is named in [original TVM implementation](https://github.com/ton-blockchain/ton/blob/master/crypto/vm). Not necessarily unique (currently only DEBUG is not unique).", - "examples": [ - "XCHG_0I", - "PLDULE4" - ] - }, - "doc": { - "type": "object", - "title": "Documentation", - "description": "Free-form human-friendly information which should be used for documentation purposes only.", - "additionalProperties": false, - "properties": { - "category": { - "type": "string", - "title": "Category of instruction", - "examples": [ - "cont_loops", - "stack_basic", - "dict_get" - ] - }, - "description": { - "type": "string", - "title": "Instruction description", - "description": "Free-form markdown description of instruction.", - "examples": [ - "Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.", - "Throws exception `0 <= n < 2^16` with parameter zero.\nApproximately equivalent to `ZERO` `SWAP` `THROWARGANY`." - ] - }, - "gas": { - "type": "string", - "title": "Gas usage info", - "description": "Free-form description of gas amount used by instruction.", - "examples": [ - "76", - "26/76" - ] - }, - "fift": { - "type": "string", - "title": "Fift usage doc", - "description": "Free-form fift usage description.", - "examples": [ - "THROWARGANYIFNOT", - "TRY" + "$ref": "#/definitions/stack_entry" + }, + "additionalItems": false + }, + "stack_entry": { + "title": "Stack entry", + "description": "Representation of stack entry or group of stack entries", + "examples": [ + { + "type": "simple", + "name": "i", + "value_types": [ + "Integer" + ] + }, + { + "type": "conditional", + "name": "status", + "match": [ + { + "value": 0, + "stack": [ + { + "type": "simple", + "name": "s", + "value_types": [ + "Slice" + ] + } + ] + }, + { + "value": -1, + "stack": [ + { + "type": "simple", + "name": "x", + "value_types": [ + "Integer" + ] + }, + { + "type": "simple", + "name": "s2", + "value_types": [ + "Slice" + ] + } + ] + } + ] + }, + { + "type": "simple", + "name": "D", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "oneOf": [ + { + "type": "object", + "required": [ + "type", + "name" + ], + "properties": { + "type": { + "const": "simple" + }, + "name": { + "type": "string", + "name": "Variable to pass" + }, + "value_types": { + "name": "Possible value types", + "type": "array", + "items": { + "enum": [ + "Integer", + "Cell", + "Builder", + "Slice", + "Tuple", + "Continuation", + "Null" ] - }, - "fift_examples": { - "type": "array", - "items": { - "type": "object", - "additionalProperties": false, - "properties": { - "fift": { - "type": "string", - "title": "Fift snippet", - "examples": [ - "TRY:<{ code1 }>CATCH<{ code2 }>" - ] - }, - "description": { - "type": "string", - "title": "Example description", - "examples": [ - "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `TRY`." - ] - } + } + } + }, + "additionalProperties": false + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "value_type", + "value" + ], + "properties": { + "type": { + "const": "const" + }, + "value_type": { + "name": "Constant type", + "type": "string", + "enum": [ + "Integer", + "Null" + ] + }, + "value": { + "name": "Constant value", + "type": [ + "number", + "null" + ] + } + } + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "name", + "match" + ], + "properties": { + "type": { + "const": "conditional" + }, + "name": { + "type": "string", + "name": "Variable to match" + }, + "match": { + "type": "array", + "additionalItems": false, + "items": { + "type": "object", + "name": "Match arm", + "description": "", + "additionalProperties": false, + "required": [ + "value", + "stack" + ], + "properties": { + "value": { + "type": "integer", + "name": "Arm value", + "description": "" + }, + "stack": { + "$ref": "#/definitions/stack" } } } }, - "required": [ - "category" - ] + "else": { + "$ref": "#/definitions/stack" + } + } + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "name", + "length_var" + ], + "properties": { + "type": { + "const": "tuple" + }, + "name": { + "name": "Variable name", + "type": "string" + }, + "length_var": { + "name": "Variable which contains tuple length", + "type": "string" + } + } + } + ] + }, + "instruction": { + "type": "object", + "additionalProperties": false, + "properties": { + "mnemonic": { + "type": "string", + "title": "Instruction name", + "description": "How instruction is named in [original TVM implementation](https://github.com/ton-blockchain/ton/blob/master/crypto/vm). Not necessarily unique (currently only DEBUG is not unique).", + "markdownDescription": "How instruction is named in [original TVM implementation](https://github.com/ton-blockchain/ton/blob/master/crypto/vm). Not necessarily unique (currently only DEBUG is not unique).", + "examples": [ + "XCHG_0I", + "PLDULE4" + ] + }, + "doc": { + "type": "object", + "title": "Documentation", + "description": "Free-form human-friendly information which should be used for documentation purposes only.", + "additionalProperties": false, + "properties": { + "category": { + "type": "string", + "title": "Category of instruction", + "examples": [ + "cont_loops", + "stack_basic", + "dict_get" + ] + }, + "description": { + "type": "string", + "title": "Instruction description", + "description": "Free-form markdown description of instruction.", + "examples": [ + "Interchanges `s[i]` with `s[j]`, `1 <= i < j <= 15`.", + "Throws exception `0 <= n < 2^16` with parameter zero.\nApproximately equivalent to `ZERO` `SWAP` `THROWARGANY`." + ] + }, + "gas": { + "type": "string", + "title": "Gas usage info", + "description": "Free-form description of gas amount used by instruction.", + "examples": [ + "76", + "26/76" + ] + }, + "fift": { + "type": "string", + "title": "Fift usage doc", + "description": "Free-form fift usage description.", + "examples": [ + "THROWARGANYIFNOT", + "TRY" + ] + }, + "fift_examples": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "fift": { + "type": "string", + "title": "Fift snippet", + "examples": [ + "TRY:<{ code1 }>CATCH<{ code2 }>" + ] + }, + "description": { + "type": "string", + "title": "Example description", + "examples": [ + "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `TRY`." + ] + } + } + } + } }, - "bytecode": { - "type": "object", - "title": "Bytecode Format", - "description": "Information related to bytecode format of an instruction. Assuming that each instruction has format `prefix || operand_1 || operand_2 || ...` (also some operands may be refs, not bitstring part).", - "markdownDescription": "Information related to bytecode format of an instruction. Assuming that each instruction has format `prefix || operand_1 || operand_2 || ...` (also some operands may be refs, not bitstring part).", - "additionalProperties": false, - "properties": { - "doc_opcode": { - "type": "string", - "title": "Opcode format documentation", - "description": "Free-form bytecode format description.", - "examples": [ - "F2FF", - "F3pr", - "FEFnssss" - ] - }, - "tlb": { - "type": "string", - "title": "TL-b schema", - "description": "TL-b bytecode format description.", - "examples": [ - "#FEF n:(## 4) ssss:((n * 8 + 8) * Bit)", - "#6FB i:uint2 j:uint2" - ] - }, - "prefix": { - "type": "string", - "title": "Instruction prefix", - "description": "Prefix to determine next instruction to parse. It is a hex bitstring as in TL-b (suffixed with `_` if bit length is not divisible by 4, trailing `'1' + '0' * x` must be removed).", - "markdownDescription": "Prefix to determine next instruction to parse. It is a hex bitstring as in TL-b (suffixed with `_` if bit length is not divisible by 4, trailing `'1' + '0' * x` must be removed).", - "examples": [ - "6FA7", - "6FE_" - ] + "required": [ + "category" + ] + }, + "bytecode": { + "type": "object", + "title": "Bytecode Format", + "description": "Information related to bytecode format of an instruction. Assuming that each instruction has format `prefix || operand_1 || operand_2 || ...` (also some operands may be refs, not bitstring part).", + "markdownDescription": "Information related to bytecode format of an instruction. Assuming that each instruction has format `prefix || operand_1 || operand_2 || ...` (also some operands may be refs, not bitstring part).", + "additionalProperties": false, + "properties": { + "doc_opcode": { + "type": "string", + "title": "Opcode format documentation", + "description": "Free-form bytecode format description.", + "examples": [ + "F2FF", + "F3pr", + "FEFnssss" + ] + }, + "tlb": { + "type": "string", + "title": "TL-b schema", + "description": "TL-b bytecode format description.", + "examples": [ + "#FEF n:(## 4) ssss:((n * 8 + 8) * Bit)", + "#6FB i:uint2 j:uint2" + ] + }, + "prefix": { + "type": "string", + "title": "Instruction prefix", + "description": "Prefix to determine next instruction to parse. It is a hex bitstring as in TL-b (suffixed with `_` if bit length is not divisible by 4, trailing `'1' + '0' * x` must be removed).", + "markdownDescription": "Prefix to determine next instruction to parse. It is a hex bitstring as in TL-b (suffixed with `_` if bit length is not divisible by 4, trailing `'1' + '0' * x` must be removed).", + "examples": [ + "6FA7", + "6FE_" + ] + }, + "operands_range_check": { + "type": "object", + "title": "Operands range check", + "description": "In TVM, it is possible for instructions to have overlapping prefixes, so to determine actual instruction it is required to read next `length` bits after prefix as uint `i` and check `from <= i <= to`. Optional, there is no operands check in case of absence.", + "markdownDescription": "In TVM, it is possible for instructions to have overlapping prefixes, so to determine actual instruction it is required to read next `length` bits after prefix as uint `i` and check `from <= i <= to`. Optional, there is no operands check in case of absence.", + "additionalProperties": false, + "properties": { + "length": { + "type": "integer" + }, + "from": { + "type": "integer" + }, + "to": { + "type": "integer" + } }, - "operands_range_check": { + "required": [ + "length", + "from", + "to" + ], + "examples": [ + { + "length": 4, + "from": 1, + "to": 15 + }, + { + "length": 5, + "from": 0, + "to": 30 + } + ] + }, + "operands": { + "type": "array", + "title": "Instruction operands", + "description": "Describes how to parse operands. Order of objects in this array represents the actual order of operands in instruction. Optional, no operands in case of absence.", + "default": [], + "items": { "type": "object", - "title": "Operands range check", - "description": "In TVM, it is possible for instructions to have overlapping prefixes, so to determine actual instruction it is required to read next `length` bits after prefix as uint `i` and check `from <= i <= to`. Optional, there is no operands check in case of absence.", - "markdownDescription": "In TVM, it is possible for instructions to have overlapping prefixes, so to determine actual instruction it is required to read next `length` bits after prefix as uint `i` and check `from <= i <= to`. Optional, there is no operands check in case of absence.", "additionalProperties": false, "properties": { - "length": { - "type": "integer" + "name": { + "type": "string", + "title": "Operand variable name", + "description": "Allowed chars are `a-zA-Z0-9_`, must not begin with digit or underscore and must not end with underscore.", + "markdownDescription": "Allowed chars are `a-zA-Z0-9_`, must not begin with digit or underscore and must not end with underscore." }, - "from": { - "type": "integer" + "loader": { + "enum": [ + "int", + "uint", + "ref", + "pushint_long", + "subslice" + ], + "title": "Loader function for operand" }, - "to": { - "type": "integer" + "loader_args": { + "type": "object", + "title": "Arguments for loader function. Optional, no arguments in case of absence.", + "default": {} } }, "required": [ - "length", - "from", - "to" + "name", + "loader" ], "examples": [ { - "length": 4, - "from": 1, - "to": 15 + "name": "x", + "loader": "pushint_long", + "loader_args": {} }, { - "length": 5, - "from": 0, - "to": 30 - } - ] - }, - "operands": { - "type": "array", - "title": "Instruction operands", - "description": "Describes how to parse operands. Order of objects in this array represents the actual order of operands in instruction. Optional, no operands in case of absence.", - "default": [], - "items": { - "type": "object", - "additionalProperties": false, - "properties": { - "name": { - "type": "string", - "title": "Operand variable name", - "description": "Allowed chars are `a-zA-Z0-9_`, must not begin with digit or underscore and must not end with underscore.", - "markdownDescription": "Allowed chars are `a-zA-Z0-9_`, must not begin with digit or underscore and must not end with underscore." - }, - "loader": { - "enum": [ - "int", - "uint", - "ref", - "pushint_long", - "subslice" - ], - "title": "Loader function for operand" - }, + "name": "r", + "loader": "uint", "loader_args": { - "type": "object", - "title": "Arguments for loader function. Optional, no arguments in case of absence.", - "default": {} + "size": 2 } }, - "required": [ - "name", - "loader" - ], - "examples": [ - { - "name": "x", - "loader": "pushint_long", - "loader_args": {} - }, - { - "name": "r", - "loader": "uint", - "loader_args": { - "size": 2 - } - }, - { - "name": "x", - "loader": "uint", - "loader_args": { - "size": 5 - } - }, - { - "name": "slice", - "loader": "subslice", - "loader_args": { - "bits_length_var": "x", - "bits_padding": 1, - "refs_length_var": "r", - "refs_add": 1, - "completion_tag": true - } + { + "name": "x", + "loader": "uint", + "loader_args": { + "size": 5 } - ] - } + }, + { + "name": "slice", + "loader": "subslice", + "loader_args": { + "bits_length_var": "x", + "bits_padding": 1, + "refs_length_var": "r", + "refs_add": 1, + "completion_tag": true + } + } + ] } - }, - "required": [ - "prefix", - "tlb" - ] + } }, - "value_flow": { - "type": "object", - "title": "Value flow of instruction", - "description": "Information related to usage of stack and registers by instruction.", - "additionalProperties": false, - "properties": { - "doc_stack": { - "type": "string", - "title": "Stack usage description", - "description": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value).", - "markdownDescription": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value)." - } + "required": [ + "prefix", + "tlb" + ] + }, + "value_flow": { + "type": "object", + "title": "Value flow of instruction", + "description": "Information related to usage of stack and registers by instruction.", + "additionalProperties": false, + "properties": { + "doc_stack": { + "type": "string", + "title": "Stack usage description", + "description": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value).", + "markdownDescription": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value)." + }, + "inputs": { + "$ref": "#/definitions/values", + "title": "Instruction inputs", + "description": "Incoming values constraints. Input is unconstrained if absent." + }, + "outputs": { + "$ref": "#/definitions/values", + "title": "Instruction outputs", + "description": "Outgoing values constraints. Output is unconstrained if absent." } } - }, - "required": [ - "mnemonic", - "doc", - "bytecode" - ] + } + }, + "required": [ + "mnemonic", + "doc", + "bytecode" + ] + } + }, + "properties": { + "$schema": { + "type": "string" + }, + "instructions": { + "name": "Instructions", + "description": "Instruction list.", + "type": "array", + "additionalItems": false, + "items": { + "$ref": "#/definitions/instruction" } }, "aliases": { "type": "array", + "title": "Aliases", + "description": "Aliases list.", "items": { - "type": "object", - "additionalProperties": false, - "properties": { - "mnemonic": { - "type": "string", - "title": "Alias name", - "examples": [ - "ROT2", - "ONE" - ] - }, - "alias_of": { - "type": "string", - "title": "Mnemonic of aliased instruction", - "examples": [ - "BLKSWAP", - "INDEX" - ] - }, - "doc_fift": { - "type": "string", - "title": "Fift usage doc", - "description": "Free-form fift usage description." - }, - "doc_stack": { - "type": "string", - "title": "Stack usage description", - "description": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value).", - "markdownDescription": "Free-form description of stack inputs and outputs. Usually the form is `[inputs] - [outputs]` where `[inputs]` are consumed stack values and `outputs` are produced stack values (top of stack is the last value)." - }, - "description": { - "type": "string", - "title": "Alias description", - "description": "Free-form markdown description of alias." - }, - "operands": { - "type": "object", - "title": "Fixed operands of alias", - "description": "Values of original instruction operands which are fixed in this alias. Currently it can be integer or slice without references which is represented by string of '0' and '1's. Type should be inferred from original instruction operand loaders.", - "markdownDescription": "Values of original instruction operands which are fixed in this alias. Currently it can be integer or slice without references which is represented by string of '0' and '1's. Type should be inferred from original instruction operand loaders.", - "examples": [ - { - "i": 1, - "j": 3 - } - ] - } - }, - "required": [ - "mnemonic", - "alias_of", - "operands" - ] + "$ref": "#/definitions/alias" } } },