From 4196201bde0df7f5f89c9be5f0bf3f6d6353445d Mon Sep 17 00:00:00 2001 From: pavelkhachatrian Date: Fri, 16 Jan 2026 14:16:40 +0100 Subject: [PATCH 1/2] Add autocompletion and hover docs for TVM opcodes --- cp0.json | 67608 +++++++++++++++++++++++++++++++++++++ src/Output.vue | 2 +- src/monaco/Monaco.vue | 18 +- src/monaco/env.ts | 5 + src/monaco/opcodes.ts | 308 + src/providers/useFift.ts | 22 +- 6 files changed, 67952 insertions(+), 11 deletions(-) create mode 100644 cp0.json create mode 100644 src/monaco/opcodes.ts diff --git a/cp0.json b/cp0.json new file mode 100644 index 0000000..b99fdb3 --- /dev/null +++ b/cp0.json @@ -0,0 +1,67608 @@ +{ + "$schema": "./schema.json", + "aliases": [ + { + "alias_of": "XCHG_0I", + "description": "

Same as s1 XCHG0.

\n", + "doc_fift": "SWAP", + "doc_stack": "x y - y x", + "mnemonic": "SWAP", + "operands": { + "i": 1 + } + }, + { + "alias_of": "PUSH", + "description": "

Same as s0 PUSH.

\n", + "doc_fift": "DUP", + "doc_stack": "x - x x", + "mnemonic": "DUP", + "operands": { + "i": 0 + } + }, + { + "alias_of": "PUSH", + "description": "

Same as s1 PUSH.

\n", + "doc_fift": "OVER", + "doc_stack": "x y - x y x", + "mnemonic": "OVER", + "operands": { + "i": 1 + } + }, + { + "alias_of": "POP", + "description": "

Same as s0 POP, discards the top-of-stack value.

\n", + "doc_fift": "DROP", + "doc_stack": "x -", + "mnemonic": "DROP", + "operands": { + "i": 0 + } + }, + { + "alias_of": "POP", + "description": "

Same as s1 POP.

\n", + "doc_fift": "NIP", + "doc_stack": "x y - y", + "mnemonic": "NIP", + "operands": { + "i": 1 + } + }, + { + "alias_of": "BLKSWAP", + "description": "

Rotates the three topmost pairs of stack entries.

\n", + "doc_fift": "ROT2\n2ROT", + "doc_stack": "a b c d e f - c d e f a b", + "mnemonic": "ROT2", + "operands": { + "i": 1, + "j": 3 + } + }, + { + "alias_of": "BLKSWAP", + "description": "

Rotates the top i+1 stack entries.\nEquivalent to 1 [i+1] BLKSWAP.

\n", + "doc_fift": "[i+1] ROLL", + "doc_stack": "", + "mnemonic": "ROLL", + "operands": { + "i": 0 + } + }, + { + "alias_of": "BLKSWAP", + "description": "

Rotates the top i+1 stack entries in the other direction.\nEquivalent to [i+1] 1 BLKSWAP.

\n", + "doc_fift": "[i+1] -ROLL\n[i+1] ROLLREV", + "doc_stack": "", + "mnemonic": "ROLLREV", + "operands": { + "j": 0 + } + }, + { + "alias_of": "TUPLE", + "description": "

Pushes the only Tuple t=() of length zero.

\n", + "doc_fift": "NIL", + "doc_stack": "- t", + "mnemonic": "NIL", + "operands": { + "n": 0 + } + }, + { + "alias_of": "TUPLE", + "description": "

Creates a singleton t:=(x), i.e., a Tuple of length one.

\n", + "doc_fift": "SINGLE", + "doc_stack": "x - t", + "mnemonic": "SINGLE", + "operands": { + "n": 1 + } + }, + { + "alias_of": "TUPLE", + "description": "

Creates pair t:=(x,y).

\n", + "doc_fift": "PAIR\nCONS", + "doc_stack": "x y - t", + "mnemonic": "PAIR", + "operands": { + "n": 2 + } + }, + { + "alias_of": "TUPLE", + "description": "

Creates triple t:=(x,y,z).

\n", + "doc_fift": "TRIPLE", + "doc_stack": "x y z - t", + "mnemonic": "TRIPLE", + "operands": { + "n": 3 + } + }, + { + "alias_of": "INDEX", + "description": "

Returns the first element of a Tuple.

\n", + "doc_fift": "FIRST\nCAR", + "doc_stack": "t - x", + "mnemonic": "FIRST", + "operands": { + "k": 0 + } + }, + { + "alias_of": "INDEX", + "description": "

Returns the second element of a Tuple.

\n", + "doc_fift": "SECOND\nCDR", + "doc_stack": "t - y", + "mnemonic": "SECOND", + "operands": { + "k": 1 + } + }, + { + "alias_of": "INDEX", + "description": "

Returns the third element of a Tuple.

\n", + "doc_fift": "THIRD", + "doc_stack": "t - z", + "mnemonic": "THIRD", + "operands": { + "k": 2 + } + }, + { + "alias_of": "UNTUPLE", + "description": "

Unpacks a singleton t=(x).

\n", + "doc_fift": "UNSINGLE", + "doc_stack": "t - x", + "mnemonic": "UNSINGLE", + "operands": { + "n": 1 + } + }, + { + "alias_of": "UNTUPLE", + "description": "

Unpacks a pair t=(x,y).

\n", + "doc_fift": "UNPAIR\nUNCONS", + "doc_stack": "t - x y", + "mnemonic": "UNPAIR", + "operands": { + "n": 2 + } + }, + { + "alias_of": "UNTUPLE", + "description": "

Unpacks a triple t=(x,y,z).

\n", + "doc_fift": "UNTRIPLE", + "doc_stack": "t - x y z", + "mnemonic": "UNTRIPLE", + "operands": { + "n": 3 + } + }, + { + "alias_of": "UNPACKFIRST", + "description": "

Checks whether t is a Tuple. If not, throws a type check exception.

\n", + "doc_fift": "CHKTUPLE", + "doc_stack": "t -", + "mnemonic": "CHKTUPLE", + "operands": { + "k": 0 + } + }, + { + "alias_of": "SETINDEX", + "description": "

Sets the first component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETFIRST", + "doc_stack": "t x - t'", + "mnemonic": "SETFIRST", + "operands": { + "k": 0 + } + }, + { + "alias_of": "SETINDEX", + "description": "

Sets the second component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETSECOND", + "doc_stack": "t x - t'", + "mnemonic": "SETSECOND", + "operands": { + "k": 1 + } + }, + { + "alias_of": "SETINDEX", + "description": "

Sets the third component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETTHIRD", + "doc_stack": "t x - t'", + "mnemonic": "SETTHIRD", + "operands": { + "k": 2 + } + }, + { + "alias_of": "INDEXQ", + "description": "

Returns the first element of a Tuple.

\n", + "doc_fift": "FIRSTQ\nCARQ", + "doc_stack": "t - x", + "mnemonic": "FIRSTQ", + "operands": { + "k": 0 + } + }, + { + "alias_of": "INDEXQ", + "description": "

Returns the second element of a Tuple.

\n", + "doc_fift": "SECONDQ\nCDRQ", + "doc_stack": "t - y", + "mnemonic": "SECONDQ", + "operands": { + "k": 1 + } + }, + { + "alias_of": "INDEXQ", + "description": "

Returns the third element of a Tuple.

\n", + "doc_fift": "THIRDQ", + "doc_stack": "t - z", + "mnemonic": "THIRDQ", + "operands": { + "k": 2 + } + }, + { + "alias_of": "SETINDEXQ", + "description": "

Sets the first component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETFIRSTQ", + "doc_stack": "t x - t'", + "mnemonic": "SETFIRSTQ", + "operands": { + "k": 0 + } + }, + { + "alias_of": "SETINDEXQ", + "description": "

Sets the second component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETSECONDQ", + "doc_stack": "t x - t'", + "mnemonic": "SETSECONDQ", + "operands": { + "k": 1 + } + }, + { + "alias_of": "SETINDEXQ", + "description": "

Sets the third component of Tuple t to x and returns the resulting Tuple t'.

\n", + "doc_fift": "SETTHIRDQ", + "doc_stack": "t x - t'", + "mnemonic": "SETTHIRDQ", + "operands": { + "k": 2 + } + }, + { + "alias_of": "INDEX2", + "description": "

Recovers x=(t_2)_1.

\n", + "doc_fift": "CADR", + "doc_stack": "t - x", + "mnemonic": "CADR", + "operands": { + "i": 1, + "j": 0 + } + }, + { + "alias_of": "INDEX2", + "description": "

Recovers x=(t_2)_2.

\n", + "doc_fift": "CDDR", + "doc_stack": "t - x", + "mnemonic": "CDDR", + "operands": { + "i": 1, + "j": 1 + } + }, + { + "alias_of": "INDEX3", + "description": "

Recovers x=t_2_2_1.

\n", + "doc_fift": "CADDR", + "doc_stack": "t - x", + "mnemonic": "CADDR", + "operands": { + "i": 1, + "j": 1, + "k": 0 + } + }, + { + "alias_of": "INDEX3", + "description": "

Recovers x=t_2_2_2.

\n", + "doc_fift": "CDDDR", + "doc_stack": "t - x", + "mnemonic": "CDDDR", + "operands": { + "i": 1, + "j": 1, + "k": 1 + } + }, + { + "alias_of": "PUSHINT_4", + "description": "", + "doc_fift": "ZERO\nFALSE", + "doc_stack": "- 0", + "mnemonic": "ZERO", + "operands": { + "i": 0 + } + }, + { + "alias_of": "PUSHINT_4", + "description": "", + "doc_fift": "ONE", + "doc_stack": "- 1", + "mnemonic": "ONE", + "operands": { + "i": 1 + } + }, + { + "alias_of": "PUSHINT_4", + "description": "", + "doc_fift": "TWO", + "doc_stack": "- 2", + "mnemonic": "TWO", + "operands": { + "i": 2 + } + }, + { + "alias_of": "PUSHINT_4", + "description": "", + "doc_fift": "TEN", + "doc_stack": "- 10", + "mnemonic": "TEN", + "operands": { + "i": 10 + } + }, + { + "alias_of": "PUSHINT_4", + "description": "", + "doc_fift": "TRUE", + "doc_stack": "- -1", + "mnemonic": "TRUE", + "operands": { + "i": 15 + } + }, + { + "alias_of": "FITS", + "description": "

Checks whether x is a ''boolean value'' (i.e., either 0 or -1).

\n", + "doc_fift": "CHKBOOL", + "doc_stack": "x - x", + "mnemonic": "CHKBOOL", + "operands": { + "c": 0 + } + }, + { + "alias_of": "UFITS", + "description": "

Checks whether x is a binary digit (i.e., zero or one).

\n", + "doc_fift": "CHKBIT", + "doc_stack": "x - x", + "mnemonic": "CHKBIT", + "operands": { + "c": 0 + } + }, + { + "alias_of": "EQINT", + "description": "

Checks whether an integer is zero. Corresponds to Forth's 0=.

\n", + "doc_fift": "ISZERO", + "doc_stack": "x - x=0", + "mnemonic": "ISZERO", + "operands": { + "y": 0 + } + }, + { + "alias_of": "LESSINT", + "description": "

Checks whether an integer is negative. Corresponds to Forth's 0<.

\n", + "doc_fift": "ISNEG", + "doc_stack": "x - x<0", + "mnemonic": "ISNEG", + "operands": { + "y": 0 + } + }, + { + "alias_of": "LESSINT", + "description": "

Checks whether an integer is non-positive.

\n", + "doc_fift": "ISNPOS", + "doc_stack": "x - x<=0", + "mnemonic": "ISNPOS", + "operands": { + "y": 1 + } + }, + { + "alias_of": "GTINT", + "description": "

Checks whether an integer is positive. Corresponds to Forth's 0>.

\n", + "doc_fift": "ISPOS", + "doc_stack": "x - x>0", + "mnemonic": "ISPOS", + "operands": { + "y": 0 + } + }, + { + "alias_of": "GTINT", + "description": "

Checks whether an integer is non-negative.

\n", + "doc_fift": "ISNNEG", + "doc_stack": "x - x >=0", + "mnemonic": "ISNNEG", + "operands": { + "y": -1 + } + }, + { + "alias_of": "STSLICECONST", + "description": "

Stores one binary zero.

\n", + "doc_fift": "STZERO", + "doc_stack": "b - b'", + "mnemonic": "STZERO", + "operands": { + "sss": "0", + "x": 0, + "y": 0 + } + }, + { + "alias_of": "STSLICECONST", + "description": "

Stores one binary one.

\n", + "doc_fift": "STONE", + "doc_stack": "b - b'", + "mnemonic": "STONE", + "operands": { + "sss": "1", + "x": 0, + "y": 0 + } + }, + { + "alias_of": "PLDREFIDX", + "description": "

Preloads the first cell reference of a Slice.

\n", + "doc_fift": "PLDREF", + "doc_stack": "s - c", + "mnemonic": "PLDREF", + "operands": { + "n": 0 + } + }, + { + "alias_of": "SETCONTARGS_N", + "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.

\n", + "doc_fift": "[n] SETNUMARGS", + "doc_stack": "c - c'", + "mnemonic": "SETNUMARGS", + "operands": { + "r": 0 + } + }, + { + "alias_of": "SETCONTARGS_N", + "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.

\n", + "doc_fift": "[r] -1 SETCONTARGS", + "doc_stack": "x_1 x_2...x_r c - c'", + "mnemonic": "SETCONTARGS", + "operands": { + "n": -1 + } + }, + { + "alias_of": "BLESSARGS", + "description": "

Also transforms a Slice s into a Continuation c, but sets c.nargs to 0 <= n <= 14.

\n", + "doc_fift": "[n] BLESSNUMARGS", + "doc_stack": "s - c", + "mnemonic": "BLESSNUMARGS", + "operands": { + "r": 0 + } + }, + { + "alias_of": "PUSHCTR", + "description": "

Pushes the ''global data root'' cell reference, thus enabling access to persistent smart-contract data.

\n", + "doc_fift": "c4 PUSHCTR\nc4 PUSH", + "doc_stack": "- x", + "mnemonic": "PUSHROOT", + "operands": { + "i": 4 + } + }, + { + "alias_of": "POPCTR", + "description": "

Sets the ''global data root'' cell reference, thus allowing modification of persistent smart-contract data.

\n", + "doc_fift": "c4 POPCTR\nc4 POP", + "doc_stack": "x -", + "mnemonic": "POPROOT", + "operands": { + "i": 4 + } + }, + { + "alias_of": "NULL", + "description": "

Returns a new empty dictionary.\nIt is an alternative mnemonics for PUSHNULL.

\n", + "doc_fift": "NEWDICT", + "doc_stack": " - D", + "mnemonic": "NEWDICT", + "operands": {} + }, + { + "alias_of": "ISNULL", + "description": "

Checks whether dictionary D is empty, and returns -1 or 0 accordingly.\nIt is an alternative mnemonics for ISNULL.

\n", + "doc_fift": "DICTEMPTY", + "doc_stack": "D - ?", + "mnemonic": "DICTEMPTY", + "operands": {} + }, + { + "alias_of": "STSLICE", + "description": "

Stores a Slice-represented dictionary s into Builder b.\nIt is actually a synonym for STSLICE.

\n", + "doc_fift": "STDICTS\n", + "doc_stack": "s b - b'", + "mnemonic": "STDICTS", + "operands": {} + }, + { + "alias_of": "GETPARAM", + "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.

\n", + "doc_fift": "NOW", + "doc_stack": " - x", + "mnemonic": "NOW", + "operands": { + "i": 3 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Returns the starting logical time of the current block.\nEquivalent to 4 GETPARAM.

\n", + "doc_fift": "BLOCKLT", + "doc_stack": " - x", + "mnemonic": "BLOCKLT", + "operands": { + "i": 4 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Returns the logical time of the current transaction.\nEquivalent to 5 GETPARAM.

\n", + "doc_fift": "LTIME", + "doc_stack": " - x", + "mnemonic": "LTIME", + "operands": { + "i": 5 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Returns the current random seed as an unsigned 256-bit Integer.\nEquivalent to 6 GETPARAM.

\n", + "doc_fift": "RANDSEED", + "doc_stack": " - x", + "mnemonic": "RANDSEED", + "operands": { + "i": 6 + } + }, + { + "alias_of": "GETPARAM", + "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 ''extra currencies'').\nEquivalent to 7 GETPARAM.\nNote that RAW primitives such as SENDRAWMSG do not update this field.

\n", + "doc_fift": "BALANCE", + "doc_stack": " - t", + "mnemonic": "BALANCE", + "operands": { + "i": 7 + } + }, + { + "alias_of": "GETPARAM", + "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.

\n", + "doc_fift": "MYADDR", + "doc_stack": " - s", + "mnemonic": "MYADDR", + "operands": { + "i": 8 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Returns the Maybe Cell D with the current global configuration dictionary. Equivalent to 9 GETPARAM .

\n", + "doc_fift": "CONFIGROOT", + "doc_stack": " - D", + "mnemonic": "CONFIGROOT", + "operands": { + "i": 9 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrieves code of smart-contract from c7. Equivalent to 10 GETPARAM .

\n", + "doc_fift": "MYCODE", + "doc_stack": " - c", + "mnemonic": "MYCODE", + "operands": { + "i": 10 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrieves value of incoming message from c7. Equivalent to 11 GETPARAM .

\n", + "doc_fift": "INCOMINGVALUE", + "doc_stack": " - t", + "mnemonic": "INCOMINGVALUE", + "operands": { + "i": 11 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrieves value of storage phase fees from c7. Equivalent to 12 GETPARAM .

\n", + "doc_fift": "STORAGEFEES", + "doc_stack": " - i", + "mnemonic": "STORAGEFEES", + "operands": { + "i": 12 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrives PrevBlocksInfo: [last_mc_blocks, prev_key_block] from c7. Equivalent to 13 GETPARAM .

\n", + "doc_fift": "PREVBLOCKSINFOTUPLE", + "doc_stack": " - t", + "mnemonic": "PREVBLOCKSINFOTUPLE", + "operands": { + "i": 13 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrives tuple that contains some config parameters as cell slices. If the parameter is absent from the config, the value is null. Values:

\n\n", + "doc_fift": "UNPACKEDCONFIGTUPLE", + "doc_stack": " - t", + "mnemonic": "UNPACKEDCONFIGTUPLE", + "operands": { + "i": 14 + } + }, + { + "alias_of": "GETPARAM", + "description": "

Retrives current debt for storage fee (nanotons).

\n", + "doc_fift": "DUEPAYMENT", + "doc_stack": " - t", + "mnemonic": "DUEPAYMENT", + "operands": { + "i": 15 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives bounce flag of incoming message.

\n", + "doc_fift": "INMSG_BOUNCE", + "doc_stack": " - x", + "mnemonic": "INMSG_BOUNCE", + "operands": { + "i": 0 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives bounced flag of incoming message.

\n", + "doc_fift": "INMSG_BOUNCED", + "doc_stack": " - x", + "mnemonic": "INMSG_BOUNCED", + "operands": { + "i": 1 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives src flag of incoming message.

\n", + "doc_fift": "INMSG_SRC", + "doc_stack": " - x", + "mnemonic": "INMSG_SRC", + "operands": { + "i": 2 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives fwd_fee field of incoming message.

\n", + "doc_fift": "INMSG_FWDFEE", + "doc_stack": " - x", + "mnemonic": "INMSG_FWDFEE", + "operands": { + "i": 3 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives lt field of incoming message.

\n", + "doc_fift": "INMSG_LT", + "doc_stack": " - x", + "mnemonic": "INMSG_LT", + "operands": { + "i": 4 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives utime field of incoming message.

\n", + "doc_fift": "INMSG_UTIME", + "doc_stack": " - x", + "mnemonic": "INMSG_UTIME", + "operands": { + "i": 5 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives original value of the message. This is sometimes different from the value in INCOMINGVALUE and TVM stack because of storage fees.

\n", + "doc_fift": "INMSG_ORIGVALUE", + "doc_stack": " - x", + "mnemonic": "INMSG_ORIGVALUE", + "operands": { + "i": 6 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrives value of the message after deducting storage fees. This is same as in INCOMINGVALUE and TVM stack.

\n", + "doc_fift": "INMSG_VALUE", + "doc_stack": " - x", + "mnemonic": "INMSG_VALUE", + "operands": { + "i": 7 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Same as in INCOMINGVALUE.

\n", + "doc_fift": "INMSG_VALUEEXTRA", + "doc_stack": " - x", + "mnemonic": "INMSG_VALUEEXTRA", + "operands": { + "i": 8 + } + }, + { + "alias_of": "INMSGPARAM", + "description": "

Retrieves init field of the incoming message.

\n", + "doc_fift": "INMSG_STATEINIT", + "doc_stack": " - x", + "mnemonic": "INMSG_STATEINIT", + "operands": { + "i": 9 + } + }, + { + "alias_of": "DEBUG", + "description": "

Dumps the stack (at most the top 255 values) and shows the total stack depth. Does nothing on production versions of TVM.

\n", + "doc_fift": "DUMPSTK", + "doc_stack": "-", + "mnemonic": "DUMPSTK", + "operands": { + "i": 0, + "j": 0 + } + }, + { + "alias_of": "DEBUG", + "description": "

Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.

\n", + "doc_fift": "STRDUMP", + "doc_stack": "-", + "mnemonic": "STRDUMP", + "operands": { + "i": 1, + "j": 4 + } + }, + { + "alias_of": "DEBUG", + "description": "

Dumps slice with length divisible by 8 from top of stack as a string. Does nothing on production versions of TVM.

\n", + "doc_fift": "s[j] DUMP", + "doc_stack": "-", + "mnemonic": "DUMP", + "operands": { + "i": 2 + } + }, + { + "alias_of": "SETCP", + "description": "

Selects TVM (test) codepage zero as described in this document.

\n", + "doc_fift": "SETCP0", + "doc_stack": "-", + "mnemonic": "SETCP0", + "operands": { + "n": 0 + } + } + ], + "instructions": [ + { + "bytecode": { + "operands": [], + "prefix": "00", + "tlb": "#00" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Does nothing.

\n", + "fift": "NOP", + "fift_examples": [], + "gas": "18", + "opcode": "00", + "stack": "-" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_nop", + "line": 28, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "NOP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 1, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 4, + "to": 15 + }, + "prefix": "0", + "tlb": "#0 i:(## 4) {1 <= i}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Interchanges s0 with s[i], 1 <= i <= 15.

\n", + "fift": "s[i] XCHG0", + "fift_examples": [], + "gas": "18", + "opcode": "0i", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg0", + "line": 43, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG_0I", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 1, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 4, + "to": 15 + }, + "prefix": "10", + "tlb": "#10 i:(## 4) j:(## 4) {1 <= i} {i + 1 <= j}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Interchanges s[i] with s[j], 1 <= i < j <= 15.

\n", + "fift": "s[i] s[j] XCHG", + "fift_examples": [], + "gas": "26", + "opcode": "10ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg", + "line": 61, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG_IJ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 255, + "min_value": 0, + "name": "i", + "size": 8, + "type": "uint" + } + ], + "prefix": "11", + "tlb": "#11 ii:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Interchanges s0 with s[ii], 0 <= ii <= 255.

\n", + "fift": "s0 [ii] s() XCHG", + "fift_examples": [], + "gas": "26", + "opcode": "11ii", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg0_l", + "line": 52, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG_0I_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 2, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 2, + "length": 4, + "to": 15 + }, + "prefix": "1", + "tlb": "#1 i:(## 4) {2 <= i}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Interchanges s1 with s[i], 2 <= i <= 15.

\n", + "fift": "s1 s[i] XCHG", + "fift_examples": [], + "gas": "18", + "opcode": "1i", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg1", + "line": 83, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG_1I", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "2", + "tlb": "#2 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Pushes a copy of the old s[i] into the stack.

\n", + "fift": "s[i] PUSH", + "fift_examples": [], + "gas": "18", + "opcode": "2i", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_push", + "line": 109, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUSH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "3", + "tlb": "#3 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_basic", + "description": "

Pops the old s0 value into the old s[i].

\n", + "fift": "s[i] POP", + "fift_examples": [], + "gas": "18", + "opcode": "3i", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_pop", + "line": 143, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "POP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "4", + "tlb": "#4 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s2 s[i] XCHG s1 s[j] XCHG s[k] XCHG0.

\n", + "fift": "s[i] s[j] s[k] XCHG3", + "fift_examples": [], + "gas": "26", + "opcode": "4ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg3", + "line": 204, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG3", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "50", + "tlb": "#50 i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s1 s[i] XCHG s[j] XCHG0.

\n", + "fift": "s[i] s[j] XCHG2", + "fift_examples": [], + "gas": "26", + "opcode": "50ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg2", + "line": 163, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "51", + "tlb": "#51 i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] XCHG0 s[j] PUSH.

\n", + "fift": "s[i] s[j] XCPU", + "fift_examples": [], + "gas": "26", + "opcode": "51ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xcpu", + "line": 173, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCPU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "52", + "tlb": "#52 i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] PUSH SWAP s[j] XCHG0.

\n", + "fift": "s[i] s[j-1] PUXC", + "fift_examples": [], + "gas": "26", + "opcode": "52ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_puxc", + "line": 183, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUXC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "53", + "tlb": "#53 i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] PUSH s[j+1] PUSH.

\n", + "fift": "s[i] s[j] PUSH2", + "fift_examples": [], + "gas": "26", + "opcode": "53ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_push2", + "line": 194, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUSH2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "540", + "tlb": "#540 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Long form of XCHG3.

\n", + "fift": "s[i] s[j] s[k] XCHG3_l", + "fift_examples": [], + "gas": "34", + "opcode": "540ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg3", + "line": 204, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHG3_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "541", + "tlb": "#541 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] s[j] XCHG2 s[k] PUSH.

\n", + "fift": "s[i] s[j] s[k] XC2PU", + "fift_examples": [], + "gas": "34", + "opcode": "541ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xc2pu", + "line": 215, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XC2PU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "542", + "tlb": "#542 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s1 s[i] XCHG s[j] s[k-1] PUXC.

\n", + "fift": "s[i] s[j] s[k-1] XCPUXC", + "fift_examples": [], + "gas": "34", + "opcode": "542ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xcpuxc", + "line": 226, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCPUXC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "543", + "tlb": "#543 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] XCHG0 s[j] s[k] PUSH2.

\n", + "fift": "s[i] s[j] s[k] XCPU2", + "fift_examples": [], + "gas": "34", + "opcode": "543ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xc2pu", + "line": 215, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCPU2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "544", + "tlb": "#544 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] PUSH s2 XCHG0 s[j] s[k] XCHG2.

\n", + "fift": "s[i] s[j-1] s[k-1] PUXC2", + "fift_examples": [], + "gas": "34", + "opcode": "544ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_puxc2", + "line": 249, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUXC2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "545", + "tlb": "#545 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] s[j-1] PUXC s[k] PUSH.

\n", + "fift": "s[i] s[j-1] s[k-1] PUXCPU", + "fift_examples": [], + "gas": "34", + "opcode": "545ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_puxcpu", + "line": 261, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUXCPU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 2 + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "546", + "tlb": "#546 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] PUSH SWAP s[j] s[k-1] PUXC.

\n", + "fift": "s[i] s[j-1] s[k-2] PU2XC", + "fift_examples": [], + "gas": "34", + "opcode": "546ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_puxc2", + "line": 249, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PU2XC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "547", + "tlb": "#547 i:uint4 j:uint4 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s[i] PUSH s[j+1] s[k+1] PUSH2.

\n", + "fift": "s[i] s[j] s[k] PUSH3", + "fift_examples": [], + "gas": "34", + "opcode": "547ijk", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_push3", + "line": 286, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUSH3", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "stack" + }, + { + "type": "add", + "value": 1 + } + ], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "55", + "tlb": "#55 i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Permutes two blocks s[j+i+1] ... s[j+1] and s[j] ... s0.\n0 <= i,j <= 15\nEquivalent to [i+1] [j+1] REVERSE [j+1] 0 REVERSE [i+j+2] 0 REVERSE.

\n", + "fift": "[i+1] [j+1] BLKSWAP", + "fift_examples": [], + "gas": "26", + "opcode": "55ij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_blkswap", + "line": 299, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "BLKSWAP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 255, + "min_value": 0, + "name": "i", + "size": 8, + "type": "uint" + } + ], + "prefix": "56", + "tlb": "#56 ii:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pushes a copy of the old s[ii] into the stack.\n0 <= ii <= 255

\n", + "fift": "[ii] s() PUSH", + "fift_examples": [], + "gas": "26", + "opcode": "56ii", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_push_l", + "line": 118, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PUSH_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "stack" + } + ], + "max_value": 255, + "min_value": 0, + "name": "i", + "size": 8, + "type": "uint" + } + ], + "prefix": "57", + "tlb": "#57 ii:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops the old s0 value into the old s[ii].\n0 <= ii <= 255

\n", + "fift": "[ii] s() POP", + "fift_examples": [], + "gas": "26", + "opcode": "57ii", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_pop_l", + "line": 152, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "POP_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "58", + "tlb": "#58" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to 1 2 BLKSWAP or to s2 s1 XCHG2.

\n", + "fift": "ROT", + "fift_examples": [], + "gas": "18", + "opcode": "58", + "stack": "a b c - b c a" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_rot", + "line": 308, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "ROT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "59", + "tlb": "#59" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to 2 1 BLKSWAP or to s2 s2 XCHG2.

\n", + "fift": "ROTREV\n-ROT", + "fift_examples": [], + "gas": "18", + "opcode": "59", + "stack": "a b c - c a b" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_rotrev", + "line": 317, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "ROTREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "5A", + "tlb": "#5A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to 2 2 BLKSWAP or to s3 s2 XCHG2.

\n", + "fift": "SWAP2\n2SWAP", + "fift_examples": [], + "gas": "18", + "opcode": "5A", + "stack": "a b c d - c d a b" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_2swap", + "line": 326, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "SWAP2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "5B", + "tlb": "#5B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to DROP DROP.

\n", + "fift": "DROP2\n2DROP", + "fift_examples": [], + "gas": "18", + "opcode": "5B", + "stack": "a b - " + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_2drop", + "line": 335, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "DROP2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "5C", + "tlb": "#5C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s1 s0 PUSH2.

\n", + "fift": "DUP2\n2DUP", + "fift_examples": [], + "gas": "18", + "opcode": "5C", + "stack": "a b - a b a b" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_2dup", + "line": 344, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "DUP2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "5D", + "tlb": "#5D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to s3 s2 PUSH2.

\n", + "fift": "OVER2\n2OVER", + "fift_examples": [], + "gas": "18", + "opcode": "5D", + "stack": "a b c d - a b c d a b" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_2over", + "line": 353, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "OVER2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "prefix": "5E", + "tlb": "#5E i:uint4 j:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Reverses the order of s[j+i+1] ... s[j].

\n", + "fift": "[i+2] [j] REVERSE", + "fift_examples": [], + "gas": "26", + "opcode": "5Eij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_reverse", + "line": 362, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "REVERSE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "5F0", + "tlb": "#5F0 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to DROP performed i times.

\n", + "fift": "[i] BLKDROP", + "fift_examples": [], + "gas": "26", + "opcode": "5F0i", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_blkdrop", + "line": 371, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "BLKDROP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 1, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 4, + "to": 15 + }, + "prefix": "5F", + "tlb": "#5F i:(## 4) j:uint4 {1 <= i}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to PUSH s(j) performed i times.\n1 <= i <= 15, 0 <= j <= 15.

\n", + "fift": "[i] [j] BLKPUSH", + "fift_examples": [], + "gas": "26", + "opcode": "5Fij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_blkpush", + "line": 389, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "BLKPUSH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "60", + "tlb": "#60" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then performs s[i] PUSH.

\n", + "fift": "PICK\nPUSHX", + "fift_examples": [], + "gas": "18", + "opcode": "60", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_pick", + "line": 400, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "PICK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "61", + "tlb": "#61" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then performs 1 [i] BLKSWAP.

\n", + "fift": "ROLLX", + "fift_examples": [], + "gas": "18", + "opcode": "61", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_roll", + "line": 410, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "ROLLX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "62", + "tlb": "#62" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then performs [i] 1 BLKSWAP.

\n", + "fift": "-ROLLX\nROLLREVX", + "fift_examples": [], + "gas": "18", + "opcode": "62", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_rollrev", + "line": 423, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "-ROLLX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "63", + "tlb": "#63" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integers i,j from the stack, then performs [i] [j] BLKSWAP.

\n", + "fift": "BLKSWX", + "fift_examples": [], + "gas": "18", + "opcode": "63", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_blkswap_x", + "line": 436, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "BLKSWX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "64", + "tlb": "#64" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integers i,j from the stack, then performs [i] [j] REVERSE.

\n", + "fift": "REVX", + "fift_examples": [], + "gas": "18", + "opcode": "64", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_reverse_x", + "line": 452, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "REVX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "65", + "tlb": "#65" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then performs [i] BLKDROP.

\n", + "fift": "DROPX", + "fift_examples": [], + "gas": "18", + "opcode": "65", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_drop_x", + "line": 464, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "DROPX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "66", + "tlb": "#66" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Equivalent to SWAP OVER or to s1 s1 XCPU.

\n", + "fift": "TUCK", + "fift_examples": [], + "gas": "18", + "opcode": "66", + "stack": "a b - b a b" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_tuck", + "line": 474, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "TUCK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "67", + "tlb": "#67" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then performs s[i] XCHG.

\n", + "fift": "XCHGX", + "fift_examples": [], + "gas": "18", + "opcode": "67", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_xchg_x", + "line": 483, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "XCHGX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "68", + "tlb": "#68" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pushes the current depth of the stack.

\n", + "fift": "DEPTH", + "fift_examples": [], + "gas": "18", + "opcode": "68", + "stack": "- depth" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_depth", + "line": 493, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "DEPTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "depth", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "69", + "tlb": "#69" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CHKDEPTH", + "fift_examples": [], + "gas": "18/58", + "opcode": "69", + "stack": "i -" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_chkdepth", + "line": 500, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "CHKDEPTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6A", + "tlb": "#6A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Pops integer i from the stack, then removes all but the top i elements.

\n", + "fift": "ONLYTOPX", + "fift_examples": [], + "gas": "18", + "opcode": "6A", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_onlytop_x", + "line": 509, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "ONLYTOPX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6B", + "tlb": "#6B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "ONLYX", + "fift_examples": [], + "gas": "18", + "opcode": "6B", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_only_x", + "line": 526, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "ONLYX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 1, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 4, + "to": 15 + }, + "prefix": "6C", + "tlb": "#6C i:(## 4) j:uint4 {1 <= i}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "stack_complex", + "description": "

Drops i stack elements under the top j elements.\n1 <= i <= 15, 0 <= j <= 15\nEquivalent to [i+j] 0 REVERSE [i] BLKDROP [j] 0 REVERSE.

\n", + "fift": "[i] [j] BLKDROP2", + "fift_examples": [], + "gas": "26", + "opcode": "6Cij", + "stack": "" + }, + "implementation": [ + { + "file": "stackops.cpp", + "function_name": "exec_blkdrop2", + "line": 380, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/stackops.cpp" + } + ], + "mnemonic": "BLKDROP2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6D", + "tlb": "#6D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Pushes the only value of type Null.

\n", + "fift": "NULL\nPUSHNULL", + "fift_examples": [], + "gas": "18", + "opcode": "6D", + "stack": " - null" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_push_null", + "line": 28, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6E", + "tlb": "#6E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Checks whether x is a Null, and returns -1 or 0 accordingly.

\n", + "fift": "ISNULL", + "fift_examples": [], + "gas": "18", + "opcode": "6E", + "stack": "x - ?" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_is_null", + "line": 34, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "ISNULL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "n", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F0", + "tlb": "#6F0 n:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Creates a new Tuple t=(x_1, ... ,x_n) containing n values x_1,..., x_n.\n0 <= n <= 15

\n", + "fift": "[n] TUPLE", + "fift_examples": [], + "gas": "26+n", + "opcode": "6F0n", + "stack": "x_1 ... x_n - t" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_mktuple_common", + "line": 73, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "TUPLE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "n", + "name": "tuple_elements", + "type": "array" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F1", + "tlb": "#6F1 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Returns the k-th element of a Tuple t.\n0 <= k <= 15.

\n", + "fift": "[k] INDEX", + "fift_examples": [], + "gas": "26", + "opcode": "6F1k", + "stack": "t - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_index", + "line": 106, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "n", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F2", + "tlb": "#6F2 n:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[n] UNTUPLE", + "fift_examples": [], + "gas": "26+n", + "opcode": "6F2n", + "stack": "t - x_1 ... x_n" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_untuple", + "line": 158, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "UNTUPLE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "n", + "name": "tuple_elements", + "type": "array" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F3", + "tlb": "#6F3 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Unpacks first 0 <= k <= 15 elements of a Tuple t.\nIf |t|<k, throws a type check exception.

\n", + "fift": "[k] UNPACKFIRST", + "fift_examples": [], + "gas": "26+k", + "opcode": "6F3k", + "stack": "t - x_1 ... x_k" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_untuple_first", + "line": 175, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "UNPACKFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "k", + "name": "tuple_elements", + "type": "array" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "n", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F4", + "tlb": "#6F4 n:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Unpacks a Tuple t=(x_1,...,x_m) and returns its length m, but only if m <= n <= 15. Otherwise throws a type check exception.

\n", + "fift": "[n] EXPLODE", + "fift_examples": [], + "gas": "26+m", + "opcode": "6F4n", + "stack": "t - x_1 ... x_m m" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_explode_tuple", + "line": 196, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "EXPLODE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "m", + "name": "tuple_elements", + "type": "array" + }, + { + "name": "m", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F5", + "tlb": "#6F5 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Computes Tuple t' that differs from t only at position t'_{k+1}, which is set to x.\n0 <= k <= 15\nIf k >= |t|, throws a range check exception.

\n", + "fift": "[k] SETINDEX", + "fift_examples": [], + "gas": "26+|t|", + "opcode": "6F5k", + "stack": "t x - t'" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_set_index", + "line": 222, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "SETINDEX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F6", + "tlb": "#6F6 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[k] INDEXQ", + "fift_examples": [], + "gas": "26", + "opcode": "6F6k", + "stack": "t - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_quiet_index", + "line": 124, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "k", + "size": 4, + "type": "uint" + } + ], + "prefix": "6F7", + "tlb": "#6F7 k:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'=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).

\n", + "fift": "[k] SETINDEXQ", + "fift_examples": [], + "gas": "26+|t'|", + "opcode": "6F7k", + "stack": "t x - t'" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_quiet_set_index", + "line": 251, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "SETINDEXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + }, + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F80", + "tlb": "#6F80" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Creates a new Tuple t of length n similarly to TUPLE, but with 0 <= n <= 255 taken from the stack.

\n", + "fift": "TUPLEVAR", + "fift_examples": [], + "gas": "26+n", + "opcode": "6F80", + "stack": "x_1 ... x_n n - t" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_mktuple_var", + "line": 94, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "TUPLEVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "n", + "name": "tuple_elements", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F81", + "tlb": "#6F81" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to k INDEX, but with 0 <= k <= 254 taken from the stack.

\n", + "fift": "INDEXVAR", + "fift_examples": [], + "gas": "26", + "opcode": "6F81", + "stack": "t k - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_index_var", + "line": 112, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEXVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F82", + "tlb": "#6F82" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to n UNTUPLE, but with 0 <= n <= 255 taken from the stack.

\n", + "fift": "UNTUPLEVAR", + "fift_examples": [], + "gas": "26+n", + "opcode": "6F82", + "stack": "t n - x_1 ... x_n" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_untuple_var", + "line": 164, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "UNTUPLEVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "n", + "name": "tuple_elements", + "type": "array" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F83", + "tlb": "#6F83" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to n UNPACKFIRST, but with 0 <= n <= 255 taken from the stack.

\n", + "fift": "UNPACKFIRSTVAR", + "fift_examples": [], + "gas": "26+n", + "opcode": "6F83", + "stack": "t n - x_1 ... x_n" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_untuple_first_var", + "line": 181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "UNPACKFIRSTVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "n", + "name": "tuple_elements", + "type": "array" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F84", + "tlb": "#6F84" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to n EXPLODE, but with 0 <= n <= 255 taken from the stack.

\n", + "fift": "EXPLODEVAR", + "fift_examples": [], + "gas": "26+m", + "opcode": "6F84", + "stack": "t n - x_1 ... x_m m" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_explode_tuple_var", + "line": 202, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "EXPLODEVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "m", + "name": "tuple_elements", + "type": "array" + }, + { + "name": "m", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F85", + "tlb": "#6F85" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to k SETINDEX, but with 0 <= k <= 254 taken from the stack.

\n", + "fift": "SETINDEXVAR", + "fift_examples": [], + "gas": "26+|t'|", + "opcode": "6F85", + "stack": "t x k - t'" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_set_index_var", + "line": 229, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "SETINDEXVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F86", + "tlb": "#6F86" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to n INDEXQ, but with 0 <= k <= 254 taken from the stack.

\n", + "fift": "INDEXVARQ", + "fift_examples": [], + "gas": "26", + "opcode": "6F86", + "stack": "t k - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_quiet_index_var", + "line": 130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEXVARQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F87", + "tlb": "#6F87" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to k SETINDEXQ, but with 0 <= k <= 254 taken from the stack.

\n", + "fift": "SETINDEXVARQ", + "fift_examples": [], + "gas": "26+|t'|", + "opcode": "6F87", + "stack": "t x k - t'" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_quiet_set_index_var", + "line": 258, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "SETINDEXVARQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F88", + "tlb": "#6F88" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Returns the length of a Tuple.

\n", + "fift": "TLEN", + "fift_examples": [], + "gas": "26", + "opcode": "6F88", + "stack": "t - n" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_length", + "line": 265, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "TLEN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F89", + "tlb": "#6F89" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Similar to TLEN, but returns -1 if t is not a Tuple.

\n", + "fift": "QTLEN", + "fift_examples": [], + "gas": "26", + "opcode": "6F89", + "stack": "t - n or -1" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_length_quiet", + "line": 273, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "QTLEN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F8A", + "tlb": "#6F8A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Returns -1 or 0 depending on whether t is a Tuple.

\n", + "fift": "ISTUPLE", + "fift_examples": [], + "gas": "26", + "opcode": "6F8A", + "stack": "t - ?" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_is_tuple", + "line": 281, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "ISTUPLE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F8B", + "tlb": "#6F8B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Returns the last element of a non-empty Tuple t.

\n", + "fift": "LAST", + "fift_examples": [], + "gas": "26", + "opcode": "6F8B", + "stack": "t - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_last", + "line": 288, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "LAST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F8C", + "tlb": "#6F8C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "TPUSH\nCOMMA", + "fift_examples": [], + "gas": "26+|t'|", + "opcode": "6F8C", + "stack": "t x - t'" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_push", + "line": 296, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "TPUSH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6F8D", + "tlb": "#6F8D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "TPOP", + "fift_examples": [], + "gas": "26+|t'|", + "opcode": "6F8D", + "stack": "t - t' x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_pop", + "line": 308, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "TPOP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t2", + "type": "simple", + "value_types": [ + "Tuple" + ] + }, + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA0", + "tlb": "#6FA0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Pushes a Null under the topmost Integer x, but only if x!=0.

\n", + "fift": "NULLSWAPIF", + "fift_examples": [], + "gas": "26", + "opcode": "6FA0", + "stack": "x - x or null x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if", + "line": 41, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLSWAPIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "match": [ + { + "stack": [], + "value": 0 + } + ], + "name": "x", + "type": "conditional" + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA1", + "tlb": "#6FA1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NULLSWAPIFNOT", + "fift_examples": [], + "gas": "26", + "opcode": "6FA1", + "stack": "x - x or null x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if", + "line": 41, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLSWAPIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [], + "match": [ + { + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "value": 0 + } + ], + "name": "x", + "type": "conditional" + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA2", + "tlb": "#6FA2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NULLROTRIF", + "fift_examples": [], + "gas": "26", + "opcode": "6FA2", + "stack": "x y - x y or null x y" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if", + "line": 41, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLROTRIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "match": [ + { + "stack": [], + "value": 0 + } + ], + "name": "y", + "type": "conditional" + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA3", + "tlb": "#6FA3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NULLROTRIFNOT", + "fift_examples": [], + "gas": "26", + "opcode": "6FA3", + "stack": "x y - x y or null x y" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if", + "line": 41, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLROTRIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [], + "match": [ + { + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "value": 0 + } + ], + "name": "y", + "type": "conditional" + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA4", + "tlb": "#6FA4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Pushes two nulls under the topmost Integer x, but only if x!=0.\nEquivalent to NULLSWAPIF NULLSWAPIF.

\n", + "fift": "NULLSWAPIF2", + "fift_examples": [], + "gas": "26", + "opcode": "6FA4", + "stack": "x - x or null null x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if_many", + "line": 56, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLSWAPIF2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "match": [ + { + "stack": [], + "value": 0 + } + ], + "name": "x", + "type": "conditional" + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA5", + "tlb": "#6FA5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Pushes two nulls under the topmost Integer x, but only if x=0.\nEquivalent to NULLSWAPIFNOT NULLSWAPIFNOT.

\n", + "fift": "NULLSWAPIFNOT2", + "fift_examples": [], + "gas": "26", + "opcode": "6FA5", + "stack": "x - x or null null x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if_many", + "line": 56, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLSWAPIFNOT2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [], + "match": [ + { + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "value": 0 + } + ], + "name": "x", + "type": "conditional" + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA6", + "tlb": "#6FA6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NULLROTRIF2", + "fift_examples": [], + "gas": "26", + "opcode": "6FA6", + "stack": "x y - x y or null null x y" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if_many", + "line": 56, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLROTRIF2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "match": [ + { + "stack": [], + "value": 0 + } + ], + "name": "y", + "type": "conditional" + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "6FA7", + "tlb": "#6FA7" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NULLROTRIFNOT2", + "fift_examples": [], + "gas": "26", + "opcode": "6FA7", + "stack": "x y - x y or null null x y" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_null_swap_if_many", + "line": 56, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "NULLROTRIFNOT2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "else": [], + "match": [ + { + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Null" + }, + { + "type": "const", + "value": null, + "value_type": "Null" + } + ], + "value": 0 + } + ], + "name": "y", + "type": "conditional" + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "i", + "size": 2, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "j", + "size": 2, + "type": "uint" + } + ], + "prefix": "6FB", + "tlb": "#6FB i:uint2 j:uint2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Recovers x=(t_{i+1})_{j+1} for 0 <= i,j <= 3.\nEquivalent to [i] INDEX [j] INDEX.

\n", + "fift": "[i] [j] INDEX2", + "fift_examples": [], + "gas": "26", + "opcode": "6FBij", + "stack": "t - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_index2", + "line": 320, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEX2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "i", + "size": 2, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "j", + "size": 2, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "k", + "size": 2, + "type": "uint" + } + ], + "prefix": "6FE_", + "tlb": "#6FE_ i:uint2 j:uint2 k:uint2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "tuple", + "description": "

Recovers x=t_{i+1}_{j+1}_{k+1}.\n0 <= i,j,k <= 3\nEquivalent to [i] [j] INDEX2 [k] INDEX.

\n", + "fift": "[i] [j] [k] INDEX3", + "fift_examples": [], + "gas": "26", + "opcode": "6FE_ijk", + "stack": "t - x" + }, + "implementation": [ + { + "file": "tupleops.cpp", + "function_name": "exec_tuple_index3", + "line": 340, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tupleops.cpp" + } + ], + "mnemonic": "INDEX3", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "pushint4" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "7", + "tlb": "#7 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "[x] PUSHINT\n[x] INT", + "fift_examples": [], + "gas": "18", + "opcode": "7i", + "stack": "- x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_tinyint4", + "line": 31, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHINT_4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "x", + "size": 8, + "type": "int" + } + ], + "prefix": "80", + "tlb": "#80 xx:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes integer xx. -128 <= xx <= 127.

\n", + "fift": "[xx] PUSHINT\n[xx] INT", + "fift_examples": [], + "gas": "26", + "opcode": "80xx", + "stack": "- xx" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_tinyint8", + "line": 46, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHINT_8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 32767, + "min_value": -32768, + "name": "x", + "size": 16, + "type": "int" + } + ], + "prefix": "81", + "tlb": "#81 xxxx:int16" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes integer xxxx. -2^15 <= xx < 2^15.

\n", + "fift": "[xxxx] PUSHINT\n[xxxx] INT", + "fift_examples": [], + "gas": "34", + "opcode": "81xxxx", + "stack": "- xxxx" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_smallint", + "line": 61, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHINT_16", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "name": "x", + "type": "pushint_long" + } + ], + "operands_range_check": { + "from": 0, + "length": 5, + "to": 30 + }, + "prefix": "82", + "tlb": "#82 l:(## 5) xxx:(int (8 * l + 19))" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes integer xxx.\nDetails: 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.

\n", + "fift": "[xxx] PUSHINT\n[xxx] INT", + "fift_examples": [], + "gas": "23", + "opcode": "82lxxx", + "stack": "- xxx" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_int", + "line": 76, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHINT_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 254, + "min_value": 0, + "name": "x", + "size": 8, + "type": "uint" + } + ], + "operands_range_check": { + "from": 0, + "length": 8, + "to": 254 + }, + "prefix": "83", + "tlb": "#83 xx:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

(Quietly) pushes 2^(xx+1) for 0 <= xx <= 255.\n2^256 is a NaN.

\n", + "fift": "[xx+1] PUSHPOW2", + "fift_examples": [], + "gas": "26", + "opcode": "83xx", + "stack": "- 2^(xx+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_pow2", + "line": 110, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHPOW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "83FF", + "tlb": "#83FF" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes a NaN.

\n", + "fift": "PUSHNAN", + "fift_examples": [], + "gas": "26", + "opcode": "83FF", + "stack": "- NaN" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_nan", + "line": 120, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHNAN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "type": "const", + "value": null, + "value_type": "Integer" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "x", + "size": 8, + "type": "uint" + } + ], + "prefix": "84", + "tlb": "#84 xx:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes 2^(xx+1)-1 for 0 <= xx <= 255.

\n", + "fift": "[xx+1] PUSHPOW2DEC", + "fift_examples": [], + "gas": "26", + "opcode": "84xx", + "stack": "- 2^(xx+1)-1" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_pow2dec", + "line": 129, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHPOW2DEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "x", + "size": 8, + "type": "uint" + } + ], + "prefix": "85", + "tlb": "#85 xx:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_int", + "description": "

Pushes -2^(xx+1) for 0 <= xx <= 255.

\n", + "fift": "[xx+1] PUSHNEGPOW2", + "fift_examples": [], + "gas": "26", + "opcode": "85xx", + "stack": "- -2^(xx+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_push_negpow2", + "line": 139, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "PUSHNEGPOW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "name": "c", + "type": "ref" + } + ], + "prefix": "88", + "tlb": "#88 c:^Cell" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes the reference ref into the stack.\nDetails: Pushes the first reference of cc.code into the stack as a Cell (and removes this reference from the current continuation).

\n", + "fift": "[ref] PUSHREF", + "fift_examples": [], + "gas": "18", + "opcode": "88", + "stack": "- c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_ref", + "line": 32, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "name": "c", + "type": "ref" + } + ], + "prefix": "89", + "tlb": "#89 c:^Cell" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Similar to PUSHREF, but converts the cell into a Slice.

\n", + "fift": "[ref] PUSHREFSLICE", + "fift_examples": [], + "gas": "118/43", + "opcode": "89", + "stack": "- s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_slice", + "line": 117, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHREFSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "8A", + "tlb": "#8A c:^Cell" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Similar to PUSHREFSLICE, but makes a simple ordinary Continuation out of the cell.

\n", + "fift": "[ref] PUSHREFCONT", + "fift_examples": [], + "gas": "118/43", + "opcode": "8A", + "stack": "- cont" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_cont", + "line": 165, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHREFCONT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 4, + "bits_padding": 4, + "completion_tag": true, + "display_hints": [], + "max_bits": 123, + "max_refs": 0, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "type": "subslice" + } + ], + "prefix": "8B", + "tlb": "#8B x:(## 4) sss:((8 * x + 4) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes the slice slice into the stack.\nDetails: 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.

\n", + "fift": "[slice] PUSHSLICE\n[slice] SLICE", + "fift_examples": [], + "gas": "22", + "opcode": "8Bxsss", + "stack": "- s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_slice", + "line": 117, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 5, + "bits_padding": 1, + "completion_tag": true, + "display_hints": [], + "max_bits": 248, + "max_refs": 4, + "min_bits": 0, + "min_refs": 1, + "name": "slice", + "refs_add": 1, + "refs_length_var_size": 2, + "type": "subslice" + } + ], + "prefix": "8C", + "tlb": "#8C r:(## 2) xx:(## 5) c:((r + 1) * ^Cell) ssss:((8 * xx + 1) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes the slice slice into the stack.\nDetails: 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.

\n", + "fift": "[slice] PUSHSLICE\n[slice] SLICE", + "fift_examples": [], + "gas": "25", + "opcode": "8Crxxssss", + "stack": "- s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_slice_r", + "line": 129, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHSLICE_REFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 7, + "bits_padding": 6, + "completion_tag": true, + "display_hints": [], + "max_bits": 1021, + "max_refs": 4, + "min_bits": 0, + "min_refs": 0, + "name": "slice", + "refs_add": 0, + "refs_length_var_size": 3, + "type": "subslice" + } + ], + "operands_range_check": { + "from": 0, + "length": 3, + "to": 4 + }, + "prefix": "8D", + "tlb": "#8D r:(#<= 4) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx + 6) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes the slice slice into the stack.\nDetails: 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.

\n", + "fift": "[slice] PUSHSLICE\n[slice] SLICE", + "fift_examples": [ + { + "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": "x{} PUSHSLICE x{ABCD1234} PUSHSLICE b{01101} PUSHSLICE" + }, + { + "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).", + "fift": " PUSHREF PUSHREFSLICE" + } + ], + "gas": "28", + "opcode": "8Drxxsssss", + "stack": "- s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_slice", + "line": 117, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHSLICE_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 7, + "bits_padding": 0, + "completion_tag": false, + "display_hints": [ + { + "type": "continuation" + } + ], + "max_bits": 1016, + "max_refs": 3, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "refs_add": 0, + "refs_length_var_size": 2, + "type": "subslice" + } + ], + "prefix": "8F_", + "tlb": "#8F_ r:(## 2) xx:(## 7) c:(r * ^Cell) ssss:((8 * xx) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes a continuation made from builder.\nDetails: Pushes the simple ordinary continuation cccc made from the first 0 <= r <= 3 references and the first 0 <= xx <= 127 bytes of cc.code.

\n", + "fift": "[builder] PUSHCONT\n[builder] CONT", + "fift_examples": [], + "gas": "26", + "opcode": "8F_rxxcccc", + "stack": "- c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_cont", + "line": 165, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHCONT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 4, + "bits_padding": 0, + "completion_tag": false, + "display_hints": [ + { + "type": "continuation" + } + ], + "max_bits": 120, + "max_refs": 0, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "type": "subslice" + } + ], + "prefix": "9", + "tlb": "#9 x:(## 4) ssss:((8 * x) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "const_data", + "description": "

Pushes a continuation made from builder.\nDetails: Pushes an x-byte continuation for 0 <= x <= 15.

\n", + "fift": "[builder] PUSHCONT\n[builder] CONT", + "fift_examples": [ + { + "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).", + "fift": "<{ code }> PUSHCONT <{ code }> CONT CONT:<{ code }>" + } + ], + "gas": "18", + "opcode": "9xccc", + "stack": "- c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_push_cont", + "line": 165, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PUSHCONT_SHORT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A0", + "tlb": "#A0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "", + "fift": "ADD", + "fift_examples": [], + "gas": "18", + "opcode": "A0", + "stack": "x y - x+y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_add", + "line": 162, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A1", + "tlb": "#A1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "", + "fift": "SUB", + "fift_examples": [], + "gas": "18", + "opcode": "A1", + "stack": "x y - x-y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_sub", + "line": 171, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "SUB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A2", + "tlb": "#A2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "

Equivalent to SWAP SUB.

\n", + "fift": "SUBR", + "fift_examples": [], + "gas": "18", + "opcode": "A2", + "stack": "x y - y-x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_subr", + "line": 180, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "SUBR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A3", + "tlb": "#A3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "NEGATE", + "fift_examples": [], + "gas": "18", + "opcode": "A3", + "stack": "x - -x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_negate", + "line": 189, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "NEGATE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A4", + "tlb": "#A4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "

Equivalent to 1 ADDCONST.

\n", + "fift": "INC", + "fift_examples": [], + "gas": "18", + "opcode": "A4", + "stack": "x - x+1" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_inc", + "line": 197, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "INC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A5", + "tlb": "#A5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "

Equivalent to -1 ADDCONST.

\n", + "fift": "DEC", + "fift_examples": [], + "gas": "18", + "opcode": "A5", + "stack": "x - x-1" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_dec", + "line": 205, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "c", + "size": 8, + "type": "int" + } + ], + "prefix": "A6", + "tlb": "#A6 cc:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "

-128 <= cc <= 127.

\n", + "fift": "[cc] ADDCONST\n[cc] ADDINT\n[-cc] SUBCONST\n[-cc] SUBINT", + "fift_examples": [], + "gas": "26", + "opcode": "A6cc", + "stack": "x - x+cc" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_add_tinyint8", + "line": 213, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDCONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "c", + "size": 8, + "type": "int" + } + ], + "prefix": "A7", + "tlb": "#A7 cc:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "

-128 <= cc <= 127.

\n", + "fift": "[cc] MULCONST\n[cc] MULINT", + "fift_examples": [], + "gas": "26", + "opcode": "A7cc", + "stack": "x - x*cc" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mul_tinyint8", + "line": 222, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULCONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A8", + "tlb": "#A8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_basic", + "description": "", + "fift": "MUL", + "fift_examples": [], + "gas": "18", + "opcode": "A8", + "stack": "x y - x*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mul", + "line": 231, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MUL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A900", + "tlb": "#A900" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDDIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A900", + "stack": "x w z - q=floor((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDDIVMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A901", + "tlb": "#A901" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDDIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A901", + "stack": "x w z - q=round((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDDIVMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A902", + "tlb": "#A902" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDDIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A902", + "stack": "x w y - q=ceil((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDDIVMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A904", + "tlb": "#A904" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q=floor(x/y), r=x-y*q

\n", + "fift": "DIV", + "fift_examples": [], + "gas": "26", + "opcode": "A904", + "stack": "x y - q" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A905", + "tlb": "#A905" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q'=round(x/y), r'=x-y*q'

\n", + "fift": "DIVR", + "fift_examples": [], + "gas": "26", + "opcode": "A905", + "stack": "x y - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIVR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A906", + "tlb": "#A906" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q''=ceil(x/y), r''=x-y*q''

\n", + "fift": "DIVC", + "fift_examples": [], + "gas": "26", + "opcode": "A906", + "stack": "x y - q''" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIVC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A908", + "tlb": "#A908" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MOD", + "fift_examples": [], + "gas": "26", + "opcode": "A908", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A909", + "tlb": "#A909" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MODR", + "fift_examples": [], + "gas": "26", + "opcode": "A909", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A90A", + "tlb": "#A90A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MODC", + "fift_examples": [], + "gas": "26", + "opcode": "A90A", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A90C", + "tlb": "#A90C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "DIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A90C", + "stack": "x y - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIVMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A90D", + "tlb": "#A90D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "DIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A90D", + "stack": "x y - q' r'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIVMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A90E", + "tlb": "#A90E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "DIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A90E", + "stack": "x y - q'' r''" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "DIVMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A920", + "tlb": "#A920" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDRSHIFTMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A920", + "stack": "x w z - q=floor((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A921", + "tlb": "#A921" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDRSHIFTMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A921", + "stack": "x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A922", + "tlb": "#A922" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "ADDRSHIFTMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A922", + "stack": "x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A925", + "tlb": "#A925" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "RSHIFTR", + "fift_examples": [], + "gas": "26", + "opcode": "A925", + "stack": "x y - round(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A926", + "tlb": "#A926" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "RSHIFTC", + "fift_examples": [], + "gas": "26", + "opcode": "A926", + "stack": "x y - ceil(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A928", + "tlb": "#A928" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MODPOW2", + "fift_examples": [], + "gas": "26", + "opcode": "A928", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A929", + "tlb": "#A929" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MODPOW2R", + "fift_examples": [], + "gas": "26", + "opcode": "A929", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2R_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A92A", + "tlb": "#A92A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MODPOW2C", + "fift_examples": [], + "gas": "26", + "opcode": "A92A", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2C_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A92C", + "tlb": "#A92C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "RSHIFTMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A92C", + "stack": "x y - q=floor(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A92D", + "tlb": "#A92D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "RSHIFTMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A92D", + "stack": "x y - q=round(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A92E", + "tlb": "#A92E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "RSHIFTMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A92E", + "stack": "x y - q=ceil(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A930", + "tlb": "#A930 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] ADDRSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A930tt", + "stack": "x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A931", + "tlb": "#A931 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] ADDRSHIFTR#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A931tt", + "stack": "x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTRMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A932", + "tlb": "#A932 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] ADDRSHIFTC#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A932tt", + "stack": "x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ADDRSHIFTCMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A935", + "tlb": "#A935 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] RSHIFTR#", + "fift_examples": [], + "gas": "34", + "opcode": "A935tt", + "stack": "x - round(x/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A936", + "tlb": "#A936 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] RSHIFTC#", + "fift_examples": [], + "gas": "34", + "opcode": "A936tt", + "stack": "x - ceil(x/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A938", + "tlb": "#A938 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MODPOW2#", + "fift_examples": [], + "gas": "34", + "opcode": "A938tt", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A939", + "tlb": "#A939 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MODPOW2R#", + "fift_examples": [], + "gas": "34", + "opcode": "A939tt", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2R", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A93A", + "tlb": "#A93A tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MODPOW2C#", + "fift_examples": [], + "gas": "34", + "opcode": "A93Att", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MODPOW2C", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A93C", + "tlb": "#A93C tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] RSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A93Ctt", + "stack": "x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A93D", + "tlb": "#A93D tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] RSHIFTR#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A93Dtt", + "stack": "x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTRMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A93E", + "tlb": "#A93E tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] RSHIFTC#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A93Ett", + "stack": "x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFTCMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A980", + "tlb": "#A980" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDDIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A980", + "stack": "x y w z - q=floor((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDDIVMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A981", + "tlb": "#A981" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDDIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A981", + "stack": "x y w z - q=round((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDDIVMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A982", + "tlb": "#A982" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDDIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A982", + "stack": "x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDDIVMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A984", + "tlb": "#A984" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q=floor(x*y/z)

\n", + "fift": "MULDIV", + "fift_examples": [], + "gas": "26", + "opcode": "A984", + "stack": "x y z - q" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A985", + "tlb": "#A985" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q'=round(x*y/z)

\n", + "fift": "MULDIVR", + "fift_examples": [], + "gas": "26", + "opcode": "A985", + "stack": "x y z - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIVR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A986", + "tlb": "#A986" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q'=ceil(x*y/z)

\n", + "fift": "MULDIVC", + "fift_examples": [], + "gas": "26", + "opcode": "A986", + "stack": "x y z - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIVC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A988", + "tlb": "#A988" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A988", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A989", + "tlb": "#A989" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A989", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A98A", + "tlb": "#A98A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A98A", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A98C", + "tlb": "#A98C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q=floor(x*y/z), r=x*y-z*q

\n", + "fift": "MULDIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A98C", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIVMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A98D", + "tlb": "#A98D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q=round(x*y/z), r=x*y-z*q

\n", + "fift": "MULDIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A98D", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIVMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A98E", + "tlb": "#A98E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

q=ceil(x*y/z), r=x*y-z*q

\n", + "fift": "MULDIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A98E", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULDIVMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A0", + "tlb": "#A9A0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDRSHIFTMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9A0", + "stack": "x y w z - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A1", + "tlb": "#A9A1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDRSHIFTRMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9A1", + "stack": "x y w z - q=round((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTRMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A2", + "tlb": "#A9A2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULADDRSHIFTCMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9A2", + "stack": "x y w z - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTCMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A4", + "tlb": "#A9A4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "MULRSHIFT", + "fift_examples": [], + "gas": "26", + "opcode": "A9A4", + "stack": "x y z - floor(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A5", + "tlb": "#A9A5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "MULRSHIFTR", + "fift_examples": [], + "gas": "26", + "opcode": "A9A5", + "stack": "x y z - round(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A6", + "tlb": "#A9A6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "MULRSHIFTC", + "fift_examples": [], + "gas": "26", + "opcode": "A9A6", + "stack": "x y z - ceil(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A8", + "tlb": "#A9A8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMODPOW2_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9A8", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9A9", + "tlb": "#A9A9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMODPOW2R_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9A9", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2R_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9AA", + "tlb": "#A9AA" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULMODPOW2C_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9AA", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2C_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9AC", + "tlb": "#A9AC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFTMOD_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9AC", + "stack": "x y z - q=floor(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9AD", + "tlb": "#A9AD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFTRMOD_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9AD", + "stack": "x y z - q=round(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTRMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9AE", + "tlb": "#A9AE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFTCMOD_VAR", + "fift_examples": [], + "gas": "26", + "opcode": "A9AE", + "stack": "x y z - q=ceil(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTCMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B0", + "tlb": "#A9B0 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULADDRSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9B0tt", + "stack": "x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B1", + "tlb": "#A9B1 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULADDRSHIFTR#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9B1tt", + "stack": "x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTRMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B2", + "tlb": "#A9B2 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULADDRSHIFTC#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9B2tt", + "stack": "x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULADDRSHIFTCMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B4", + "tlb": "#A9B4 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULRSHIFT#", + "fift_examples": [], + "gas": "34", + "opcode": "A9B4tt", + "stack": "x y - floor(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B5", + "tlb": "#A9B5 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULRSHIFTR#", + "fift_examples": [], + "gas": "34", + "opcode": "A9B5tt", + "stack": "x y - round(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B6", + "tlb": "#A9B6 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULRSHIFTC#", + "fift_examples": [], + "gas": "34", + "opcode": "A9B6tt", + "stack": "x y - ceil(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B8", + "tlb": "#A9B8 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULMODPOW2#", + "fift_examples": [], + "gas": "34", + "opcode": "A9B8tt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9B9", + "tlb": "#A9B9 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULMODPOW2R#", + "fift_examples": [], + "gas": "34", + "opcode": "A9B9tt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2R", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9BA", + "tlb": "#A9BA tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] MULMODPOW2C#", + "fift_examples": [], + "gas": "34", + "opcode": "A9BAtt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULMODPOW2C", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9BC", + "tlb": "#A9BC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9BC", + "stack": "x y - q=floor(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9BD", + "tlb": "#A9BD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFTR#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9BD", + "stack": "x y - q=round(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTRMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9BE", + "tlb": "#A9BE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "MULRSHIFTC#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9BE", + "stack": "x y - q=ceil(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MULRSHIFTCMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C0", + "tlb": "#A9C0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTADDDIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9C0", + "stack": "x w z y - q=floor((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C1", + "tlb": "#A9C1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTADDDIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A9C1", + "stack": "x w z y - q=round((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMODR_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C2", + "tlb": "#A9C2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTADDDIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A9C2", + "stack": "x w z y - q=round((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMODC_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C4", + "tlb": "#A9C4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "LSHIFTDIV", + "fift_examples": [], + "gas": "26", + "opcode": "A9C4", + "stack": "x y z - floor(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIV_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C5", + "tlb": "#A9C5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "LSHIFTDIVR", + "fift_examples": [], + "gas": "26", + "opcode": "A9C5", + "stack": "x y z - round(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C6", + "tlb": "#A9C6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "

0 <= z <= 256

\n", + "fift": "LSHIFTDIVC", + "fift_examples": [], + "gas": "26", + "opcode": "A9C6", + "stack": "x y z - ceil(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C8", + "tlb": "#A9C8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9C8", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9C9", + "tlb": "#A9C9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A9C9", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9CA", + "tlb": "#A9CA" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A9CA", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9CC", + "tlb": "#A9CC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTDIVMOD", + "fift_examples": [], + "gas": "26", + "opcode": "A9CC", + "stack": "x y z - q=floor(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9CD", + "tlb": "#A9CD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTDIVMODR", + "fift_examples": [], + "gas": "26", + "opcode": "A9CD", + "stack": "x y z - q=round(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "A9CE", + "tlb": "#A9CE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "LSHIFTDIVMODC", + "fift_examples": [], + "gas": "26", + "opcode": "A9CE", + "stack": "x y z - q=ceil(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D0", + "tlb": "#A9D0 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#ADDDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9D0tt", + "stack": "x w z - q=floor((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D1", + "tlb": "#A9D1 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#ADDDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "A9D1tt", + "stack": "x w z - q=round((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D2", + "tlb": "#A9D2 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#ADDDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "A9D2tt", + "stack": "x w z - q=ceil((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTADDDIVMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D4", + "tlb": "#A9D4 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIV", + "fift_examples": [], + "gas": "34", + "opcode": "A9D4tt", + "stack": "x y - floor(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D5", + "tlb": "#A9D5 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIVR", + "fift_examples": [], + "gas": "34", + "opcode": "A9D5tt", + "stack": "x y - round(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D6", + "tlb": "#A9D6 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIVC", + "fift_examples": [], + "gas": "34", + "opcode": "A9D6tt", + "stack": "x y - ceil(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D8", + "tlb": "#A9D8 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9D8tt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9D9", + "tlb": "#A9D9 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#MODR", + "fift_examples": [], + "gas": "34", + "opcode": "A9D9tt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9DA", + "tlb": "#A9DA tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#MODC", + "fift_examples": [], + "gas": "34", + "opcode": "A9DAtt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9DC", + "tlb": "#A9DC tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "A9DCtt", + "stack": "x y - q=floor(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9DD", + "tlb": "#A9DD tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "A9DDtt", + "stack": "x y - q=round(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "A9DE", + "tlb": "#A9DE tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_div", + "description": "", + "fift": "[tt+1] LSHIFT#DIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "A9DEtt", + "stack": "x y - q=ceil(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFTDIVMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "AA", + "tlb": "#AA cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

0 <= cc <= 255

\n", + "fift": "[cc+1] LSHIFT#", + "fift_examples": [], + "gas": "26", + "opcode": "AAcc", + "stack": "x - x*2^(cc+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_lshift", + "line": 740, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "AB", + "tlb": "#AB cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

0 <= cc <= 255

\n", + "fift": "[cc+1] RSHIFT#", + "fift_examples": [], + "gas": "26", + "opcode": "ABcc", + "stack": "x - floor(x/2^(cc+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_rshift", + "line": 749, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "AC", + "tlb": "#AC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

0 <= y <= 1023

\n", + "fift": "LSHIFT", + "fift_examples": [], + "gas": "18", + "opcode": "AC", + "stack": "x y - x*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_lshift_tinyint8", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "AD", + "tlb": "#AD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

0 <= y <= 1023

\n", + "fift": "RSHIFT", + "fift_examples": [], + "gas": "18", + "opcode": "AD", + "stack": "x y - floor(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_rshift_tinyint8", + "line": 731, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "RSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "AE", + "tlb": "#AE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

0 <= y <= 1023\nEquivalent to ONE SWAP LSHIFT.

\n", + "fift": "POW2", + "fift_examples": [], + "gas": "18", + "opcode": "AE", + "stack": "y - 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_pow2", + "line": 758, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "POW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B0", + "tlb": "#B0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Bitwise and of two signed integers x and y, sign-extended to infinity.

\n", + "fift": "AND", + "fift_examples": [], + "gas": "18", + "opcode": "B0", + "stack": "x y - x&y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_and", + "line": 769, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "AND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B1", + "tlb": "#B1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Bitwise or of two integers.

\n", + "fift": "OR", + "fift_examples": [], + "gas": "18", + "opcode": "B1", + "stack": "x y - x|y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_or", + "line": 778, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "OR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B2", + "tlb": "#B2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Bitwise xor of two integers.

\n", + "fift": "XOR", + "fift_examples": [], + "gas": "18", + "opcode": "B2", + "stack": "x y - x xor y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_xor", + "line": 787, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "XOR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B3", + "tlb": "#B3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Bitwise not of an integer.

\n", + "fift": "NOT", + "fift_examples": [], + "gas": "18", + "opcode": "B3", + "stack": "x - ~x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_not", + "line": 796, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "NOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B4", + "tlb": "#B4 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "[cc+1] FITS", + "fift_examples": [], + "gas": "26/76", + "opcode": "B4cc", + "stack": "x - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_fits_tinyint8", + "line": 804, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "FITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B5", + "tlb": "#B5 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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)).

\n", + "fift": "[cc+1] UFITS", + "fift_examples": [], + "gas": "26/76", + "opcode": "B5cc", + "stack": "x - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_ufits_tinyint8", + "line": 817, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "UFITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B600", + "tlb": "#B600" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Checks whether x is a c-bit signed integer for 0 <= c <= 1023.

\n", + "fift": "FITSX", + "fift_examples": [], + "gas": "26/76", + "opcode": "B600", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_fits", + "line": 830, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "FITSX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B601", + "tlb": "#B601" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Checks whether x is a c-bit unsigned integer for 0 <= c <= 1023.

\n", + "fift": "UFITSX", + "fift_examples": [], + "gas": "26/76", + "opcode": "B601", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_ufits", + "line": 843, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "UFITSX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B602", + "tlb": "#B602" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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)).

\n", + "fift": "BITSIZE", + "fift_examples": [], + "gas": "26", + "opcode": "B602", + "stack": "x - c" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_bitsize", + "line": 856, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "BITSIZE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B603", + "tlb": "#B603" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "UBITSIZE", + "fift_examples": [], + "gas": "26", + "opcode": "B603", + "stack": "x - c" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_bitsize", + "line": 856, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "UBITSIZE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B608", + "tlb": "#B608" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Computes the minimum of two integers x and y.

\n", + "fift": "MIN", + "fift_examples": [], + "gas": "26", + "opcode": "B608", + "stack": "x y - x or y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_minmax", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B609", + "tlb": "#B609" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Computes the maximum of two integers x and y.

\n", + "fift": "MAX", + "fift_examples": [], + "gas": "26", + "opcode": "B609", + "stack": "x y - x or y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_minmax", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B60A", + "tlb": "#B60A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Sorts two integers. Quiet version of this operation returns two NaNs if any of the arguments are NaNs.

\n", + "fift": "MINMAX\nINTSORT2", + "fift_examples": [], + "gas": "26", + "opcode": "B60A", + "stack": "x y - x y or y x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_minmax", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "MINMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "r1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B60B", + "tlb": "#B60B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_logical", + "description": "

Computes the absolute value of an integer x.

\n", + "fift": "ABS", + "fift_examples": [], + "gas": "26", + "opcode": "B60B", + "stack": "x - |x|" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_abs", + "line": 936, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ABS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A0", + "tlb": "#B7A0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADD", + "fift_examples": [], + "gas": "26", + "opcode": "B7A0", + "stack": "x y - x+y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_add", + "line": 162, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A1", + "tlb": "#B7A1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QSUB", + "fift_examples": [], + "gas": "26", + "opcode": "B7A1", + "stack": "x y - x-y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_sub", + "line": 171, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QSUB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A2", + "tlb": "#B7A2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QSUBR", + "fift_examples": [], + "gas": "26", + "opcode": "B7A2", + "stack": "x y - y-x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_subr", + "line": 180, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QSUBR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A3", + "tlb": "#B7A3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QNEGATE", + "fift_examples": [], + "gas": "26", + "opcode": "B7A3", + "stack": "x - -x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_negate", + "line": 189, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QNEGATE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A4", + "tlb": "#B7A4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QINC", + "fift_examples": [], + "gas": "26", + "opcode": "B7A4", + "stack": "x - x+1" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_inc", + "line": 197, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QINC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A5", + "tlb": "#B7A5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDEC", + "fift_examples": [], + "gas": "26", + "opcode": "B7A5", + "stack": "x - x-1" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_dec", + "line": 205, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A8", + "tlb": "#B7A8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMUL", + "fift_examples": [], + "gas": "26", + "opcode": "B7A8", + "stack": "x y - x*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mul", + "line": 231, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMUL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A900", + "tlb": "#B7A900" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A900", + "stack": "x w z - q=floor((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDDIVMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A901", + "tlb": "#B7A901" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A901", + "stack": "x w z - q=round((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDDIVMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A902", + "tlb": "#B7A902" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A902", + "stack": "x w y - q=ceil((x+w)/z) r=(x+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDDIVMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A904", + "tlb": "#B7A904" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

Division returns NaN if y=0.

\n", + "fift": "QDIV", + "fift_examples": [], + "gas": "34", + "opcode": "B7A904", + "stack": "x y - q" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A905", + "tlb": "#B7A905" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDIVR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A905", + "stack": "x y - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIVR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A906", + "tlb": "#B7A906" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDIVC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A906", + "stack": "x y - q''" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIVC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A908", + "tlb": "#B7A908" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A908", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A909", + "tlb": "#B7A909" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A909", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A90A", + "tlb": "#B7A90A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A90A", + "stack": "x y - r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A90C", + "tlb": "#B7A90C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A90C", + "stack": "x y - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIVMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A90D", + "tlb": "#B7A90D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A90D", + "stack": "x y - q' r'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIVMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A90E", + "tlb": "#B7A90E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A90E", + "stack": "x y - q'' r''" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_divmod", + "line": 266, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QDIVMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A920", + "tlb": "#B7A920" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDRSHIFTMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A920", + "stack": "x w z - q=floor((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A921", + "tlb": "#B7A921" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDRSHIFTMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A921", + "stack": "x w z - q=round((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A922", + "tlb": "#B7A922" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QADDRSHIFTMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A922", + "stack": "x w z - q=ceil((x+w)/2^z) r=(x+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A925", + "tlb": "#B7A925" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFTR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A925", + "stack": "x y - round(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A926", + "tlb": "#B7A926" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFTC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A926", + "stack": "x y - ceil(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A928", + "tlb": "#B7A928" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMODPOW2", + "fift_examples": [], + "gas": "34", + "opcode": "B7A928", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A929", + "tlb": "#B7A929" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMODPOW2R", + "fift_examples": [], + "gas": "34", + "opcode": "B7A929", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2R_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A92A", + "tlb": "#B7A92A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMODPOW2C", + "fift_examples": [], + "gas": "34", + "opcode": "B7A92A", + "stack": "x y - x mod 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2C_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A92C", + "tlb": "#B7A92C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFTMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A92C", + "stack": "x y - q=floor(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A92D", + "tlb": "#B7A92D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFTMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A92D", + "stack": "x y - q=round(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A92E", + "tlb": "#B7A92E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFTMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A92E", + "stack": "x y - q=ceil(x/2^y) r=x-q*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A930", + "tlb": "#B7A930 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QADDRSHIFT#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A930tt", + "stack": "x w - q=floor((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A931", + "tlb": "#B7A931 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QADDRSHIFTR#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A931tt", + "stack": "x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTRMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A932", + "tlb": "#B7A932 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QADDRSHIFTC#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A932tt", + "stack": "x w - q=round((x+w)/2^(tt+1)) r=(x+w)-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QADDRSHIFTCMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A935", + "tlb": "#B7A935 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QRSHIFTR#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A935tt", + "stack": "x - round(x/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A936", + "tlb": "#B7A936 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QRSHIFTC#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A936tt", + "stack": "x - ceil(x/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A938", + "tlb": "#B7A938 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMODPOW2#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A938tt", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A939", + "tlb": "#B7A939 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMODPOW2R#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A939tt", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2R", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A93A", + "tlb": "#B7A93A tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMODPOW2C#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A93Att", + "stack": "x - x mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMODPOW2C", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A93C", + "tlb": "#B7A93C tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QRSHIFT#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A93Ctt", + "stack": "x - q=floor(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A93D", + "tlb": "#B7A93D tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QRSHIFTR#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A93Dtt", + "stack": "x - q=round(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTRMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A93E", + "tlb": "#B7A93E tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QRSHIFTC#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A93Ett", + "stack": "x - q=ceil(x/2^(tt+1)) r=x-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFTCMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A980", + "tlb": "#B7A980" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A980", + "stack": "x y w z - q=floor((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDDIVMOD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A981", + "tlb": "#B7A981" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A981", + "stack": "x y w z - q=round((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDDIVMODR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A982", + "tlb": "#B7A982" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A982", + "stack": "x y w z - q=ceil((xy+w)/z) r=(xy+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDDIVMODC", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A984", + "tlb": "#B7A984" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

q=floor(x*y/z)

\n", + "fift": "QMULDIV", + "fift_examples": [], + "gas": "34", + "opcode": "B7A984", + "stack": "x y z - q" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A985", + "tlb": "#B7A985" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULDIVR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A985", + "stack": "x y z - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIVR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A986", + "tlb": "#B7A986" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

q'=ceil(x*y/z)

\n", + "fift": "QMULDIVC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A986", + "stack": "x y z - q'" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIVC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A988", + "tlb": "#B7A988" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A988", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A989", + "tlb": "#B7A989" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A989", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A98A", + "tlb": "#B7A98A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A98A", + "stack": "x y z - x*y mod z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A98C", + "tlb": "#B7A98C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A98C", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIVMOD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A98D", + "tlb": "#B7A98D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

q=round(x*y/z), r=x*y-z*q

\n", + "fift": "QMULDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A98D", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIVMODR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A98E", + "tlb": "#B7A98E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

q=ceil(x*y/z), r=x*y-z*q

\n", + "fift": "QMULDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A98E", + "stack": "x y z - q r" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_muldivmod", + "line": 434, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULDIVMODC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A0", + "tlb": "#B7A9A0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDRSHIFTMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A0", + "stack": "x y w z - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A1", + "tlb": "#B7A9A1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDRSHIFTRMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A1", + "stack": "x y w z - q=round((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTRMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A2", + "tlb": "#B7A9A2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULADDRSHIFTCMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A2", + "stack": "x y w z - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTCMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "q", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A4", + "tlb": "#B7A9A4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QMULRSHIFT", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A4", + "stack": "x y z - floor(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A5", + "tlb": "#B7A9A5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QMULRSHIFTR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A5", + "stack": "x y z - round(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A6", + "tlb": "#B7A9A6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QMULRSHIFTC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A6", + "stack": "x y z - ceil(x*y/2^z)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A8", + "tlb": "#B7A9A8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMODPOW2_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A8", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9A9", + "tlb": "#B7A9A9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMODPOW2R_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9A9", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2R_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9AA", + "tlb": "#B7A9AA" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULMODPOW2C_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9AA", + "stack": "x y z - x*y mod 2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2C_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9AC", + "tlb": "#B7A9AC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFTMOD_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9AC", + "stack": "x y z - q=floor(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9AD", + "tlb": "#B7A9AD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFTRMOD_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9AD", + "stack": "x y z - q=round(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTRMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9AE", + "tlb": "#B7A9AE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFTCMOD_VAR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9AE", + "stack": "x y z - q=ceil(x*y/2^z) r=xy-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTCMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B0", + "tlb": "#B7A9B0 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULADDRSHIFT#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B0tt", + "stack": "x y w - q=floor((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B1", + "tlb": "#B7A9B1 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULADDRSHIFTR#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B1tt", + "stack": "x y w - q=round((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTRMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B2", + "tlb": "#B7A9B2 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULADDRSHIFTC#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B2tt", + "stack": "x y w - q=ceil((xy+w)/2^z) r=(xy+w)-q*2^z" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shrmod", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULADDRSHIFTCMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B4", + "tlb": "#B7A9B4 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULRSHIFT#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B4tt", + "stack": "x y - floor(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFT", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B5", + "tlb": "#B7A9B5 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULRSHIFTR#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B5tt", + "stack": "x y - round(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B6", + "tlb": "#B7A9B6 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULRSHIFTC#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B6tt", + "stack": "x y - ceil(x*y/2^(tt+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B8", + "tlb": "#B7A9B8 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULMODPOW2#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B8tt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9B9", + "tlb": "#B7A9B9 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULMODPOW2R#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9B9tt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2R", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9BA", + "tlb": "#B7A9BA tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QMULMODPOW2C#", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9BAtt", + "stack": "x y - x*y mod 2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULMODPOW2C", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9BC", + "tlb": "#B7A9BC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFT#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9BC", + "stack": "x y - q=floor(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9BD", + "tlb": "#B7A9BD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFTR#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9BD", + "stack": "x y - q=round(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTRMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9BE", + "tlb": "#B7A9BE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QMULRSHIFTC#MOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9BE", + "stack": "x y - q=ceil(x*y/2^(tt+1)) r=xy-q*2^(tt+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_mulshrmod", + "line": 497, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QMULRSHIFTCMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C0", + "tlb": "#B7A9C0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTADDDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C0", + "stack": "x w z y - q=floor((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMOD_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C1", + "tlb": "#B7A9C1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTADDDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C1", + "stack": "x w z y - q=round((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMODR_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C2", + "tlb": "#B7A9C2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTADDDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C2", + "stack": "x w z y - q=round((x*2^y+w)/z) r=(x*2^y+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMODC_VAR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C4", + "tlb": "#B7A9C4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QLSHIFTDIV", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C4", + "stack": "x y z - floor(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIV_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C5", + "tlb": "#B7A9C5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QLSHIFTDIVR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C5", + "stack": "x y z - round(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C6", + "tlb": "#B7A9C6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= z <= 256

\n", + "fift": "QLSHIFTDIVC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C6", + "stack": "x y z - ceil(2^z*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C8", + "tlb": "#B7A9C8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C8", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9C9", + "tlb": "#B7A9C9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9C9", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9CA", + "tlb": "#B7A9CA" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9CA", + "stack": "x y z - 2^z*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9CC", + "tlb": "#B7A9CC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTDIVMOD", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9CC", + "stack": "x y z - q=floor(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMOD_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9CD", + "tlb": "#B7A9CD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTDIVMODR", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9CD", + "stack": "x y z - q=round(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMODR_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7A9CE", + "tlb": "#B7A9CE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFTDIVMODC", + "fift_examples": [], + "gas": "34", + "opcode": "B7A9CE", + "stack": "x y z - q=ceil(2^z*x/y) r=2^z*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMODC_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D0", + "tlb": "#B7A9D0 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#ADDDIVMOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D0tt", + "stack": "x w z - q=floor((x*2^(tt+1)+w)/z) r=(x*2^(tt+1)+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D1", + "tlb": "#B7A9D1 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#ADDDIVMODR", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D1tt", + "stack": "x w z - q=round((x*2^(tt+1)+w)/z) r=(x*2^(tt+1)+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMODR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D2", + "tlb": "#B7A9D2 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#ADDDIVMODC", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D2tt", + "stack": "x w z - q=ceil((x*2^(tt+1)+w)/z) r=(x*2^(tt+1)+w)-zq" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTADDDIVMODC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "w", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D4", + "tlb": "#B7A9D4 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIV", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D4tt", + "stack": "x y - floor(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIV", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D5", + "tlb": "#B7A9D5 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIVR", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D5tt", + "stack": "x y - round(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D6", + "tlb": "#B7A9D6 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIVC", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D6tt", + "stack": "x y - ceil(2^(tt+1)*x/y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D8", + "tlb": "#B7A9D8 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#MOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D8tt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9D9", + "tlb": "#B7A9D9 tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#MODR", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9D9tt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMODR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9DA", + "tlb": "#B7A9DA tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#MODC", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9DAtt", + "stack": "x y - 2^(tt+1)*x mod y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTMODC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9DC", + "tlb": "#B7A9DC tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIVMOD", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9DCtt", + "stack": "x y - q=floor(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMOD", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9DD", + "tlb": "#B7A9DD tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIVMODR", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9DDtt", + "stack": "x y - q=round(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMODR", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "t", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7A9DE", + "tlb": "#B7A9DE tt:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "[tt+1] QLSHIFT#DIVMODC", + "fift_examples": [], + "gas": "42", + "opcode": "B7A9DEtt", + "stack": "x y - q=ceil(2^(tt+1)*x/y) r=2^(tt+1)*x-q*y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_shldivmod", + "line": 595, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFTDIVMODC", + "since_version": 9999, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7AA", + "tlb": "#B7AA cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= cc <= 255

\n", + "fift": "[cc+1] QLSHIFT#", + "fift_examples": [], + "gas": "34", + "opcode": "B7AAcc", + "stack": "x - x*2^(cc+1)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_lshift", + "line": 740, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7AB", + "tlb": "#B7AB cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

0 <= cc <= 255

\n", + "fift": "[cc+1] QRSHIFT#", + "fift_examples": [], + "gas": "34", + "opcode": "B7ABcc", + "stack": "x - floor(x/2^(cc+1))" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_rshift", + "line": 749, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7AC", + "tlb": "#B7AC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QLSHIFT", + "fift_examples": [], + "gas": "26", + "opcode": "B7AC", + "stack": "x y - x*2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_lshift", + "line": 740, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QLSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7AD", + "tlb": "#B7AD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QRSHIFT", + "fift_examples": [], + "gas": "26", + "opcode": "B7AD", + "stack": "x y - floor(x/2^y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_rshift", + "line": 749, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QRSHIFT_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7AE", + "tlb": "#B7AE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QPOW2", + "fift_examples": [], + "gas": "26", + "opcode": "B7AE", + "stack": "y - 2^y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_pow2", + "line": 758, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QPOW2", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B0", + "tlb": "#B7B0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QAND", + "fift_examples": [], + "gas": "26", + "opcode": "B7B0", + "stack": "x y - x&y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_and", + "line": 769, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QAND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B1", + "tlb": "#B7B1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QOR", + "fift_examples": [], + "gas": "26", + "opcode": "B7B1", + "stack": "x y - x|y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_or", + "line": 778, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QOR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B2", + "tlb": "#B7B2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QXOR", + "fift_examples": [], + "gas": "26", + "opcode": "B7B2", + "stack": "x y - x xor y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_xor", + "line": 787, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QXOR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B3", + "tlb": "#B7B3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "", + "fift": "QNOT", + "fift_examples": [], + "gas": "26", + "opcode": "B7B3", + "stack": "x - ~x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_not", + "line": 796, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7B4", + "tlb": "#B7B4 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

Replaces x with a NaN if x is not a cc+1-bit signed integer, leaves it intact otherwise.

\n", + "fift": "[cc+1] QFITS", + "fift_examples": [], + "gas": "34", + "opcode": "B7B4cc", + "stack": "x - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_fits", + "line": 830, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QFITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "B7B5", + "tlb": "#B7B5 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

Replaces x with a NaN if x is not a cc+1-bit unsigned integer, leaves it intact otherwise.

\n", + "fift": "[cc+1] QUFITS", + "fift_examples": [], + "gas": "34", + "opcode": "B7B5cc", + "stack": "x - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_fits", + "line": 830, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QUFITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B600", + "tlb": "#B7B600" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

Replaces x with a NaN if x is not a c-bit signed integer, leaves it intact otherwise.

\n", + "fift": "QFITSX", + "fift_examples": [], + "gas": "34", + "opcode": "B7B600", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_fits", + "line": 830, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QFITSX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7B601", + "tlb": "#B7B601" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "arithm_quiet", + "description": "

Replaces x with a NaN if x is not a c-bit unsigned integer, leaves it intact otherwise.

\n", + "fift": "QUFITSX", + "fift_examples": [], + "gas": "34", + "opcode": "B7B601", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_ufits", + "line": 843, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "QUFITSX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B8", + "tlb": "#B8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SGN", + "fift_examples": [], + "gas": "18", + "opcode": "B8", + "stack": "x - sgn(x)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_sgn", + "line": 961, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "SGN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B9", + "tlb": "#B9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Returns -1 if x<y, 0 otherwise.

\n", + "fift": "LESS", + "fift_examples": [], + "gas": "18", + "opcode": "B9", + "stack": "x y - xReturns -1 if x=y, 0 otherwise.

\n", + "fift": "EQUAL", + "fift_examples": [], + "gas": "18", + "opcode": "BA", + "stack": "x y - x=y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "EQUAL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "BB", + "tlb": "#BB" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "", + "fift": "LEQ", + "fift_examples": [], + "gas": "18", + "opcode": "BB", + "stack": "x y - x<=y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "LEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "BC", + "tlb": "#BC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "", + "fift": "GREATER", + "fift_examples": [], + "gas": "18", + "opcode": "BC", + "stack": "x y - x>y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "GREATER", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "BD", + "tlb": "#BD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Equivalent to EQUAL NOT.

\n", + "fift": "NEQ", + "fift_examples": [], + "gas": "18", + "opcode": "BD", + "stack": "x y - x!=y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "NEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "BE", + "tlb": "#BE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Equivalent to LESS NOT.

\n", + "fift": "GEQ", + "fift_examples": [], + "gas": "18", + "opcode": "BE", + "stack": "x y - x>=y" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "GEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "BF", + "tlb": "#BF" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Computes the sign of x-y:\n-1 if x<y, 0 if x=y, 1 if x>y.\nNo integer overflow can occur here unless x or y is a NaN.

\n", + "fift": "CMP", + "fift_examples": [], + "gas": "18", + "opcode": "BF", + "stack": "x y - sgn(x-y)" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp", + "line": 975, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "CMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "y", + "size": 8, + "type": "int" + } + ], + "prefix": "C0", + "tlb": "#C0 yy:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Returns -1 if x=yy, 0 otherwise.\n-2^7 <= yy < 2^7.

\n", + "fift": "[yy] EQINT", + "fift_examples": [], + "gas": "26", + "opcode": "C0yy", + "stack": "x - x=yy" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp_int", + "line": 992, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "EQINT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "y", + "size": 8, + "type": "int" + } + ], + "prefix": "C1", + "tlb": "#C1 yy:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Returns -1 if x<yy, 0 otherwise.\n-2^7 <= yy < 2^7.

\n", + "fift": "[yy] LESSINT\n[yy-1] LEQINT", + "fift_examples": [], + "gas": "26", + "opcode": "C1yy", + "stack": "x - xReturns -1 if x>yy, 0 otherwise.\n-2^7 <= yy < 2^7.

\n", + "fift": "[yy] GTINT\n[yy+1] GEQINT", + "fift_examples": [], + "gas": "26", + "opcode": "C2yy", + "stack": "x - x>yy" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp_int", + "line": 992, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "GTINT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 127, + "min_value": -128, + "name": "y", + "size": 8, + "type": "int" + } + ], + "prefix": "C3", + "tlb": "#C3 yy:int8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Returns -1 if x!=yy, 0 otherwise.\n-2^7 <= yy < 2^7.

\n", + "fift": "[yy] NEQINT", + "fift_examples": [], + "gas": "26", + "opcode": "C3yy", + "stack": "x - x!=yy" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_cmp_int", + "line": 992, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "NEQINT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C4", + "tlb": "#C4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Checks whether x is a NaN.

\n", + "fift": "ISNAN", + "fift_examples": [], + "gas": "18", + "opcode": "C4", + "stack": "x - x=NaN" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_is_nan", + "line": 1007, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "ISNAN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C5", + "tlb": "#C5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_int", + "description": "

Throws an arithmetic overflow exception if x is a NaN.

\n", + "fift": "CHKNAN", + "fift_examples": [], + "gas": "18/68", + "opcode": "C5", + "stack": "x - x" + }, + "implementation": [ + { + "file": "arithops.cpp", + "function_name": "exec_chk_nan", + "line": 1016, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/arithops.cpp" + } + ], + "mnemonic": "CHKNAN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C700", + "tlb": "#C700" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether a Slice s is empty (i.e., contains no bits of data and no cell references).

\n", + "fift": "SEMPTY", + "fift_examples": [], + "gas": "26", + "opcode": "C700", + "stack": "s - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_un_cs_cmp", + "line": 251, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SEMPTY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C701", + "tlb": "#C701" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether Slice s has no bits of data.

\n", + "fift": "SDEMPTY", + "fift_examples": [], + "gas": "26", + "opcode": "C701", + "stack": "s - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_un_cs_cmp", + "line": 251, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDEMPTY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C702", + "tlb": "#C702" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether Slice s has no references.

\n", + "fift": "SREMPTY", + "fift_examples": [], + "gas": "26", + "opcode": "C702", + "stack": "s - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_un_cs_cmp", + "line": 251, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SREMPTY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C703", + "tlb": "#C703" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether the first bit of Slice s is a one.

\n", + "fift": "SDFIRST", + "fift_examples": [], + "gas": "26", + "opcode": "C703", + "stack": "s - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_un_cs_cmp", + "line": 251, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C704", + "tlb": "#C704" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SDLEXCMP", + "fift_examples": [], + "gas": "26", + "opcode": "C704", + "stack": "s s' - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_ibin_cs_cmp", + "line": 277, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDLEXCMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C705", + "tlb": "#C705" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether the data parts of s and s' coincide, equivalent to SDLEXCMP ISZERO.

\n", + "fift": "SDEQ", + "fift_examples": [], + "gas": "26", + "opcode": "C705", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C708", + "tlb": "#C708" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s is a prefix of s'.

\n", + "fift": "SDPFX", + "fift_examples": [], + "gas": "26", + "opcode": "C708", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPFX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C709", + "tlb": "#C709" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s' is a prefix of s, equivalent to SWAP SDPFX.

\n", + "fift": "SDPFXREV", + "fift_examples": [], + "gas": "26", + "opcode": "C709", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPFXREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70A", + "tlb": "#C70A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s is a proper prefix of s' (i.e., a prefix distinct from s').

\n", + "fift": "SDPPFX", + "fift_examples": [], + "gas": "26", + "opcode": "C70A", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPPFX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70B", + "tlb": "#C70B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s' is a proper prefix of s.

\n", + "fift": "SDPPFXREV", + "fift_examples": [], + "gas": "26", + "opcode": "C70B", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPPFXREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70C", + "tlb": "#C70C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s is a suffix of s'.

\n", + "fift": "SDSFX", + "fift_examples": [], + "gas": "26", + "opcode": "C70C", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDSFX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70D", + "tlb": "#C70D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s' is a suffix of s.

\n", + "fift": "SDSFXREV", + "fift_examples": [], + "gas": "26", + "opcode": "C70D", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDSFXREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70E", + "tlb": "#C70E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s is a proper suffix of s'.

\n", + "fift": "SDPSFX", + "fift_examples": [], + "gas": "26", + "opcode": "C70E", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPSFX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C70F", + "tlb": "#C70F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Checks whether s' is a proper suffix of s.

\n", + "fift": "SDPSFXREV", + "fift_examples": [], + "gas": "26", + "opcode": "C70F", + "stack": "s s' - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_bin_cs_cmp", + "line": 267, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDPSFXREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C710", + "tlb": "#C710" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Returns the number of leading zeroes in s.

\n", + "fift": "SDCNTLEAD0", + "fift_examples": [], + "gas": "26", + "opcode": "C710", + "stack": "s - n" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_iun_cs_cmp", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCNTLEAD0", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C711", + "tlb": "#C711" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Returns the number of leading ones in s.

\n", + "fift": "SDCNTLEAD1", + "fift_examples": [], + "gas": "26", + "opcode": "C711", + "stack": "s - n" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_iun_cs_cmp", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCNTLEAD1", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C712", + "tlb": "#C712" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Returns the number of trailing zeroes in s.

\n", + "fift": "SDCNTTRAIL0", + "fift_examples": [], + "gas": "26", + "opcode": "C712", + "stack": "s - n" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_iun_cs_cmp", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCNTTRAIL0", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C713", + "tlb": "#C713" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "compare_other", + "description": "

Returns the number of trailing ones in s.

\n", + "fift": "SDCNTTRAIL1", + "fift_examples": [], + "gas": "26", + "opcode": "C713", + "stack": "s - n" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_iun_cs_cmp", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCNTTRAIL1", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C8", + "tlb": "#C8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Creates a new empty Builder.

\n", + "fift": "NEWC", + "fift_examples": [], + "gas": "18", + "opcode": "C8", + "stack": "- b" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_new_builder", + "line": 334, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "NEWC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "C9", + "tlb": "#C9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Converts a Builder into an ordinary Cell.

\n", + "fift": "ENDC", + "fift_examples": [], + "gas": "518", + "opcode": "C9", + "stack": "b - c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_to_cell", + "line": 341, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "ENDC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CA", + "tlb": "#CA cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[cc+1] STI", + "fift_examples": [], + "gas": "26", + "opcode": "CAcc", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STI", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CB", + "tlb": "#CB cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[cc+1] STU", + "fift_examples": [], + "gas": "26", + "opcode": "CBcc", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CC", + "tlb": "#CC" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a reference to Cell c into Builder b.

\n", + "fift": "STREF", + "fift_examples": [], + "gas": "18", + "opcode": "CC", + "stack": "c b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_ref", + "line": 415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CD", + "tlb": "#CD" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to ENDC SWAP STREF.

\n", + "fift": "STBREFR\nENDCST", + "fift_examples": [], + "gas": "518", + "opcode": "CD", + "stack": "b b'' - b" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_as_ref_rev", + "line": 484, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBREFR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "child", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CE", + "tlb": "#CE" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores Slice s into Builder b.

\n", + "fift": "STSLICE", + "fift_examples": [], + "gas": "18", + "opcode": "CE", + "stack": "s b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_slice", + "line": 507, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF00", + "tlb": "#CF00" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a signed l-bit integer x into b for 0 <= l <= 257.

\n", + "fift": "STIX", + "fift_examples": [], + "gas": "26", + "opcode": "CF00", + "stack": "x b l - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF01", + "tlb": "#CF01" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores an unsigned l-bit integer x into b for 0 <= l <= 256.

\n", + "fift": "STUX", + "fift_examples": [], + "gas": "26", + "opcode": "CF01", + "stack": "x b l - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF02", + "tlb": "#CF02" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Similar to STIX, but with arguments in a different order.

\n", + "fift": "STIXR", + "fift_examples": [], + "gas": "26", + "opcode": "CF02", + "stack": "b x l - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIXR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF03", + "tlb": "#CF03" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Similar to STUX, but with arguments in a different order.

\n", + "fift": "STUXR", + "fift_examples": [], + "gas": "26", + "opcode": "CF03", + "stack": "b x l - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUXR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF04", + "tlb": "#CF04" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "STIXQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF04", + "stack": "x b l - x b f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF05", + "tlb": "#CF05" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STUX.

\n", + "fift": "STUXQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF05", + "stack": "x b l - x b f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF06", + "tlb": "#CF06" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STIXR.

\n", + "fift": "STIXRQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF06", + "stack": "b x l - b x f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIXRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF07", + "tlb": "#CF07" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STUXR.

\n", + "fift": "STUXRQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF07", + "stack": "b x l - b x f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_var", + "line": 599, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUXRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF08", + "tlb": "#CF08 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A longer version of [cc+1] STI.

\n", + "fift": "[cc+1] STI_l", + "fift_examples": [], + "gas": "34", + "opcode": "CF08cc", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STI_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF09", + "tlb": "#CF09 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A longer version of [cc+1] STU.

\n", + "fift": "[cc+1] STU_l", + "fift_examples": [], + "gas": "34", + "opcode": "CF09cc", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STU_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0A", + "tlb": "#CF0A cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to SWAP [cc+1] STI.

\n", + "fift": "[cc+1] STIR", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Acc", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0B", + "tlb": "#CF0B cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to SWAP [cc+1] STU.

\n", + "fift": "[cc+1] STUR", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Bcc", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0C", + "tlb": "#CF0C cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STI.

\n", + "fift": "[cc+1] STIQ", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Ccc", + "stack": "x b - x b f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0D", + "tlb": "#CF0D cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STU.

\n", + "fift": "[cc+1] STUQ", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Dcc", + "stack": "x b - x b f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STUQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0E", + "tlb": "#CF0E cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STIR.

\n", + "fift": "[cc+1] STIRQ", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Ecc", + "stack": "b x - b x f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STIRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF0F", + "tlb": "#CF0F cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A quiet version of STUR.

\n", + "fift": "[cc+1] STURQ", + "fift_examples": [], + "gas": "34", + "opcode": "CF0Fcc", + "stack": "b x - b x f or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STURQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": 1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF10", + "tlb": "#CF10" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A longer version of STREF.

\n", + "fift": "STREF_l", + "fift_examples": [], + "gas": "26", + "opcode": "CF10", + "stack": "c b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_ref_rev", + "line": 438, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREF_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF11", + "tlb": "#CF11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to SWAP STBREFR.

\n", + "fift": "STBREF", + "fift_examples": [], + "gas": "526", + "opcode": "CF11", + "stack": "b' b - b''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_as_ref", + "line": 461, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "child", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF12", + "tlb": "#CF12" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A longer version of STSLICE.

\n", + "fift": "STSLICE_l", + "fift_examples": [], + "gas": "26", + "opcode": "CF12", + "stack": "s b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_slice", + "line": 507, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICE_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF13", + "tlb": "#CF13" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Appends all data from Builder b' to Builder b.

\n", + "fift": "STB", + "fift_examples": [], + "gas": "26", + "opcode": "CF13", + "stack": "b' b - b''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder", + "line": 553, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF14", + "tlb": "#CF14" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to SWAP STREF.

\n", + "fift": "STREFR", + "fift_examples": [], + "gas": "26", + "opcode": "CF14", + "stack": "b c - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_ref_rev", + "line": 438, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREFR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF15", + "tlb": "#CF15" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

A longer encoding of STBREFR.

\n", + "fift": "STBREFR_l", + "fift_examples": [], + "gas": "526", + "opcode": "CF15", + "stack": "b b' - b''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_as_ref_rev", + "line": 484, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBREFR_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF16", + "tlb": "#CF16" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to SWAP STSLICE.

\n", + "fift": "STSLICER", + "fift_examples": [], + "gas": "26", + "opcode": "CF16", + "stack": "b s - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_slice_rev", + "line": 530, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICER", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF17", + "tlb": "#CF17" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Concatenates two builders.\nEquivalent to SWAP STB.

\n", + "fift": "STBR\nBCONCAT", + "fift_examples": [], + "gas": "26", + "opcode": "CF17", + "stack": "b b' - b''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_rev", + "line": 576, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF18", + "tlb": "#CF18" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STREF.

\n", + "fift": "STREFQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF18", + "stack": "c b - c b -1 or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_ref", + "line": 415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREFQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF19", + "tlb": "#CF19" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STBREF.

\n", + "fift": "STBREFQ", + "fift_examples": [], + "gas": "526", + "opcode": "CF19", + "stack": "b' b - b' b -1 or b'' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_as_ref", + "line": 461, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBREFQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1A", + "tlb": "#CF1A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STSLICE.

\n", + "fift": "STSLICEQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF1A", + "stack": "s b - s b -1 or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_slice", + "line": 507, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1B", + "tlb": "#CF1B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STB.

\n", + "fift": "STBQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF1B", + "stack": "b' b - b' b -1 or b'' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder", + "line": 553, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1C", + "tlb": "#CF1C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STREFR.

\n", + "fift": "STREFRQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF1C", + "stack": "b c - b c -1 or b' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_ref_rev", + "line": 438, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREFRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1D", + "tlb": "#CF1D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STBREFR.

\n", + "fift": "STBREFRQ", + "fift_examples": [], + "gas": "526", + "opcode": "CF1D", + "stack": "b b' - b b' -1 or b'' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_as_ref_rev", + "line": 484, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBREFRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1E", + "tlb": "#CF1E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STSLICER.

\n", + "fift": "STSLICERQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF1E", + "stack": "b s - b s -1 or b'' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_slice_rev", + "line": 530, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICERQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF1F", + "tlb": "#CF1F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Quiet version of STBR.

\n", + "fift": "STBRQ\nBCONCATQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF1F", + "stack": "b b' - b b' -1 or b'' 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_builder_rev", + "line": 576, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STBRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b3", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "name": "c", + "type": "ref" + } + ], + "prefix": "CF20", + "tlb": "#CF20 c:^Cell" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to PUSHREF STREFR.

\n", + "fift": "[ref] STREFCONST", + "fift_examples": [], + "gas": "26", + "opcode": "CF20", + "stack": "b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_const_ref", + "line": 647, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREFCONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "name": "c1", + "type": "ref" + }, + { + "display_hints": [], + "name": "c2", + "type": "ref" + } + ], + "prefix": "CF21", + "tlb": "#CF21 c1:^Cell c2:^Cell" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Equivalent to STREFCONST STREFCONST.

\n", + "fift": "[ref] [ref] STREF2CONST", + "fift_examples": [], + "gas": "26", + "opcode": "CF21", + "stack": "b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_const_ref", + "line": 647, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STREF2CONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF23", + "tlb": "#CF23" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "ENDXC", + "fift_examples": [], + "gas": "526", + "opcode": "CF23", + "stack": "b x - c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_to_special_cell", + "line": 349, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "ENDXC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF28", + "tlb": "#CF28" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a little-endian signed 32-bit integer.

\n", + "fift": "STILE4", + "fift_examples": [], + "gas": "26", + "opcode": "CF28", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STILE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF29", + "tlb": "#CF29" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a little-endian unsigned 32-bit integer.

\n", + "fift": "STULE4", + "fift_examples": [], + "gas": "26", + "opcode": "CF29", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STULE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF2A", + "tlb": "#CF2A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a little-endian signed 64-bit integer.

\n", + "fift": "STILE8", + "fift_examples": [], + "gas": "26", + "opcode": "CF2A", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STILE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF2B", + "tlb": "#CF2B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a little-endian unsigned 64-bit integer.

\n", + "fift": "STULE8", + "fift_examples": [], + "gas": "26", + "opcode": "CF2B", + "stack": "x b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_int_fixed", + "line": 622, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STULE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF30", + "tlb": "#CF30" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "BDEPTH", + "fift_examples": [], + "gas": "26", + "opcode": "CF30", + "stack": "b - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_int_builder_func", + "line": 704, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BDEPTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF31", + "tlb": "#CF31" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the number of data bits already stored in Builder b.

\n", + "fift": "BBITS", + "fift_examples": [], + "gas": "26", + "opcode": "CF31", + "stack": "b - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_int_builder_func", + "line": 704, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BBITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF32", + "tlb": "#CF32" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the number of cell references already stored in b.

\n", + "fift": "BREFS", + "fift_examples": [], + "gas": "26", + "opcode": "CF32", + "stack": "b - y" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_int_builder_func", + "line": 704, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF33", + "tlb": "#CF33" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the numbers of both data bits and cell references in b.

\n", + "fift": "BBITREFS", + "fift_examples": [], + "gas": "26", + "opcode": "CF33", + "stack": "b - x y" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_2int_builder_func", + "line": 712, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BBITREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF35", + "tlb": "#CF35" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the number of data bits that can still be stored in b.

\n", + "fift": "BREMBITS", + "fift_examples": [], + "gas": "26", + "opcode": "CF35", + "stack": "b - x'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_int_builder_func", + "line": 704, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BREMBITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF36", + "tlb": "#CF36" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the number of references that can still be stored in b.

\n", + "fift": "BREMREFS", + "fift_examples": [], + "gas": "26", + "opcode": "CF36", + "stack": "b - y'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_int_builder_func", + "line": 704, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BREMREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "y2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF37", + "tlb": "#CF37" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Returns the numbers of both data bits and references that can still be stored in b.

\n", + "fift": "BREMBITREFS", + "fift_examples": [], + "gas": "26", + "opcode": "CF37", + "stack": "b - x' y'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_2int_builder_func", + "line": 712, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BREMBITREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF38", + "tlb": "#CF38 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether cc+1 bits can be stored into b, where 0 <= cc <= 255.

\n", + "fift": "[cc+1] BCHKBITS#", + "fift_examples": [], + "gas": "34/84", + "opcode": "CF38cc", + "stack": "b -" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF39", + "tlb": "#CF39" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "BCHKBITS", + "fift_examples": [], + "gas": "26/76", + "opcode": "CF39", + "stack": "b x - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITS_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF3A", + "tlb": "#CF3A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether y references can be stored into b, 0 <= y <= 7.

\n", + "fift": "BCHKREFS", + "fift_examples": [], + "gas": "26/76", + "opcode": "CF3A", + "stack": "b y - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF3B", + "tlb": "#CF3B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether x bits and y references can be stored into b, 0 <= x <= 1023, 0 <= y <= 7.

\n", + "fift": "BCHKBITREFS", + "fift_examples": [], + "gas": "26/76", + "opcode": "CF3B", + "stack": "b x y - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "CF3C", + "tlb": "#CF3C cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether cc+1 bits can be stored into b, where 0 <= cc <= 255.

\n", + "fift": "[cc+1] BCHKBITSQ#", + "fift_examples": [], + "gas": "34", + "opcode": "CF3Ccc", + "stack": "b - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF3D", + "tlb": "#CF3D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether x bits can be stored into b, 0 <= x <= 1023.

\n", + "fift": "BCHKBITSQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF3D", + "stack": "b x - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITSQ_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF3E", + "tlb": "#CF3E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether y references can be stored into b, 0 <= y <= 7.

\n", + "fift": "BCHKREFSQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF3E", + "stack": "b y - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKREFSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF3F", + "tlb": "#CF3F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Checks whether x bits and y references can be stored into b, 0 <= x <= 1023, 0 <= y <= 7.

\n", + "fift": "BCHKBITREFSQ", + "fift_examples": [], + "gas": "26", + "opcode": "CF3F", + "stack": "b x y - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_chk_bits_refs", + "line": 737, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BCHKBITREFSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF40", + "tlb": "#CF40" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores n binary zeroes into Builder b.

\n", + "fift": "STZEROES", + "fift_examples": [], + "gas": "26", + "opcode": "CF40", + "stack": "b n - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_same", + "line": 752, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STZEROES", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF41", + "tlb": "#CF41" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores n binary ones into Builder b.

\n", + "fift": "STONES", + "fift_examples": [], + "gas": "26", + "opcode": "CF41", + "stack": "b n - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_same", + "line": 752, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STONES", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF42", + "tlb": "#CF42" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores n binary xes (0 <= x <= 1) into Builder b.

\n", + "fift": "STSAME", + "fift_examples": [], + "gas": "26", + "opcode": "CF42", + "stack": "b n x - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_same", + "line": 752, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSAME", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "CF50", + "tlb": "#CF50" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Same as ENDC CTOS, but without gas cost for cell creation and loading.

\n", + "fift": "BTOS", + "fift_examples": [], + "gas": "26", + "opcode": "CF50", + "stack": "b - s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_builder_to_slice", + "line": 767, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "BTOS", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 3, + "bits_padding": 2, + "completion_tag": true, + "display_hints": [], + "max_bits": 57, + "max_refs": 3, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "refs_add": 0, + "refs_length_var_size": 2, + "type": "subslice" + } + ], + "prefix": "CFC_", + "tlb": "#CFC_ x:(## 2) y:(## 3) c:(x * ^Cell) sss:((8 * y + 2) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_build", + "description": "

Stores a constant subslice sss.\nDetails: 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.

\n", + "fift": "[slice] STSLICECONST", + "fift_examples": [], + "gas": "24", + "opcode": "CFC_xysss", + "stack": "b - b'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_store_const_slice", + "line": 776, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "STSLICECONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D0", + "tlb": "#D0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CTOS", + "fift_examples": [], + "gas": "118/43", + "opcode": "D0", + "stack": "c - s" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_to_slice", + "line": 883, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CTOS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D1", + "tlb": "#D1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Removes a Slice s from the stack, and throws an exception if it is not empty.

\n", + "fift": "ENDS", + "fift_examples": [], + "gas": "18/68", + "opcode": "D1", + "stack": "s - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_empty", + "line": 946, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "ENDS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D2", + "tlb": "#D2 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "[cc+1] LDI", + "fift_examples": [], + "gas": "26", + "opcode": "D2cc", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDI", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D3", + "tlb": "#D3 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads an unsigned cc+1-bit integer x from Slice s.

\n", + "fift": "[cc+1] LDU", + "fift_examples": [], + "gas": "26", + "opcode": "D3cc", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D4", + "tlb": "#D4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads a cell reference c from s.

\n", + "fift": "LDREF", + "fift_examples": [], + "gas": "18", + "opcode": "D4", + "stack": "s - c s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_ref", + "line": 1013, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D5", + "tlb": "#D5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Equivalent to LDREF SWAP CTOS.

\n", + "fift": "LDREFRTOS", + "fift_examples": [], + "gas": "118/43", + "opcode": "D5", + "stack": "s - s' s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_ref_rev_to_slice", + "line": 1036, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDREFRTOS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D6", + "tlb": "#D6 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Cuts the next cc+1 bits of s into a separate Slice s''.

\n", + "fift": "[cc+1] LDSLICE", + "fift_examples": [], + "gas": "26", + "opcode": "D6cc", + "stack": "s - s'' s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D700", + "tlb": "#D700" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "LDIX", + "fift_examples": [], + "gas": "26", + "opcode": "D700", + "stack": "s l - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_var", + "line": 1090, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDIX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D701", + "tlb": "#D701" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads an unsigned l-bit integer x from (the first l bits of) s, with 0 <= l <= 256.

\n", + "fift": "LDUX", + "fift_examples": [], + "gas": "26", + "opcode": "D701", + "stack": "s l - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_var", + "line": 1090, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDUX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D702", + "tlb": "#D702" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a signed l-bit integer from Slice s, for 0 <= l <= 257.

\n", + "fift": "PLDIX", + "fift_examples": [], + "gas": "26", + "opcode": "D702", + "stack": "s l - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDIX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D703", + "tlb": "#D703" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads an unsigned l-bit integer from s, for 0 <= l <= 256.

\n", + "fift": "PLDUX", + "fift_examples": [], + "gas": "26", + "opcode": "D703", + "stack": "s l - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDUX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D704", + "tlb": "#D704" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDIXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D704", + "stack": "s l - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_var", + "line": 1090, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDIXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D705", + "tlb": "#D705" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quiet version of LDUX.

\n", + "fift": "LDUXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D705", + "stack": "s l - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_var", + "line": 1090, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDUXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D706", + "tlb": "#D706" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quiet version of PLDIX.

\n", + "fift": "PLDIXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D706", + "stack": "s l - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDIXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D707", + "tlb": "#D707" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quiet version of PLDUX.

\n", + "fift": "PLDUXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D707", + "stack": "s l - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDUXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D708", + "tlb": "#D708 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A longer encoding for LDI.

\n", + "fift": "[cc+1] LDI_l", + "fift_examples": [], + "gas": "34", + "opcode": "D708cc", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDI_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D709", + "tlb": "#D709 cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A longer encoding for LDU.

\n", + "fift": "[cc+1] LDU_l", + "fift_examples": [], + "gas": "34", + "opcode": "D709cc", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDU_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70A", + "tlb": "#D70A cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a signed cc+1-bit integer from Slice s.

\n", + "fift": "[cc+1] PLDI", + "fift_examples": [], + "gas": "34", + "opcode": "D70Acc", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDI", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70B", + "tlb": "#D70B cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads an unsigned cc+1-bit integer from s.

\n", + "fift": "[cc+1] PLDU", + "fift_examples": [], + "gas": "34", + "opcode": "D70Bcc", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70C", + "tlb": "#D70C cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of LDI.

\n", + "fift": "[cc+1] LDIQ", + "fift_examples": [], + "gas": "34", + "opcode": "D70Ccc", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDIQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70D", + "tlb": "#D70D cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of LDU.

\n", + "fift": "[cc+1] LDUQ", + "fift_examples": [], + "gas": "34", + "opcode": "D70Dcc", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDUQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70E", + "tlb": "#D70E cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of PLDI.

\n", + "fift": "[cc+1] PLDIQ", + "fift_examples": [], + "gas": "34", + "opcode": "D70Ecc", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDIQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D70F", + "tlb": "#D70F cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of PLDU.

\n", + "fift": "[cc+1] PLDUQ", + "fift_examples": [], + "gas": "34", + "opcode": "D70Fcc", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDUQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "plduz" + } + ], + "max_value": 7, + "min_value": 0, + "name": "c", + "size": 3, + "type": "uint" + } + ], + "prefix": "D714_", + "tlb": "#D714_ c:uint3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[32(c+1)] PLDUZ", + "fift_examples": [], + "gas": "26", + "opcode": "D714_c", + "stack": "s - s x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDUZ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D718", + "tlb": "#D718" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "LDSLICEX", + "fift_examples": [], + "gas": "26", + "opcode": "D718", + "stack": "s l - s'' s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSLICEX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D719", + "tlb": "#D719" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the first 0 <= l <= 1023 bits of s as s''.

\n", + "fift": "PLDSLICEX", + "fift_examples": [], + "gas": "26", + "opcode": "D719", + "stack": "s l - s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDSLICEX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D71A", + "tlb": "#D71A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of LDSLICEX.

\n", + "fift": "LDSLICEXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D71A", + "stack": "s l - s'' s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSLICEXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D71B", + "tlb": "#D71B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of LDSLICEXQ.

\n", + "fift": "PLDSLICEXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D71B", + "stack": "s l - s' -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDSLICEXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D71C", + "tlb": "#D71C cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A longer encoding for LDSLICE.

\n", + "fift": "[cc+1] LDSLICE_l", + "fift_examples": [], + "gas": "34", + "opcode": "D71Ccc", + "stack": "s - s'' s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSLICE_ALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D71D", + "tlb": "#D71D cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the first 0 < cc+1 <= 256 bits of s as s''.

\n", + "fift": "[cc+1] PLDSLICE", + "fift_examples": [], + "gas": "34", + "opcode": "D71Dcc", + "stack": "s - s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D71E", + "tlb": "#D71E cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of LDSLICE.

\n", + "fift": "[cc+1] LDSLICEQ", + "fift_examples": [], + "gas": "34", + "opcode": "D71Ecc", + "stack": "s - s'' s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSLICEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": 1 + } + ], + "max_value": 255, + "min_value": 0, + "name": "c", + "size": 8, + "type": "uint" + } + ], + "prefix": "D71F", + "tlb": "#D71F cc:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of PLDSLICE.

\n", + "fift": "[cc+1] PLDSLICEQ", + "fift_examples": [], + "gas": "34", + "opcode": "D71Fcc", + "stack": "s - s'' -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_slice", + "line": 1137, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDSLICEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D720", + "tlb": "#D720" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the first 0 <= l <= 1023 bits of s. It is equivalent to PLDSLICEX.

\n", + "fift": "SDCUTFIRST", + "fift_examples": [], + "gas": "26", + "opcode": "D720", + "stack": "s l - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args", + "line": 1167, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCUTFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D721", + "tlb": "#D721" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns all but the first 0 <= l <= 1023 bits of s. It is equivalent to LDSLICEX NIP.

\n", + "fift": "SDSKIPFIRST", + "fift_examples": [], + "gas": "26", + "opcode": "D721", + "stack": "s l - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args", + "line": 1167, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDSKIPFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D722", + "tlb": "#D722" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the last 0 <= l <= 1023 bits of s.

\n", + "fift": "SDCUTLAST", + "fift_examples": [], + "gas": "26", + "opcode": "D722", + "stack": "s l - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args", + "line": 1167, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDCUTLAST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D723", + "tlb": "#D723" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns all but the last 0 <= l <= 1023 bits of s.

\n", + "fift": "SDSKIPLAST", + "fift_examples": [], + "gas": "26", + "opcode": "D723", + "stack": "s l - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args", + "line": 1167, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDSKIPLAST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D724", + "tlb": "#D724" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SDSUBSTR", + "fift_examples": [], + "gas": "26", + "opcode": "D724", + "stack": "s l l' - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args2", + "line": 1181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDSUBSTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D726", + "tlb": "#D726" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SDBEGINSX", + "fift_examples": [], + "gas": "26", + "opcode": "D726", + "stack": "s s' - s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_begins_with", + "line": 1215, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDBEGINSX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D727", + "tlb": "#D727" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of SDBEGINSX.

\n", + "fift": "SDBEGINSXQ", + "fift_examples": [], + "gas": "26", + "opcode": "D727", + "stack": "s s' - s'' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_begins_with", + "line": 1215, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDBEGINSXQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 7, + "bits_padding": 3, + "completion_tag": true, + "display_hints": [], + "max_bits": 1018, + "max_refs": 0, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "type": "subslice" + } + ], + "prefix": "D72A_", + "tlb": "#D72A_ x:(## 7) sss:((8 * x + 3) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[slice] SDBEGINS", + "fift_examples": [], + "gas": "31", + "opcode": "D72A_xsss", + "stack": "s - s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_begins_with_const", + "line": 1222, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDBEGINS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 7, + "bits_padding": 3, + "completion_tag": true, + "display_hints": [], + "max_bits": 1018, + "max_refs": 0, + "min_bits": 0, + "min_refs": 0, + "name": "s", + "type": "subslice" + } + ], + "prefix": "D72E_", + "tlb": "#D72E_ x:(## 7) sss:((8 * x + 3) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of SDBEGINS.

\n", + "fift": "[slice] SDBEGINSQ", + "fift_examples": [], + "gas": "31", + "opcode": "D72E_xsss", + "stack": "s - s'' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_begins_with_const", + "line": 1222, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDBEGINSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D730", + "tlb": "#D730" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the first 0 <= l <= 1023 bits and first 0 <= r <= 4 references of s.

\n", + "fift": "SCUTFIRST", + "fift_examples": [], + "gas": "26", + "opcode": "D730", + "stack": "s l r - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args2", + "line": 1181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCUTFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D731", + "tlb": "#D731" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns all but the first l bits of s and r references of s.

\n", + "fift": "SSKIPFIRST", + "fift_examples": [], + "gas": "26", + "opcode": "D731", + "stack": "s l r - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args2", + "line": 1181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SSKIPFIRST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D732", + "tlb": "#D732" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the last 0 <= l <= 1023 data bits and last 0 <= r <= 4 references of s.

\n", + "fift": "SCUTLAST", + "fift_examples": [], + "gas": "26", + "opcode": "D732", + "stack": "s l r - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args2", + "line": 1181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCUTLAST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D733", + "tlb": "#D733" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns all but the last l bits of s and r references of s.

\n", + "fift": "SSKIPLAST", + "fift_examples": [], + "gas": "26", + "opcode": "D733", + "stack": "s l r - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_op_args2", + "line": 1181, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SSKIPLAST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D734", + "tlb": "#D734" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SUBSLICE", + "fift_examples": [], + "gas": "26", + "opcode": "D734", + "stack": "s l r l' r' - s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_subslice", + "line": 1246, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SUBSLICE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l2", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D736", + "tlb": "#D736" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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''.

\n", + "fift": "SPLIT", + "fift_examples": [], + "gas": "26", + "opcode": "D736", + "stack": "s l r - s' s''" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_split", + "line": 1260, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SPLIT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D737", + "tlb": "#D737" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

A quiet version of SPLIT.

\n", + "fift": "SPLITQ", + "fift_examples": [], + "gas": "26", + "opcode": "D737", + "stack": "s l r - s' s'' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_split", + "line": 1260, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SPLITQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D739", + "tlb": "#D739" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "XCTOS", + "fift_examples": [], + "gas": "126/51", + "opcode": "D739", + "stack": "c - s ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_to_slice_maybe_special", + "line": 891, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "XCTOS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "flag", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D73A", + "tlb": "#D73A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "XLOAD", + "fift_examples": [], + "gas": "126/51", + "opcode": "D73A", + "stack": "c - c'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_special_cell", + "line": 901, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "XLOAD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D73B", + "tlb": "#D73B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "XLOADQ", + "fift_examples": [], + "gas": "126/51", + "opcode": "D73B", + "stack": "c - c' -1 or c 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_special_cell", + "line": 901, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "XLOADQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D741", + "tlb": "#D741" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SCHKBITS", + "fift_examples": [], + "gas": "26/76", + "opcode": "D741", + "stack": "s l - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args", + "line": 1285, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKBITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D742", + "tlb": "#D742" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Checks whether there are at least r references in Slice s.

\n", + "fift": "SCHKREFS", + "fift_examples": [], + "gas": "26/76", + "opcode": "D742", + "stack": "s r - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args", + "line": 1285, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D743", + "tlb": "#D743" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Checks whether there are at least l data bits and r references in Slice s.

\n", + "fift": "SCHKBITREFS", + "fift_examples": [], + "gas": "26/76", + "opcode": "D743", + "stack": "s l r - " + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args2", + "line": 1301, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKBITREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D745", + "tlb": "#D745" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Checks whether there are at least l data bits in Slice s.

\n", + "fift": "SCHKBITSQ", + "fift_examples": [], + "gas": "26", + "opcode": "D745", + "stack": "s l - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args", + "line": 1285, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKBITSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D746", + "tlb": "#D746" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Checks whether there are at least r references in Slice s.

\n", + "fift": "SCHKREFSQ", + "fift_examples": [], + "gas": "26", + "opcode": "D746", + "stack": "s r - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args", + "line": 1285, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKREFSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D747", + "tlb": "#D747" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Checks whether there are at least l data bits and r references in Slice s.

\n", + "fift": "SCHKBITREFSQ", + "fift_examples": [], + "gas": "26", + "opcode": "D747", + "stack": "s l r - ?" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_chk_op_args2", + "line": 1301, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SCHKBITREFSQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D748", + "tlb": "#D748" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the n-th cell reference of Slice s for 0 <= n <= 3.

\n", + "fift": "PLDREFVAR", + "fift_examples": [], + "gas": "26", + "opcode": "D748", + "stack": "s n - c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref", + "line": 1000, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDREFVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D749", + "tlb": "#D749" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the number of data bits in Slice s.

\n", + "fift": "SBITS", + "fift_examples": [], + "gas": "26", + "opcode": "D749", + "stack": "s - l" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_bits_refs", + "line": 1318, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SBITS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D74A", + "tlb": "#D74A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the number of references in Slice s.

\n", + "fift": "SREFS", + "fift_examples": [], + "gas": "26", + "opcode": "D74A", + "stack": "s - r" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_bits_refs", + "line": 1318, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D74B", + "tlb": "#D74B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns both the number of data bits and the number of references in s.

\n", + "fift": "SBITREFS", + "fift_examples": [], + "gas": "26", + "opcode": "D74B", + "stack": "s - l r" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_bits_refs", + "line": 1318, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SBITREFS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "n", + "size": 2, + "type": "uint" + } + ], + "prefix": "D74E_", + "tlb": "#D74E_ n:uint2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the n-th cell reference of Slice s, where 0 <= n <= 3.

\n", + "fift": "[n] PLDREFIDX", + "fift_examples": [], + "gas": "26", + "opcode": "D74E_n", + "stack": "s - c" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDREFIDX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D750", + "tlb": "#D750" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads a little-endian signed 32-bit integer.

\n", + "fift": "LDILE4", + "fift_examples": [], + "gas": "26", + "opcode": "D750", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDILE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D751", + "tlb": "#D751" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads a little-endian unsigned 32-bit integer.

\n", + "fift": "LDULE4", + "fift_examples": [], + "gas": "26", + "opcode": "D751", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDULE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D752", + "tlb": "#D752" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads a little-endian signed 64-bit integer.

\n", + "fift": "LDILE8", + "fift_examples": [], + "gas": "26", + "opcode": "D752", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDILE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D753", + "tlb": "#D753" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Loads a little-endian unsigned 64-bit integer.

\n", + "fift": "LDULE8", + "fift_examples": [], + "gas": "26", + "opcode": "D753", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDULE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D754", + "tlb": "#D754" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a little-endian signed 32-bit integer.

\n", + "fift": "PLDILE4", + "fift_examples": [], + "gas": "26", + "opcode": "D754", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDILE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D755", + "tlb": "#D755" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a little-endian unsigned 32-bit integer.

\n", + "fift": "PLDULE4", + "fift_examples": [], + "gas": "26", + "opcode": "D755", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDULE4", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D756", + "tlb": "#D756" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a little-endian signed 64-bit integer.

\n", + "fift": "PLDILE8", + "fift_examples": [], + "gas": "26", + "opcode": "D756", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDILE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D757", + "tlb": "#D757" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Preloads a little-endian unsigned 64-bit integer.

\n", + "fift": "PLDULE8", + "fift_examples": [], + "gas": "26", + "opcode": "D757", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDULE8", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D758", + "tlb": "#D758" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly loads a little-endian signed 32-bit integer.

\n", + "fift": "LDILE4Q", + "fift_examples": [], + "gas": "26", + "opcode": "D758", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDILE4Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D759", + "tlb": "#D759" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly loads a little-endian unsigned 32-bit integer.

\n", + "fift": "LDULE4Q", + "fift_examples": [], + "gas": "26", + "opcode": "D759", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDULE4Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75A", + "tlb": "#D75A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly loads a little-endian signed 64-bit integer.

\n", + "fift": "LDILE8Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75A", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDILE8Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75B", + "tlb": "#D75B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly loads a little-endian unsigned 64-bit integer.

\n", + "fift": "LDULE8Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75B", + "stack": "s - x s' -1 or s 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_int_fixed", + "line": 981, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDULE8Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75C", + "tlb": "#D75C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly preloads a little-endian signed 32-bit integer.

\n", + "fift": "PLDILE4Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75C", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDILE4Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75D", + "tlb": "#D75D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly preloads a little-endian unsigned 32-bit integer.

\n", + "fift": "PLDULE4Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75D", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDULE4Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75E", + "tlb": "#D75E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly preloads a little-endian signed 64-bit integer.

\n", + "fift": "PLDILE8Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75E", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDILE8Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D75F", + "tlb": "#D75F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Quietly preloads a little-endian unsigned 64-bit integer.

\n", + "fift": "PLDULE8Q", + "fift_examples": [], + "gas": "26", + "opcode": "D75F", + "stack": "s - x -1 or 0" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_preload_ref_fixed", + "line": 988, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "PLDULE8Q", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D760", + "tlb": "#D760" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the count n of leading zero bits in s, and removes these bits from s.

\n", + "fift": "LDZEROES", + "fift_examples": [], + "gas": "26", + "opcode": "D760", + "stack": "s - n s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_same", + "line": 1371, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDZEROES", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D761", + "tlb": "#D761" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns the count n of leading one bits in s, and removes these bits from s.

\n", + "fift": "LDONES", + "fift_examples": [], + "gas": "26", + "opcode": "D761", + "stack": "s - n s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_same", + "line": 1371, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDONES", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D762", + "tlb": "#D762" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDSAME", + "fift_examples": [], + "gas": "26", + "opcode": "D762", + "stack": "s x - n s'" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_load_same", + "line": 1371, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "LDSAME", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D764", + "tlb": "#D764" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SDEPTH", + "fift_examples": [], + "gas": "26", + "opcode": "D764", + "stack": "s - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_slice_depth", + "line": 1396, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "SDEPTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D765", + "tlb": "#D765" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CDEPTH", + "fift_examples": [], + "gas": "26", + "opcode": "D765", + "stack": "c - x" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_depth", + "line": 1388, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CDEPTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D766", + "tlb": "#D766" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns level of the cell.

\n", + "fift": "CLEVEL", + "fift_examples": [], + "gas": "26", + "opcode": "D766", + "stack": "cell - level" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_level", + "line": 1404, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CLEVEL", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "level", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D767", + "tlb": "#D767" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns level mask of the cell.

\n", + "fift": "CLEVELMASK", + "fift_examples": [], + "gas": "26", + "opcode": "D767", + "stack": "cell - level_mask" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_level_mask", + "line": 1412, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CLEVELMASK", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "level_mask", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "n", + "size": 2, + "type": "uint" + } + ], + "prefix": "D76A_", + "tlb": "#D76A_ i:uint2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns ith hash of the cell.

\n", + "fift": "[i] CHASHI", + "fift_examples": [], + "gas": "26", + "opcode": "D76A_", + "stack": "cell - hash" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_hash_i", + "line": 1420, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CHASHI", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "hash", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 3, + "min_value": 0, + "name": "n", + "size": 2, + "type": "uint" + } + ], + "prefix": "D76E_", + "tlb": "#D76E_ i:uint2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns ith depth of the cell.

\n", + "fift": "[i] CDEPTHI", + "fift_examples": [], + "gas": "26", + "opcode": "D76E_", + "stack": "cell - depth" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_depth_i", + "line": 1438, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CDEPTHI", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "depth", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D770", + "tlb": "#D770" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns ith hash of the cell.

\n", + "fift": "CHASHIX", + "fift_examples": [], + "gas": "26", + "opcode": "D770", + "stack": "cell i - hash" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_hash_i", + "line": 1420, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CHASHIX", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "hash", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D771", + "tlb": "#D771" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cell_parse", + "description": "

Returns ith depth of the cell.

\n", + "fift": "CDEPTHIX", + "fift_examples": [], + "gas": "26", + "opcode": "D771", + "stack": "cell i - depth" + }, + "implementation": [ + { + "file": "cellops.cpp", + "function_name": "exec_cell_depth_i", + "line": 1438, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/cellops.cpp" + } + ], + "mnemonic": "CDEPTHIX", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "cell", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "depth", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D8", + "tlb": "#D8" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Calls, or executes, continuation c.

\n", + "fift": "EXECUTE\nCALLX", + "fift_examples": [], + "gas": "18", + "opcode": "D8", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_execute", + "line": 33, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "EXECUTE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "D9", + "tlb": "#D9" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Jumps, or transfers control, to continuation c.\nThe remainder of the previous current continuation cc is discarded.

\n", + "fift": "JMPX", + "fift_examples": [], + "gas": "18", + "opcode": "D9", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_jmpx", + "line": 53, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + } + ], + "prefix": "DA", + "tlb": "#DA p:uint4 r:uint4" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Calls continuation c with p parameters and expecting r return values\n0 <= p <= 15, 0 <= r <= 15

\n", + "fift": "[p] [r] CALLXARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DApr", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callx_args", + "line": 39, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLXARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + } + ], + "prefix": "DB0", + "tlb": "#DB0 p:uint4" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Calls continuation c with 0 <= p <= 15 parameters, expecting an arbitrary number of return values.

\n", + "fift": "[p] -1 CALLXARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB0p", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callx_args", + "line": 39, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLXARGS_VAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + } + ], + "prefix": "DB1", + "tlb": "#DB1 p:uint4" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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).

\n", + "fift": "[p] JMPXARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB1p", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_jmpx_args", + "line": 59, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPXARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + } + ], + "prefix": "DB2", + "tlb": "#DB2 r:uint4" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Returns to c0, with 0 <= r <= 15 return values taken from the current stack.

\n", + "fift": "[r] RETARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB2r", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_args", + "line": 71, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB30", + "tlb": "#DB30" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "RET\nRETTRUE", + "fift_examples": [], + "gas": "26", + "opcode": "DB30", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret", + "line": 66, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB31", + "tlb": "#DB31" + }, + "control_flow": { + "branches": [ + { + "index": 1, + "type": "register" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Returns to the continuation at c1.\nApproximately equivalent to c1 PUSHCTR JMPX.

\n", + "fift": "RETALT\nRETFALSE", + "fift_examples": [], + "gas": "26", + "opcode": "DB31", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_alt", + "line": 77, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB32", + "tlb": "#DB32" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + }, + { + "index": 1, + "type": "register" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Performs RETTRUE if integer f!=0, or RETFALSE if f=0.

\n", + "fift": "BRANCH\nRETBOOL", + "fift_examples": [], + "gas": "26", + "opcode": "DB32", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_bool", + "line": 82, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "BRANCH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB34", + "tlb": "#DB34" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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).

\n", + "fift": "CALLCC", + "fift_examples": [], + "gas": "26", + "opcode": "DB34", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callcc", + "line": 87, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLCC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB35", + "tlb": "#DB35" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "JMPXDATA", + "fift_examples": [], + "gas": "26", + "opcode": "DB35", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_jmpx_data", + "line": 96, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPXDATA", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "optional_nargs" + } + ], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + } + ], + "prefix": "DB36", + "tlb": "#DB36 p:uint4 r:uint4" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[p] [r] CALLCCARGS", + "fift_examples": [], + "gas": "34", + "opcode": "DB36pr", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callcc_args", + "line": 103, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLCCARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB38", + "tlb": "#DB38" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "CALLXVARARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB38", + "stack": "c p r - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callx_varargs", + "line": 114, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLXVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "p", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB39", + "tlb": "#DB39" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Similar to RETARGS.

\n", + "fift": "RETVARARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB39", + "stack": "p r - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_varargs", + "line": 123, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "p", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB3A", + "tlb": "#DB3A" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Similar to JMPXARGS.

\n", + "fift": "JMPXVARARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB3A", + "stack": "c p r - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_jmpx_varargs", + "line": 130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPXVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "p", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB3B", + "tlb": "#DB3B" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Similar to CALLCCARGS.

\n", + "fift": "CALLCCVARARGS", + "fift_examples": [], + "gas": "26", + "opcode": "DB3B", + "stack": "c p r - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_callcc_varargs", + "line": 139, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLCCVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "p", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "p", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "DB3C", + "tlb": "#DB3C c:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Equivalent to PUSHREFCONT CALLX.

\n", + "fift": "[ref] CALLREF", + "fift_examples": [], + "gas": "126/51", + "opcode": "DB3C", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_do_with_ref", + "line": 152, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "DB3D", + "tlb": "#DB3D c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Equivalent to PUSHREFCONT JMPX.

\n", + "fift": "[ref] JMPREF", + "fift_examples": [], + "gas": "126/51", + "opcode": "DB3D", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmpref", + "line": 459, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "DB3E", + "tlb": "#DB3E c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_basic", + "description": "

Equivalent to PUSHREFCONT JMPXDATA.

\n", + "fift": "[ref] JMPREFDATA", + "fift_examples": [], + "gas": "126/51", + "opcode": "DB3E", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_data", + "line": 209, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPREFDATA", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB3F", + "tlb": "#DB3F" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "RETDATA", + "fift_examples": [], + "gas": "26", + "opcode": "DB3F", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ret_data", + "line": 209, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETDATA", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 4095, + "min_value": 0, + "name": "flags", + "size": 12, + "type": "uint" + } + ], + "prefix": "DB4", + "tlb": "#DB4 flags:(## 12)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_basic", + "description": "

Runs child VM with code code and stack x_1...x_n. Returns the resulting stack x'_1...x'_m and exitcode. Other arguments and return values are enabled by flags.

\n

Flags operate similarly to RUNVMX in Fift:

\n
    \n
  • +1: sets c3 to code.
    • \n
  • +2: pushes an implicit 0 before executing the code.
    • \n
  • +4: takes persistent data c4 from the stack and returns its final value.
    • \n
  • +8: takes the gas limit g_l from the stack and returns the consumed gas g_c.
    • \n
  • +16: takes c7 (smart contract context) from the stack.
    • \n
  • +32: returns the final value of c5 (actions).
    • \n
  • +64: pops the hard gas limit g_m enabled by ACCEPT from the stack.
    • \n
  • +128: enables \"isolated gas consumption\", meaning the child VM maintains a separate set of visited cells and a chksgn counter.
    • \n
  • +256: pops an integer r and ensures exactly r values are returned from the top of the stack:\n
      \n
    • If RUNVM call succeeds and r is set, it returns r elements. If r is not set, it returns all available elements.
      • \n
    • If RUNVM is successful but lacks elements on the stack, meaning the stack depth is less than r, it is treated as an exception in the child VM. The exit_code is set to -3, and exit_arg is set to 0, so 0 is returned as the only stack element.
      • \n
    • If RUNVM fails with an exception, only one element is returned, exit_arg, which should not be confused with exit_code.
      • \n
    • In the case of running out of gas, exit_code is set to -14, and exit_arg contains the amount of gas.
      • \n
    \n
    • \n
\n

Gas cost:

\n
    \n
  • 66 gas;
    • \n
  • 1 gas for each stack element passed to the child VM (the first 32 elements are free);
    • \n
  • 1 gas for each stack element returned from the child VM (the first 32 elements are free).
    • \n
\n", + "fift": "flags RUNVM", + "fift_examples": [], + "gas": "74", + "opcode": "DB4fff", + "stack": "x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_execute", + "line": 33, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RUNVM", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DB50", + "tlb": "#DB50" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_basic", + "description": "

Runs child VM with code code and stack x_1...x_n. Returns the resulting stack x'_1...x'_m and exitcode. Other arguments and return values are enabled by flags.

\n

Flags operate similarly to RUNVMX in Fift:

\n
    \n
  • +1: sets c3 to code.
    • \n
  • +2: pushes an implicit 0 before executing the code.
    • \n
  • +4: takes persistent data c4 from the stack and returns its final value.
    • \n
  • +8: takes the gas limit g_l from the stack and returns the consumed gas g_c.
    • \n
  • +16: takes c7 (smart contract context) from the stack.
    • \n
  • +32: returns the final value of c5 (actions).
    • \n
  • +64: pops the hard gas limit g_m enabled by ACCEPT from the stack.
    • \n
  • +128: enables \"isolated gas consumption\", meaning the child VM maintains a separate set of visited cells and a chksgn counter.
    • \n
  • +256: pops an integer r and ensures exactly r values are returned from the top of the stack:\n
      \n
    • If RUNVM call succeeds and r is set, it returns r elements. If r is not set, it returns all available elements.
      • \n
    • If RUNVM is successful but lacks elements on the stack, meaning the stack depth is less than r, it is treated as an exception in the child VM. The exit_code is set to -3, and exit_arg is set to 0, so 0 is returned as the only stack element.
      • \n
    • If RUNVM fails with an exception, only one element is returned, exit_arg, which should not be confused with exit_code.
      • \n
    • In the case of running out of gas, exit_code is set to -14, and exit_arg contains the amount of gas.
      • \n
    \n
    • \n
\n

Gas cost:

\n
    \n
  • 66 gas;
    • \n
  • 1 gas for each stack element passed to the child VM (the first 32 elements are free);
    • \n
  • 1 gas for each stack element returned from the child VM (the first 32 elements are free).
    • \n
\n", + "fift": "RUNVMX", + "fift_examples": [], + "gas": "66", + "opcode": "DB50", + "stack": "x_1 ... x_n n code [r] [c4] [c7] [g_l] [g_m] flags - x'_1 ... x'_m exitcode [data'] [c4'] [c5] [g_c]" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_runvmx", + "line": 277, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RUNVMX", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DC", + "tlb": "#DC" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "IFRET\nIFNOT:", + "fift_examples": [], + "gas": "18", + "opcode": "DC", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifret", + "line": 369, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFRET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DD", + "tlb": "#DD" + }, + "control_flow": { + "branches": [ + { + "index": 0, + "type": "register" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Performs a RET, but only if integer f is zero.

\n", + "fift": "IFNOTRET\nIF:", + "fift_examples": [], + "gas": "18", + "opcode": "DD", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifnotret", + "line": 377, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOTRET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DE", + "tlb": "#DE" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "IF", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `IF`.", + "fift": "IF:<{ code }> <{ code }>IF" + } + ], + "gas": "18", + "opcode": "DE", + "stack": "f c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if", + "line": 325, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "DF", + "tlb": "#DF" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Executes continuation c, but only if integer f is zero. Otherwise simply discards both values.

\n", + "fift": "IFNOT", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `IFNOT`.", + "fift": "IFNOT:<{ code }> <{ code }>IFNOT" + } + ], + "gas": "18", + "opcode": "DF", + "stack": "f c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifnot", + "line": 336, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E0", + "tlb": "#E0" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Jumps to c (similarly to JMPX), but only if f is non-zero.

\n", + "fift": "IFJMP", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `IFJMP`.", + "fift": "IFJMP:<{ code }>" + } + ], + "gas": "18", + "opcode": "E0", + "stack": "f c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_jmp", + "line": 347, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E1", + "tlb": "#E1" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Jumps to c (similarly to JMPX), but only if f is zero.

\n", + "fift": "IFNOTJMP", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `IFNOTJMP`.", + "fift": "IFNOTJMP:<{ code }>" + } + ], + "gas": "18", + "opcode": "E1", + "stack": "f c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifnot_jmp", + "line": 358, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOTJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E2", + "tlb": "#E2" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + }, + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

If integer f is non-zero, executes c, otherwise executes c'. Equivalent to CONDSELCHK EXECUTE.

\n", + "fift": "IFELSE", + "fift_examples": [ + { + "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `IFELSE`.", + "fift": "IF:<{ code1 }>ELSE<{ code2 }>" + } + ], + "gas": "18", + "opcode": "E2", + "stack": "f c c' - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_else", + "line": 385, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFELSE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E300", + "tlb": "#E300 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "[ref] IFREF", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E300", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifret", + "line": 369, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E301", + "tlb": "#E301 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Equivalent to PUSHREFCONT IFNOT.

\n", + "fift": "[ref] IFNOTREF", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E301", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifnotret", + "line": 377, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E302", + "tlb": "#E302 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Equivalent to PUSHREFCONT IFJMP.

\n", + "fift": "[ref] IFJMPREF", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E302", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmpref", + "line": 459, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFJMPREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E303", + "tlb": "#E303 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Equivalent to PUSHREFCONT IFNOTJMP.

\n", + "fift": "[ref] IFNOTJMPREF", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E303", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_condsel", + "line": 398, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOTJMPREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E304", + "tlb": "#E304" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CONDSEL", + "fift_examples": [], + "gas": "26", + "opcode": "E304", + "stack": "f x y - x or y" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_condsel", + "line": 398, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CONDSEL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E305", + "tlb": "#E305" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Same as CONDSEL, but first checks whether x and y have the same type.

\n", + "fift": "CONDSELCHK", + "fift_examples": [], + "gas": "26", + "opcode": "E305", + "stack": "f x y - x or y" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_condsel_chk", + "line": 408, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CONDSELCHK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x", + "type": "simple" + }, + { + "name": "y", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E308", + "tlb": "#E308" + }, + "control_flow": { + "branches": [ + { + "index": 1, + "type": "register" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Performs RETALT if integer f!=0.

\n", + "fift": "IFRETALT", + "fift_examples": [], + "gas": "26", + "opcode": "E308", + "stack": "f -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifretalt", + "line": 421, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFRETALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E309", + "tlb": "#E309" + }, + "control_flow": { + "branches": [ + { + "index": 1, + "type": "register" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_conditional", + "description": "

Performs RETALT if integer f=0.

\n", + "fift": "IFNOTRETALT", + "fift_examples": [], + "gas": "26", + "opcode": "E309", + "stack": "f -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifnotretalt", + "line": 429, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNOTRETALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E30D", + "tlb": "#E30D c:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + }, + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[ref] IFREFELSE", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E30D", + "stack": "f c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifref_elseref", + "line": 193, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFREFELSE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E30E", + "tlb": "#E30E c:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + }, + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

Equivalent to PUSHREFCONT IFELSE.

\n", + "fift": "[ref] IFELSEREF", + "fift_examples": [], + "gas": "26/126/51", + "opcode": "E30E", + "stack": "f c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifelse_ref", + "line": 174, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFELSEREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c1", + "type": "ref" + }, + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c2", + "type": "ref" + } + ], + "prefix": "E30F", + "tlb": "#E30F c1:^Cell c2:^Cell" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c1" + }, + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

Equivalent to PUSHREFCONT PUSHREFCONT IFELSE.

\n", + "fift": "[ref] [ref] IFREFELSEREF", + "fift_examples": [], + "gas": "126/51", + "opcode": "E30F", + "stack": "f -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_ifref_elseref", + "line": 193, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFREFELSEREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 0, + "name": "n", + "size": 5, + "type": "uint" + } + ], + "prefix": "E39_", + "tlb": "#E39_ n:uint5" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[n] IFBITJMP", + "fift_examples": [], + "gas": "26", + "opcode": "E39_n", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmp", + "line": 437, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFBITJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 0, + "name": "n", + "size": 5, + "type": "uint" + } + ], + "prefix": "E3B_", + "tlb": "#E3B_ n:uint5" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

Jumps to c if bit 0 <= n <= 31 is not set in integer x.

\n", + "fift": "[n] IFNBITJMP", + "fift_examples": [], + "gas": "26", + "opcode": "E3B_n", + "stack": "x c - x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmp", + "line": 437, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNBITJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 0, + "name": "n", + "size": 5, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E3D_", + "tlb": "#E3D_ n:uint5 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

Performs a JMPREF if bit 0 <= n <= 31 is set in integer x.

\n", + "fift": "[ref] [n] IFBITJMPREF", + "fift_examples": [], + "gas": "126/51", + "opcode": "E3D_n", + "stack": "x - x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmpref", + "line": 459, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFBITJMPREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 0, + "name": "n", + "size": 5, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "continuation" + } + ], + "name": "c", + "type": "ref" + } + ], + "prefix": "E3F_", + "tlb": "#E3F_ n:uint5 c:^Cell" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_conditional", + "description": "

Performs a JMPREF if bit 0 <= n <= 31 is not set in integer x.

\n", + "fift": "[ref] [n] IFNBITJMPREF", + "fift_examples": [], + "gas": "126/51", + "opcode": "E3F_n", + "stack": "x - x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_if_bit_jmpref", + "line": 459, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "IFNBITJMPREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E4", + "tlb": "#E4" + }, + "control_flow": { + "branches": [ + { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "type": "variable", + "var_name": "c" + }, + "count": "n" + }, + "name": "repeat", + "type": "special" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "REPEAT", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `REPEAT`.", + "fift": "REPEAT:<{ code }> <{ code }>REPEAT" + } + ], + "gas": "18", + "opcode": "E4", + "stack": "n c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_repeat", + "line": 489, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "REPEAT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E5", + "tlb": "#E5" + }, + "control_flow": { + "branches": [ + { + "args": { + "after": { + "index": 0, + "type": "register" + }, + "body": { + "type": "cc" + }, + "count": "n" + }, + "name": "repeat", + "type": "special" + } + ], + "nobranch": true + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to REPEAT, but it is applied to the current continuation cc.

\n", + "fift": "REPEATEND\nREPEAT:", + "fift_examples": [], + "gas": "18", + "opcode": "E5", + "stack": "n - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_repeat_end", + "line": 501, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "REPEATEND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E6", + "tlb": "#E6" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "type": "variable", + "var_name": "c" + } + }, + "name": "until", + "type": "special" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "UNTIL", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `UNTIL`.", + "fift": "UNTIL:<{ code }> <{ code }>UNTIL" + } + ], + "gas": "18", + "opcode": "E6", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_until", + "line": 513, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "UNTIL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E7", + "tlb": "#E7" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "index": 0, + "type": "register" + }, + "body": { + "type": "cc" + } + }, + "name": "until", + "type": "special" + } + }, + "type": "cc" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "UNTILEND\nUNTIL:", + "fift_examples": [], + "gas": "18", + "opcode": "E7", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_until_end", + "line": 520, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "UNTILEND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E8", + "tlb": "#E8" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "type": "variable", + "var_name": "c" + }, + "cond": { + "type": "variable", + "var_name": "c2" + } + }, + "name": "while", + "type": "special" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "WHILE", + "fift_examples": [ + { + "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILE`.", + "fift": "WHILE:<{ cond }>DO<{ code }>" + } + ], + "gas": "18", + "opcode": "E8", + "stack": "c' c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_while", + "line": 526, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "WHILE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E9", + "tlb": "#E9" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "index": 0, + "type": "register" + }, + "body": { + "type": "cc" + }, + "cond": { + "type": "variable", + "var_name": "c2" + } + }, + "name": "while", + "type": "special" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to WHILE, but uses the current continuation cc as the loop body.

\n", + "fift": "WHILEEND", + "fift_examples": [], + "gas": "18", + "opcode": "E9", + "stack": "c' - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_while_end", + "line": 535, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "WHILEEND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EA", + "tlb": "#EA" + }, + "control_flow": { + "branches": [ + { + "args": { + "body": { + "type": "variable", + "var_name": "c" + } + }, + "name": "again", + "type": "special" + } + ], + "nobranch": false + }, + "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).

\n", + "fift": "AGAIN", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `AGAIN`.", + "fift": "AGAIN:<{ code }> <{ code }>AGAIN" + } + ], + "gas": "18", + "opcode": "EA", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_again", + "line": 542, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "AGAIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EB", + "tlb": "#EB" + }, + "control_flow": { + "branches": [ + { + "args": { + "body": { + "type": "cc" + } + }, + "name": "again", + "type": "special" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to AGAIN, but performed with respect to the current continuation cc.

\n", + "fift": "AGAINEND\nAGAIN:", + "fift_examples": [], + "gas": "18", + "opcode": "EB", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_again_end", + "line": 550, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "AGAINEND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E314", + "tlb": "#E314" + }, + "control_flow": { + "branches": [ + { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "save": { + "c1": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + }, + "count": "n" + }, + "name": "repeat", + "type": "special" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "REPEATBRK", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `REPEATBRK`.", + "fift": "REPEATBRK:<{ code }> <{ code }>REPEATBRK" + } + ], + "gas": "26", + "opcode": "E314", + "stack": "n c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_repeat", + "line": 489, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "REPEATBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E315", + "tlb": "#E315" + }, + "control_flow": { + "branches": [ + { + "args": { + "after": { + "index": 0, + "type": "register" + }, + "body": { + "save": { + "c1": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + }, + "count": "n" + }, + "name": "repeat", + "type": "special" + } + ], + "nobranch": true + }, + "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.

\n", + "fift": "REPEATENDBRK", + "fift_examples": [], + "gas": "26", + "opcode": "E315", + "stack": "n -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_repeat_end", + "line": 501, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "REPEATENDBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E316", + "tlb": "#E316" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "save": { + "c1": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + }, + "name": "until", + "type": "special" + }, + "c1": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to UNTIL, but also modifies c1 in the same way as REPEATBRK.

\n", + "fift": "UNTILBRK", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `UNTILBRK`.", + "fift": "UNTILBRK:<{ code }>" + } + ], + "gas": "26", + "opcode": "E316", + "stack": "c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_until", + "line": 513, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "UNTILBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E317", + "tlb": "#E317" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "index": 0, + "type": "register" + }, + "body": { + "save": { + "c1": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "name": "until", + "type": "special" + }, + "c1": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_loops", + "description": "

Equivalent to SAMEALTSAVE UNTILEND.

\n", + "fift": "UNTILENDBRK\nUNTILBRK:", + "fift_examples": [], + "gas": "26", + "opcode": "E317", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_until_end", + "line": 520, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "UNTILENDBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E318", + "tlb": "#E318" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "after": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + }, + "body": { + "type": "variable", + "var_name": "c" + }, + "cond": { + "type": "variable", + "var_name": "c2" + } + }, + "name": "while", + "type": "special" + } + }, + "type": "variable", + "var_name": "c2" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to WHILE, but also modifies c1 in the same way as REPEATBRK.

\n", + "fift": "WHILEBRK", + "fift_examples": [ + { + "description": "Equivalent to `<{ cond }> CONT` `<{ code }> CONT` `WHILEBRK`.", + "fift": "WHILEBRK:<{ cond }>DO<{ code }>" + } + ], + "gas": "26", + "opcode": "E318", + "stack": "c' c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_while", + "line": 526, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "WHILEBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E319", + "tlb": "#E319" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_loops", + "description": "

Equivalent to SAMEALTSAVE WHILEEND.

\n", + "fift": "WHILEENDBRK", + "fift_examples": [], + "gas": "26", + "opcode": "E319", + "stack": "c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_while_end", + "line": 535, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "WHILEENDBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E31A", + "tlb": "#E31A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_loops", + "description": "

Similar to AGAIN, but also modifies c1 in the same way as REPEATBRK.

\n", + "fift": "AGAINBRK", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `AGAINBRK`.", + "fift": "AGAINBRK:<{ code }>" + } + ], + "gas": "26", + "opcode": "E31A", + "stack": "c -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_again", + "line": 542, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "AGAINBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "E31B", + "tlb": "#E31B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_loops", + "description": "

Equivalent to SAMEALTSAVE AGAINEND.

\n", + "fift": "AGAINENDBRK\nAGAINBRK:", + "fift_examples": [], + "gas": "26", + "opcode": "E31B", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_again_end", + "line": 550, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "AGAINENDBRK", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "optional_nargs" + } + ], + "max_value": 15, + "min_value": 0, + "name": "n", + "size": 4, + "type": "uint" + } + ], + "prefix": "EC", + "tlb": "#EC r:uint4 n:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_stack", + "description": "

Pushes 0 <= r <= 15 values x_1...x_r into the stack of (a copy of) the continuation c, starting with x_1. When n is 15 (-1 in Fift notation), does nothing with c.nargs. For 0 <= n <= 14, sets c.nargs to the final size of the stack of c' plus n. In other words, transforms c into a closure or a partially applied function, with 0 <= n <= 14 arguments missing.

\n", + "fift": "[r] [n] SETCONTARGS", + "fift_examples": [], + "gas": "26+s''", + "opcode": "ECrn", + "stack": "x_1 x_2...x_r c - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcontargs", + "line": 665, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTARGS_N", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "r", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED0", + "tlb": "#ED0 p:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[p] RETURNARGS", + "fift_examples": [], + "gas": "26+s''", + "opcode": "ED0p", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_return_args", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETURNARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "ED10", + "tlb": "#ED10" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_stack", + "description": "

Similar to RETURNARGS, but with Integer 0 <= p <= 255 taken from the stack.

\n", + "fift": "RETURNVARARGS", + "fift_examples": [], + "gas": "26+s''", + "opcode": "ED10", + "stack": "p -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_return_varargs", + "line": 728, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "RETURNVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "ED11", + "tlb": "#ED11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_stack", + "description": "

Similar to SETCONTARGS, but with 0 <= r <= 255 and -1 <= n <= 255 taken from the stack.

\n", + "fift": "SETCONTVARARGS", + "fift_examples": [], + "gas": "26+s''", + "opcode": "ED11", + "stack": "x_1 x_2...x_r c r n - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcont_varargs", + "line": 678, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "r", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "ED12", + "tlb": "#ED12" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETNUMVARARGS", + "fift_examples": [], + "gas": "26", + "opcode": "ED12", + "stack": "c n - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setnum_varargs", + "line": 687, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETNUMVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "ED1E", + "tlb": "#ED1E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "BLESS", + "fift_examples": [], + "gas": "26", + "opcode": "ED1E", + "stack": "s - c" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_bless", + "line": 733, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "BLESS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "ED1F", + "tlb": "#ED1F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_create", + "description": "

Equivalent to ROT BLESS ROTREV SETCONTVARARGS.

\n", + "fift": "BLESSVARARGS", + "fift_examples": [], + "gas": "26+s''", + "opcode": "ED1F", + "stack": "x_1...x_r s r n - c" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_bless_varargs", + "line": 750, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "BLESSVARARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "r", + "name": "args", + "type": "array" + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + }, + { + "display_hints": [ + { + "type": "optional_nargs" + } + ], + "max_value": 15, + "min_value": 0, + "name": "n", + "size": 4, + "type": "uint" + } + ], + "prefix": "EE", + "tlb": "#EE r:uint4 n:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[r] [n] BLESSARGS", + "fift_examples": [], + "gas": "26", + "opcode": "EErn", + "stack": "x_1...x_r s - c" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_bless_args", + "line": 759, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "BLESSARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple" + } + ], + "length_var": "r", + "name": "args", + "type": "array" + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED4", + "tlb": "#ED4 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] PUSHCTR\nc[i] PUSH", + "fift_examples": [], + "gas": "26", + "opcode": "ED4i", + "stack": "- x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_push_ctr", + "line": 765, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "PUSHCTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED5", + "tlb": "#ED5 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] POPCTR\nc[i] POP", + "fift_examples": [], + "gas": "26", + "opcode": "ED5i", + "stack": "x - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_pop_ctr", + "line": 794, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "POPCTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED6", + "tlb": "#ED6 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] SETCONT\nc[i] SETCONTCTR", + "fift_examples": [], + "gas": "26", + "opcode": "ED6i", + "stack": "x c - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcont_ctr", + "line": 807, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTCTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED7", + "tlb": "#ED7 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Equivalent to c0 PUSHCTR c[i] SETCONTCTR c0 POPCTR.

\n", + "fift": "c[i] SETRETCTR", + "fift_examples": [], + "gas": "26", + "opcode": "ED7i", + "stack": "x - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setret_ctr", + "line": 818, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETRETCTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED8", + "tlb": "#ED8 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Equivalent to c1 PUSHCTR c[i] SETCONTCTR c1 POPCTR.

\n", + "fift": "c[i] SETALTCTR", + "fift_examples": [], + "gas": "26", + "opcode": "ED8i", + "stack": "x - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setalt_ctr", + "line": 827, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETALTCTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "ED9", + "tlb": "#ED9 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] POPSAVE\nc[i] POPCTRSAVE", + "fift_examples": [], + "gas": "26", + "opcode": "ED9i", + "stack": "x -" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_popsave_ctr", + "line": 836, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "POPSAVE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + }, + { + "index": 0, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "EDA", + "tlb": "#EDA i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] SAVE\nc[i] SAVECTR", + "fift_examples": [], + "gas": "26", + "opcode": "EDAi", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_savealt_ctr", + "line": 873, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SAVE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + }, + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "EDB", + "tlb": "#EDB i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "c[i] SAVEALT\nc[i] SAVEALTCTR", + "fift_examples": [], + "gas": "26", + "opcode": "EDBi", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_samealt", + "line": 862, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SAVEALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "register" + } + ], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "EDC", + "tlb": "#EDC i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Equivalent to c[i] SAVE c[i] SAVEALT.

\n", + "fift": "c[i] SAVEBOTH\nc[i] SAVEBOTHCTR", + "fift_examples": [], + "gas": "26", + "opcode": "EDCi", + "stack": "" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_saveboth_ctr", + "line": 882, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SAVEBOTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + }, + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDE0", + "tlb": "#EDE0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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 ''exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of x depends on i.

\n", + "fift": "PUSHCTRX", + "fift_examples": [], + "gas": "26", + "opcode": "EDE0", + "stack": "i - x" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_push_ctr_var", + "line": 894, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "PUSHCTRX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + } + ], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDE1", + "tlb": "#EDE1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Similar to c[i] POPCTR, but with 0 <= i <= 255 from the stack.

\n", + "fift": "POPCTRX", + "fift_examples": [], + "gas": "26", + "opcode": "EDE1", + "stack": "x i - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_pop_ctr_var", + "line": 904, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "POPCTRX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "type": "variable", + "var_name": "i" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDE2", + "tlb": "#EDE2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Similar to c[i] SETCONTCTR, but with 0 <= i <= 255 from the stack.

\n", + "fift": "SETCONTCTRX", + "fift_examples": [], + "gas": "26", + "opcode": "EDE2", + "stack": "x c i - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcont_ctr_var", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTCTRX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 255, + "min_value": 0, + "name": "mask", + "size": 8, + "type": "uint" + } + ], + "prefix": "EDE3", + "tlb": "#EDE3 mask:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Takes continuation, performs the equivalent of c[i] PUSHCTR SWAP c[i] SETCONTCNR for each i that is set in mask (mask is in 0..255).

\n", + "fift": "SETCONTCTRMANY\nSETCONTMANY", + "fift_examples": [], + "gas": "34", + "opcode": "EDE3mm", + "stack": "c - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcont_ctr_many", + "line": 926, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTCTRMANY", + "since_version": 9, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDE4", + "tlb": "#EDE4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Takes continuation, performs the equivalent of c[i] PUSHCTR SWAP c[i] SETCONTCNR for each i that is set in mask (mask is in 0..255).

\n", + "fift": "SETCONTCTRMANYX\nSETCONTMANYX", + "fift_examples": [], + "gas": "26", + "opcode": "EDE4", + "stack": "c mask - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setcont_ctr_many_var", + "line": 943, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCONTCTRMANYX", + "since_version": 9, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "mask", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF0", + "tlb": "#EDF0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Computes the composition compose0(c, c'), which has the meaning of ''perform c, and, if successful, perform c''' (if c is a boolean circuit) or simply ''perform c, then c'''. Equivalent to SWAP c0 SETCONT.

\n", + "fift": "COMPOS\nBOOLAND", + "fift_examples": [], + "gas": "26", + "opcode": "EDF0", + "stack": "c c' - c''" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_compos", + "line": 961, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "COMPOS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c3", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF1", + "tlb": "#EDF1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Computes the alternative composition compose1(c, c'), which has the meaning of ''perform c, and, if not successful, perform c''' (if c is a boolean circuit). Equivalent to SWAP c1 SETCONT.

\n", + "fift": "COMPOSALT\nBOOLOR", + "fift_examples": [], + "gas": "26", + "opcode": "EDF1", + "stack": "c c' - c''" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_compos", + "line": 961, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "COMPOSALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c3", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF2", + "tlb": "#EDF2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Computes composition compose1(compose0(c, c'), c'), which has the meaning of ''compute boolean circuit c, then compute c', regardless of the result of c''.

\n", + "fift": "COMPOSBOTH", + "fift_examples": [], + "gas": "26", + "opcode": "EDF2", + "stack": "c c' - c''" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_compos", + "line": 961, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "COMPOSBOTH", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c3", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF3", + "tlb": "#EDF3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Sets c0 to compose0(c, c0). In other words, c will be executed before exiting current subroutine.

\n", + "fift": "ATEXIT", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `ATEXIT`.", + "fift": "ATEXIT:<{ code }> <{ code }>ATEXIT" + } + ], + "gas": "26", + "opcode": "EDF3", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_atexit", + "line": 983, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "ATEXIT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF4", + "tlb": "#EDF4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "ATEXITALT", + "fift_examples": [ + { + "description": "Equivalent to `<{ code }> CONT` `ATEXITALT`.", + "fift": "ATEXITALT:<{ code }> <{ code }>ATEXITALT" + } + ], + "gas": "26", + "opcode": "EDF4", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_atexit_alt", + "line": 992, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "ATEXITALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF5", + "tlb": "#EDF5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETEXITALT", + "fift_examples": [], + "gas": "26", + "opcode": "EDF5", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_setexit_alt", + "line": 1001, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETEXITALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF6", + "tlb": "#EDF6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Computes compose0(c, c0).

\n", + "fift": "THENRET", + "fift_examples": [], + "gas": "26", + "opcode": "EDF6", + "stack": "c - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_thenret", + "line": 1011, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THENRET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF7", + "tlb": "#EDF7" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Computes compose0(c, c1)

\n", + "fift": "THENRETALT", + "fift_examples": [], + "gas": "26", + "opcode": "EDF7", + "stack": "c - c'" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_thenret_alt", + "line": 1020, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THENRETALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF8", + "tlb": "#EDF8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Interchanges c0 and c1.

\n", + "fift": "INVERT", + "fift_examples": [], + "gas": "26", + "opcode": "EDF8", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_invert", + "line": 1029, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "INVERT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDF9", + "tlb": "#EDF9" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "args": { + "next": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + }, + "value": -1 + }, + "name": "pushint", + "type": "special" + }, + "c1": { + "args": { + "next": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + } + }, + "type": "cc" + }, + "value": 0 + }, + "name": "pushint", + "type": "special" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "BOOLEVAL", + "fift_examples": [], + "gas": "26", + "opcode": "EDF9", + "stack": "c - ?" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_booleval", + "line": 1037, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "BOOLEVAL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDFA", + "tlb": "#EDFA" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "cont_registers", + "description": "

Sets c1 to c0. Equivalent to c0 PUSHCTR c1 POPCTR.

\n", + "fift": "SAMEALT", + "fift_examples": [], + "gas": "26", + "opcode": "EDFA", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_samealt", + "line": 862, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SAMEALT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "EDFB", + "tlb": "#EDFB" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SAMEALTSAVE", + "fift_examples": [], + "gas": "26", + "opcode": "EDFB", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_samealt", + "line": 862, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SAMEALTSAVE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 0, + "type": "constant" + }, + { + "index": 1, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 255, + "min_value": 0, + "name": "n", + "size": 8, + "type": "uint" + } + ], + "prefix": "F0", + "tlb": "#F0 n:uint8" + }, + "control_flow": { + "branches": [ + { + "index": 3, + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "register" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[nn] CALL\n[nn] CALLDICT", + "fift_examples": [], + "gas": "26", + "opcode": "F0nn", + "stack": "- nn" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_calldict_short", + "line": 1092, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 16383, + "min_value": 0, + "name": "n", + "size": 14, + "type": "uint" + } + ], + "prefix": "F12_", + "tlb": "#F12_ n:uint14" + }, + "control_flow": { + "branches": [ + { + "index": 3, + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "register" + } + ], + "nobranch": false + }, + "doc": { + "category": "cont_dict", + "description": "

For 0 <= n < 2^14, an encoding of [n] CALL for larger values of n.

\n", + "fift": "[n] CALL\n[n] CALLDICT", + "fift_examples": [], + "gas": "34", + "opcode": "F12_n", + "stack": "- n" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_calldict", + "line": 1099, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "CALLDICT_LONG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 16383, + "min_value": 0, + "name": "n", + "size": 14, + "type": "uint" + } + ], + "prefix": "F16_", + "tlb": "#F16_ n:uint14" + }, + "control_flow": { + "branches": [ + { + "index": 3, + "type": "register" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[n] JMP", + "fift_examples": [], + "gas": "34", + "opcode": "F16_n", + "stack": " - n" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_jmpdict", + "line": 1106, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "JMPDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 16383, + "min_value": 0, + "name": "n", + "size": 14, + "type": "uint" + } + ], + "prefix": "F1A_", + "tlb": "#F1A_ n:uint14" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[n] PREPARE\n[n] PREPAREDICT", + "fift_examples": [], + "gas": "34", + "opcode": "F1A_n", + "stack": " - n c" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_preparedict", + "line": 1113, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "PREPAREDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 3, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 63, + "min_value": 0, + "name": "n", + "size": 6, + "type": "uint" + } + ], + "prefix": "F22_", + "tlb": "#F22_ n:uint6" + }, + "control_flow": { + "branches": [], + "nobranch": false + }, + "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.

\n", + "fift": "[n] THROW", + "fift_examples": [], + "gas": "76", + "opcode": "F22_n", + "stack": " - 0 n" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROW_SHORT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 63, + "min_value": 0, + "name": "n", + "size": 6, + "type": "uint" + } + ], + "prefix": "F26_", + "tlb": "#F26_ n:uint6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n <= 63 with parameter zero only if integer f!=0.

\n", + "fift": "[n] THROWIF", + "fift_examples": [], + "gas": "26/76", + "opcode": "F26_n", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWIF_SHORT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 63, + "min_value": 0, + "name": "n", + "size": 6, + "type": "uint" + } + ], + "prefix": "F2A_", + "tlb": "#F2A_ n:uint6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n <= 63 with parameter zero only if integer f=0.

\n", + "fift": "[n] THROWIFNOT", + "fift_examples": [], + "gas": "26/76", + "opcode": "F2A_n", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWIFNOT_SHORT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2C4_", + "tlb": "#F2C4_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": false + }, + "doc": { + "category": "exceptions", + "description": "

For 0 <= n < 2^11, an encoding of [n] THROW for larger values of n.

\n", + "fift": "[n] THROW", + "fift_examples": [], + "gas": "84", + "opcode": "F2C4_n", + "stack": "- 0 nn" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROW", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2CC_", + "tlb": "#F2CC_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": false + }, + "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.

\n", + "fift": "[n] THROWARG", + "fift_examples": [], + "gas": "84", + "opcode": "F2CC_n", + "stack": "x - x nn" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_arg_fixed", + "line": 1140, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2D4_", + "tlb": "#F2D4_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

For 0 <= n < 2^11, an encoding of [n] THROWIF for larger values of n.

\n", + "fift": "[n] THROWIF", + "fift_examples": [], + "gas": "34/84", + "opcode": "F2D4_n", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2DC_", + "tlb": "#F2DC_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= nn < 2^11 with parameter x only if integer f!=0.

\n", + "fift": "[n] THROWARGIF", + "fift_examples": [], + "gas": "34/84", + "opcode": "F2DC_n", + "stack": "x f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_arg_fixed", + "line": 1140, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARGIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2E4_", + "tlb": "#F2E4_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

For 0 <= n < 2^11, an encoding of [n] THROWIFNOT for larger values of n.

\n", + "fift": "[n] THROWIFNOT", + "fift_examples": [], + "gas": "34/84", + "opcode": "F2E4_n", + "stack": "f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_fixed", + "line": 1130, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 2047, + "min_value": 0, + "name": "n", + "size": 11, + "type": "uint" + } + ], + "prefix": "F2EC_", + "tlb": "#F2EC_ n:uint11" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n < 2^11 with parameter x only if integer f=0.

\n", + "fift": "[n] THROWARGIFNOT", + "fift_examples": [], + "gas": "34/84", + "opcode": "F2EC_n", + "stack": "x f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_arg_fixed", + "line": 1140, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARGIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F0", + "tlb": "#F2F0" + }, + "control_flow": { + "branches": [], + "nobranch": false + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n < 2^16 with parameter zero.\nApproximately equivalent to ZERO SWAP THROWARGANY.

\n", + "fift": "THROWANY", + "fift_examples": [], + "gas": "76", + "opcode": "F2F0", + "stack": "n - 0 n" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWANY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F1", + "tlb": "#F2F1" + }, + "control_flow": { + "branches": [], + "nobranch": false + }, + "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.

\n", + "fift": "THROWARGANY", + "fift_examples": [], + "gas": "76", + "opcode": "F2F1", + "stack": "x n - x n" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARGANY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F2", + "tlb": "#F2F2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n < 2^16 with parameter zero only if f!=0.

\n", + "fift": "THROWANYIF", + "fift_examples": [], + "gas": "26/76", + "opcode": "F2F2", + "stack": "n f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWANYIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F3", + "tlb": "#F2F3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n<2^16 with parameter x only if f!=0.

\n", + "fift": "THROWARGANYIF", + "fift_examples": [], + "gas": "26/76", + "opcode": "F2F3", + "stack": "x n f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARGANYIF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F4", + "tlb": "#F2F4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n<2^16 with parameter zero only if f=0.

\n", + "fift": "THROWANYIFNOT", + "fift_examples": [], + "gas": "26/76", + "opcode": "F2F4", + "stack": "n f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWANYIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2F5", + "tlb": "#F2F5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "exceptions", + "description": "

Throws exception 0 <= n<2^16 with parameter x only if f=0.

\n", + "fift": "THROWARGANYIFNOT", + "fift_examples": [], + "gas": "26/76", + "opcode": "F2F5", + "stack": "x n f - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_throw_any", + "line": 1153, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "THROWARGANYIFNOT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F2FF", + "tlb": "#F2FF" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "cc" + }, + "c2": { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "cc" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "variable", + "var_name": "c2" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "TRY", + "fift_examples": [ + { + "description": "Equivalent to `<{ code1 }> CONT` `<{ code2 }> CONT` `TRY`.", + "fift": "TRY:<{ code1 }>CATCH<{ code2 }>" + } + ], + "gas": "26", + "opcode": "F2FF", + "stack": "c c' - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_try", + "line": 1186, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "TRY", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "p", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "r", + "size": 4, + "type": "uint" + } + ], + "prefix": "F3", + "tlb": "#F3 p:uint4 r:uint4" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "cc" + }, + "c2": { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + }, + "c1": { + "index": 1, + "type": "register" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "cc" + }, + "c2": { + "index": 2, + "type": "register" + } + }, + "type": "variable", + "var_name": "c2" + } + }, + "type": "variable", + "var_name": "c" + } + ], + "nobranch": false + }, + "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.

\n", + "fift": "[p] [r] TRYARGS", + "fift_examples": [], + "gas": "26", + "opcode": "F3pr", + "stack": "c c' - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_try", + "line": 1186, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "TRYARGS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "arg", + "type": "simple" + } + ], + "length_var": "r", + "name": "args", + "type": "array" + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Continuation" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Continuation" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F400", + "tlb": "#F400" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

Stores dictionary D into Builder b, returning 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.

\n", + "fift": "STDICT\nSTOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F400", + "stack": "D b - b'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_store_dict", + "line": 53, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "STDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F401", + "tlb": "#F401" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

Equivalent to LDDICT NIP.

\n", + "fift": "SKIPDICT\nSKIPOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F401", + "stack": "s - s'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_skip_dict", + "line": 82, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SKIPDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F402", + "tlb": "#F402" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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 ''split function'' for all HashmapE(n,X) dictionary types.

\n", + "fift": "LDDICTS", + "fift_examples": [], + "gas": "26", + "opcode": "F402", + "stack": "s - s' s''" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict_slice", + "line": 121, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "LDDICTS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F403", + "tlb": "#F403" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

Preloads a (Slice-represented) dictionary s' from Slice s.\nApproximately equivalent to LDDICTS DROP.

\n", + "fift": "PLDDICTS", + "fift_examples": [], + "gas": "26", + "opcode": "F403", + "stack": "s - s'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict_slice", + "line": 121, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PLDDICTS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F404", + "tlb": "#F404" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDDICT\nLDOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F404", + "stack": "s - D s'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict", + "line": 148, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "LDDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F405", + "tlb": "#F405" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

Preloads a dictionary D from Slice s.\nApproximately equivalent to LDDICT DROP.

\n", + "fift": "PLDDICT\nPLDOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F405", + "stack": "s - D" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict", + "line": 148, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PLDDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F406", + "tlb": "#F406" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

A quiet version of LDDICT.

\n", + "fift": "LDDICTQ", + "fift_examples": [], + "gas": "26", + "opcode": "F406", + "stack": "s - D s' -1 or s 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict", + "line": 148, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "LDDICTQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F407", + "tlb": "#F407" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_serial", + "description": "

A quiet version of PLDDICT.

\n", + "fift": "PLDDICTQ", + "fift_examples": [], + "gas": "26", + "opcode": "F407", + "stack": "s - D -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_load_dict", + "line": 148, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PLDDICTQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40A", + "tlb": "#F40A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTGET", + "fift_examples": [], + "gas": "26", + "opcode": "F40A", + "stack": "k D n - x -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get", + "line": 207, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40B", + "tlb": "#F40B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "DICTGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F40B", + "stack": "k D n - c -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40C", + "tlb": "#F40C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIGET", + "fift_examples": [], + "gas": "26", + "opcode": "F40C", + "stack": "i D n - x -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get", + "line": 207, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40D", + "tlb": "#F40D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F40D", + "stack": "i D n - c -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40E", + "tlb": "#F40E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_get", + "description": "

Similar to DICTIGET, but with unsigned (big-endian) n-bit Integer i used as a key.

\n", + "fift": "DICTUGET", + "fift_examples": [], + "gas": "26", + "opcode": "F40E", + "stack": "i D n - x -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get", + "line": 207, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F40F", + "tlb": "#F40F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_get", + "description": "

Similar to DICTIGETREF, but with an unsigned n-bit Integer key i.

\n", + "fift": "DICTUGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F40F", + "stack": "i D n - c -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F412", + "tlb": "#F412" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "DICTSET", + "fift_examples": [], + "gas": "26", + "opcode": "F412", + "stack": "x k D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F413", + "tlb": "#F413" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

Similar to DICTSET, but with the value set to a reference to Cell c.

\n", + "fift": "DICTSETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F413", + "stack": "c k D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F414", + "tlb": "#F414" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTISET", + "fift_examples": [], + "gas": "26", + "opcode": "F414", + "stack": "x i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F415", + "tlb": "#F415" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

Similar to DICTSETREF, but with the key a signed n-bit integer as in DICTISET.

\n", + "fift": "DICTISETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F415", + "stack": "c i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F416", + "tlb": "#F416" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

Similar to DICTISET, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUSET", + "fift_examples": [], + "gas": "26", + "opcode": "F416", + "stack": "x i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F417", + "tlb": "#F417" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

Similar to DICTISETREF, but with i unsigned.

\n", + "fift": "DICTUSETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F417", + "stack": "c i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41A", + "tlb": "#F41A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTSETGET", + "fift_examples": [], + "gas": "26", + "opcode": "F41A", + "stack": "x k D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41B", + "tlb": "#F41B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

Combines DICTSETREF with DICTGETREF similarly to DICTSETGET.

\n", + "fift": "DICTSETGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F41B", + "stack": "c k D n - D' c' -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41C", + "tlb": "#F41C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTISETGET, but with i a signed n-bit integer.

\n", + "fift": "DICTISETGET", + "fift_examples": [], + "gas": "26", + "opcode": "F41C", + "stack": "x i D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41D", + "tlb": "#F41D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTISETGETREF, but with i a signed n-bit integer.

\n", + "fift": "DICTISETGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F41D", + "stack": "c i D n - D' c' -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41E", + "tlb": "#F41E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTISETGET, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUSETGET", + "fift_examples": [], + "gas": "26", + "opcode": "F41E", + "stack": "x i D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F41F", + "tlb": "#F41F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTISETGETREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUSETGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F41F", + "stack": "c i D n - D' c' -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F422", + "tlb": "#F422" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTREPLACE", + "fift_examples": [], + "gas": "26", + "opcode": "F422", + "stack": "x k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F423", + "tlb": "#F423" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

A Replace counterpart of DICTSETREF.

\n", + "fift": "DICTREPLACEREF", + "fift_examples": [], + "gas": "26", + "opcode": "F423", + "stack": "c k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACEREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F424", + "tlb": "#F424" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACE, but with i a signed n-bit integer.

\n", + "fift": "DICTIREPLACE", + "fift_examples": [], + "gas": "26", + "opcode": "F424", + "stack": "x i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F425", + "tlb": "#F425" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEREF, but with i a signed n-bit integer.

\n", + "fift": "DICTIREPLACEREF", + "fift_examples": [], + "gas": "26", + "opcode": "F425", + "stack": "c i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACEREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F426", + "tlb": "#F426" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACE, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUREPLACE", + "fift_examples": [], + "gas": "26", + "opcode": "F426", + "stack": "x i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F427", + "tlb": "#F427" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUREPLACEREF", + "fift_examples": [], + "gas": "26", + "opcode": "F427", + "stack": "c i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACEREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42A", + "tlb": "#F42A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

A Replace counterpart of DICTSETGET: on success, also returns the old value associated with the key in question.

\n", + "fift": "DICTREPLACEGET", + "fift_examples": [], + "gas": "26", + "opcode": "F42A", + "stack": "x k D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACEGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42B", + "tlb": "#F42B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

A Replace counterpart of DICTSETGETREF.

\n", + "fift": "DICTREPLACEGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F42B", + "stack": "c k D n - D' c' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACEGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42C", + "tlb": "#F42C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEGET, but with i a signed n-bit integer.

\n", + "fift": "DICTIREPLACEGET", + "fift_examples": [], + "gas": "26", + "opcode": "F42C", + "stack": "x i D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACEGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42D", + "tlb": "#F42D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEGETREF, but with i a signed n-bit integer.

\n", + "fift": "DICTIREPLACEGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F42D", + "stack": "c i D n - D' c' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACEGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42E", + "tlb": "#F42E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEGET, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUREPLACEGET", + "fift_examples": [], + "gas": "26", + "opcode": "F42E", + "stack": "x i D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACEGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F42F", + "tlb": "#F42F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTREPLACEGETREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUREPLACEGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F42F", + "stack": "c i D n - D' c' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACEGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F432", + "tlb": "#F432" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTADD", + "fift_examples": [], + "gas": "26", + "opcode": "F432", + "stack": "x k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F433", + "tlb": "#F433" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

An Add counterpart of DICTSETREF.

\n", + "fift": "DICTADDREF", + "fift_examples": [], + "gas": "26", + "opcode": "F433", + "stack": "c k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADDREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F434", + "tlb": "#F434" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADD, but with i a signed n-bit integer.

\n", + "fift": "DICTIADD", + "fift_examples": [], + "gas": "26", + "opcode": "F434", + "stack": "x i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F435", + "tlb": "#F435" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDREF, but with i a signed n-bit integer.

\n", + "fift": "DICTIADDREF", + "fift_examples": [], + "gas": "26", + "opcode": "F435", + "stack": "c i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADDREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F436", + "tlb": "#F436" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADD, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUADD", + "fift_examples": [], + "gas": "26", + "opcode": "F436", + "stack": "x i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F437", + "tlb": "#F437" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUADDREF", + "fift_examples": [], + "gas": "26", + "opcode": "F437", + "stack": "c i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADDREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43A", + "tlb": "#F43A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTADDGET", + "fift_examples": [], + "gas": "26", + "opcode": "F43A", + "stack": "x k D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADDGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43B", + "tlb": "#F43B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

An Add counterpart of DICTSETGETREF.

\n", + "fift": "DICTADDGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F43B", + "stack": "c k D n - D' -1 or D c' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADDGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43C", + "tlb": "#F43C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDGET, but with i a signed n-bit integer.

\n", + "fift": "DICTIADDGET", + "fift_examples": [], + "gas": "26", + "opcode": "F43C", + "stack": "x i D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADDGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43D", + "tlb": "#F43D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDGETREF, but with i a signed n-bit integer.

\n", + "fift": "DICTIADDGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F43D", + "stack": "c i D n - D' -1 or D c' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADDGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43E", + "tlb": "#F43E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDGET, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUADDGET", + "fift_examples": [], + "gas": "26", + "opcode": "F43E", + "stack": "x i D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADDGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F43F", + "tlb": "#F43F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set", + "description": "

DICTADDGETREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUADDGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F43F", + "stack": "c i D n - D' -1 or D c' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADDGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F441", + "tlb": "#F441" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTSETB", + "fift_examples": [], + "gas": "26", + "opcode": "F441", + "stack": "b k D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F442", + "tlb": "#F442" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTISETB", + "fift_examples": [], + "gas": "26", + "opcode": "F442", + "stack": "b i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F443", + "tlb": "#F443" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUSETB", + "fift_examples": [], + "gas": "26", + "opcode": "F443", + "stack": "b i D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F445", + "tlb": "#F445" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTSETGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F445", + "stack": "b k D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F446", + "tlb": "#F446" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTISETGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F446", + "stack": "b i D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F447", + "tlb": "#F447" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUSETGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F447", + "stack": "b i D n - D' y -1 or D' 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F449", + "tlb": "#F449" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTREPLACEB", + "fift_examples": [], + "gas": "26", + "opcode": "F449", + "stack": "b k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACEB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F44A", + "tlb": "#F44A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTIREPLACEB", + "fift_examples": [], + "gas": "26", + "opcode": "F44A", + "stack": "b i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACEB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F44B", + "tlb": "#F44B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUREPLACEB", + "fift_examples": [], + "gas": "26", + "opcode": "F44B", + "stack": "b i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACEB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F44D", + "tlb": "#F44D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTREPLACEGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F44D", + "stack": "b k D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREPLACEGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F44E", + "tlb": "#F44E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTIREPLACEGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F44E", + "stack": "b i D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREPLACEGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F44F", + "tlb": "#F44F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUREPLACEGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F44F", + "stack": "b i D n - D' y -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREPLACEGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F451", + "tlb": "#F451" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTADDB", + "fift_examples": [], + "gas": "26", + "opcode": "F451", + "stack": "b k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADDB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F452", + "tlb": "#F452" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTIADDB", + "fift_examples": [], + "gas": "26", + "opcode": "F452", + "stack": "b i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADDB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F453", + "tlb": "#F453" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUADDB", + "fift_examples": [], + "gas": "26", + "opcode": "F453", + "stack": "b i D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_set", + "line": 271, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADDB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F455", + "tlb": "#F455" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTADDGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F455", + "stack": "b k D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTADDGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F456", + "tlb": "#F456" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTIADDGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F456", + "stack": "b i D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIADDGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F457", + "tlb": "#F457" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_set_builder", + "description": "", + "fift": "DICTUADDGETB", + "fift_examples": [], + "gas": "26", + "opcode": "F457", + "stack": "b i D n - D' -1 or D y 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget", + "line": 315, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUADDGETB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F459", + "tlb": "#F459" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTDEL", + "fift_examples": [], + "gas": "26", + "opcode": "F459", + "stack": "k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_delete", + "line": 374, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTDEL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F45A", + "tlb": "#F45A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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 (''key not found, dictionary unmodified'').

\n", + "fift": "DICTIDEL", + "fift_examples": [], + "gas": "26", + "opcode": "F45A", + "stack": "i D n - D' ?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_delete", + "line": 374, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIDEL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F45B", + "tlb": "#F45B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_delete", + "description": "

Similar to DICTIDEL, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUDEL", + "fift_examples": [], + "gas": "26", + "opcode": "F45B", + "stack": "i D n - D' ?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_delete", + "line": 374, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUDEL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F462", + "tlb": "#F462" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTDELGET", + "fift_examples": [], + "gas": "26", + "opcode": "F462", + "stack": "k D n - D' x -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTDELGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F463", + "tlb": "#F463" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTDELGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F463", + "stack": "k D n - D' c -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTDELGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F464", + "tlb": "#F464" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_delete", + "description": "

DICTDELGET, but with i a signed n-bit integer.

\n", + "fift": "DICTIDELGET", + "fift_examples": [], + "gas": "26", + "opcode": "F464", + "stack": "i D n - D' x -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIDELGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F465", + "tlb": "#F465" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_delete", + "description": "

DICTDELGETREF, but with i a signed n-bit integer.

\n", + "fift": "DICTIDELGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F465", + "stack": "i D n - D' c -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIDELGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F466", + "tlb": "#F466" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_delete", + "description": "

DICTDELGET, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUDELGET", + "fift_examples": [], + "gas": "26", + "opcode": "F466", + "stack": "i D n - D' x -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUDELGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F467", + "tlb": "#F467" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_delete", + "description": "

DICTDELGETREF, but with i an unsigned n-bit integer.

\n", + "fift": "DICTUDELGETREF", + "fift_examples": [], + "gas": "26", + "opcode": "F467", + "stack": "i D n - D' c -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_deleteget", + "line": 401, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUDELGETREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F469", + "tlb": "#F469" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F469", + "stack": "k D n - c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F46A", + "tlb": "#F46A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F46A", + "stack": "i D n - c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F46B", + "tlb": "#F46B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTUGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F46B", + "stack": "i D n - c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_optref", + "line": 247, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F46D", + "tlb": "#F46D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "DICTSETGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F46D", + "stack": "c^? k D n - D' ~c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget_optref", + "line": 442, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTSETGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F46E", + "tlb": "#F46E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTISETGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F46E", + "stack": "c^? i D n - D' ~c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget_optref", + "line": 442, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTISETGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F46F", + "tlb": "#F46F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_mayberef", + "description": "

Similar to primitive DICTSETGETOPTREF, but using unsigned n-bit Integer i as a key.

\n", + "fift": "DICTUSETGETOPTREF", + "fift_examples": [], + "gas": "26", + "opcode": "F46F", + "stack": "c^? i D n - D' ~c^?" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_setget_optref", + "line": 442, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUSETGETOPTREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "c2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F470", + "tlb": "#F470" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_prefix", + "description": "", + "fift": "PFXDICTSET", + "fift_examples": [], + "gas": "26", + "opcode": "F470", + "stack": "x k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_set", + "line": 566, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTSET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F471", + "tlb": "#F471" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_prefix", + "description": "", + "fift": "PFXDICTREPLACE", + "fift_examples": [], + "gas": "26", + "opcode": "F471", + "stack": "x k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_set", + "line": 566, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTREPLACE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F472", + "tlb": "#F472" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_prefix", + "description": "", + "fift": "PFXDICTADD", + "fift_examples": [], + "gas": "26", + "opcode": "F472", + "stack": "x k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_set", + "line": 566, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTADD", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F473", + "tlb": "#F473" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_prefix", + "description": "", + "fift": "PFXDICTDEL", + "fift_examples": [], + "gas": "26", + "opcode": "F473", + "stack": "k D n - D' -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_delete", + "line": 580, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTDEL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F474", + "tlb": "#F474" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "DICTGETNEXT", + "fift_examples": [], + "gas": "26", + "opcode": "F474", + "stack": "k D n - x' k' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETNEXT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F475", + "tlb": "#F475" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETNEXT, but computes the minimal key k' that is lexicographically greater than or equal to k.

\n", + "fift": "DICTGETNEXTEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F475", + "stack": "k D n - x' k' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETNEXTEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F476", + "tlb": "#F476" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETNEXT, but computes the maximal key k' lexicographically smaller than k.

\n", + "fift": "DICTGETPREV", + "fift_examples": [], + "gas": "26", + "opcode": "F476", + "stack": "k D n - x' k' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETPREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F477", + "tlb": "#F477" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETPREV, but computes the maximal key k' lexicographically smaller than or equal to k.

\n", + "fift": "DICTGETPREVEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F477", + "stack": "k D n - x' k' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTGETPREVEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F478", + "tlb": "#F478" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "DICTIGETNEXT", + "fift_examples": [], + "gas": "26", + "opcode": "F478", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETNEXT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F479", + "tlb": "#F479" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETNEXTEQ, but interprets keys as signed n-bit integers.

\n", + "fift": "DICTIGETNEXTEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F479", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETNEXTEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47A", + "tlb": "#F47A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETPREV, but interprets keys as signed n-bit integers.

\n", + "fift": "DICTIGETPREV", + "fift_examples": [], + "gas": "26", + "opcode": "F47A", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETPREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47B", + "tlb": "#F47B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETPREVEQ, but interprets keys as signed n-bit integers.

\n", + "fift": "DICTIGETPREVEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F47B", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETPREVEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47C", + "tlb": "#F47C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "DICTUGETNEXT", + "fift_examples": [], + "gas": "26", + "opcode": "F47C", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETNEXT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47D", + "tlb": "#F47D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETNEXTEQ, but interprets keys as unsigned n-bit integers.

\n", + "fift": "DICTUGETNEXTEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F47D", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETNEXTEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47E", + "tlb": "#F47E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETPREV, but interprets keys as unsigned n-bit integers.

\n", + "fift": "DICTUGETPREV", + "fift_examples": [], + "gas": "26", + "opcode": "F47E", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETPREV", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F47F", + "tlb": "#F47F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_next", + "description": "

Similar to DICTGETPREVEQ, but interprets keys a unsigned n-bit integers.

\n", + "fift": "DICTUGETPREVEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F47F", + "stack": "i D n - x' i' -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getnear", + "line": 523, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETPREVEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F482", + "tlb": "#F482" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F482", + "stack": "D n - x k -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F483", + "tlb": "#F483" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTMIN, but returns the only reference in the value as a Cell c.

\n", + "fift": "DICTMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F483", + "stack": "D n - c k -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F484", + "tlb": "#F484" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F484", + "stack": "D n - x i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F485", + "tlb": "#F485" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTIMIN, but returns the only reference in the value.

\n", + "fift": "DICTIMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F485", + "stack": "D n - c i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F486", + "tlb": "#F486" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTMIN, but returns the key as an unsigned n-bit Integer i.

\n", + "fift": "DICTUMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F486", + "stack": "D n - x i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F487", + "tlb": "#F487" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTUMIN, but returns the only reference in the value.

\n", + "fift": "DICTUMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F487", + "stack": "D n - c i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48A", + "tlb": "#F48A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F48A", + "stack": "D n - x k -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48B", + "tlb": "#F48B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTMAX, but returns the only reference in the value.

\n", + "fift": "DICTMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F48B", + "stack": "D n - c k -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48C", + "tlb": "#F48C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F48C", + "stack": "D n - x i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48D", + "tlb": "#F48D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTIMAX, but returns the only reference in the value.

\n", + "fift": "DICTIMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F48D", + "stack": "D n - c i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48E", + "tlb": "#F48E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTMAX, but returns the key as an unsigned n-bit Integer i.

\n", + "fift": "DICTUMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F48E", + "stack": "D n - x i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F48F", + "tlb": "#F48F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTUMAX, but returns the only reference in the value.

\n", + "fift": "DICTUMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F48F", + "stack": "D n - c i -1 or 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F492", + "tlb": "#F492" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "DICTREMMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F492", + "stack": "D n - D' x k -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREMMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F493", + "tlb": "#F493" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTREMMIN, but returns the only reference in the value as a Cell c.

\n", + "fift": "DICTREMMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F493", + "stack": "D n - D' c k -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREMMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F494", + "tlb": "#F494" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIREMMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F494", + "stack": "D n - D' x i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREMMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F495", + "tlb": "#F495" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTIREMMIN, but returns the only reference in the value.

\n", + "fift": "DICTIREMMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F495", + "stack": "D n - D' c i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREMMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F496", + "tlb": "#F496" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTREMMIN, but returns the key as an unsigned n-bit Integer i.

\n", + "fift": "DICTUREMMIN", + "fift_examples": [], + "gas": "26", + "opcode": "F496", + "stack": "D n - D' x i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREMMIN", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F497", + "tlb": "#F497" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTUREMMIN, but returns the only reference in the value.

\n", + "fift": "DICTUREMMINREF", + "fift_examples": [], + "gas": "26", + "opcode": "F497", + "stack": "D n - D' c i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREMMINREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49A", + "tlb": "#F49A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "DICTREMMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F49A", + "stack": "D n - D' x k -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREMMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49B", + "tlb": "#F49B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTREMMAX, but returns the only reference in the value as a Cell c.

\n", + "fift": "DICTREMMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F49B", + "stack": "D n - D' c k -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTREMMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49C", + "tlb": "#F49C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "DICTIREMMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F49C", + "stack": "D n - D' x i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREMMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49D", + "tlb": "#F49D" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTIREMMAX, but returns the only reference in the value.

\n", + "fift": "DICTIREMMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F49D", + "stack": "D n - D' c i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIREMMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49E", + "tlb": "#F49E" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTREMMAX, but returns the key as an unsigned n-bit Integer i.

\n", + "fift": "DICTUREMMAX", + "fift_examples": [], + "gas": "26", + "opcode": "F49E", + "stack": "D n - D' x i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREMMAX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F49F", + "tlb": "#F49F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_min", + "description": "

Similar to DICTUREMMAX, but returns the only reference in the value.

\n", + "fift": "DICTUREMMAXREF", + "fift_examples": [], + "gas": "26", + "opcode": "F49F", + "stack": "D n - D' c i -1 or D 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_getmin", + "line": 470, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUREMMAXREF", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A0", + "tlb": "#F4A0" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to DICTIGET, but with x BLESSed into a continuation with a subsequent JMPX to it on success. On failure, does nothing. This is useful for implementing switch/case constructions.

\n", + "fift": "DICTIGETJMP", + "fift_examples": [], + "gas": "26", + "opcode": "F4A0", + "stack": "i D n - " + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A1", + "tlb": "#F4A1" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to DICTIGETJMP, but performs DICTUGET instead of DICTIGET.

\n", + "fift": "DICTUGETJMP", + "fift_examples": [], + "gas": "26", + "opcode": "F4A1", + "stack": "i D n - " + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A2", + "tlb": "#F4A2" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to DICTIGETJMP, but with EXECUTE instead of JMPX.

\n", + "fift": "DICTIGETEXEC", + "fift_examples": [], + "gas": "26", + "opcode": "F4A2", + "stack": "i D n - " + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETEXEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A3", + "tlb": "#F4A3" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to DICTUGETJMP, but with EXECUTE instead of JMPX.

\n", + "fift": "DICTUGETEXEC", + "fift_examples": [], + "gas": "26", + "opcode": "F4A3", + "stack": "i D n - " + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETEXEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "size_var": "n", + "type": "dictionary" + } + ], + "name": "d", + "type": "ref" + }, + { + "display_hints": [], + "max_value": 1023, + "min_value": 0, + "name": "n", + "size": 10, + "type": "uint" + } + ], + "prefix": "F4A6_", + "tlb": "#F4A6_ d:^Cell n:uint10" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[ref] [n] DICTPUSHCONST", + "fift_examples": [], + "gas": "34", + "opcode": "F4A6_n", + "stack": " - D n" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_push_const_dict", + "line": 620, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTPUSHCONST", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A8", + "tlb": "#F4A8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "PFXDICTGETQ", + "fift_examples": [], + "gas": "26", + "opcode": "F4A8", + "stack": "s D n - s' x s'' -1 or s 0" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_get", + "line": 658, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTGETQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4A9", + "tlb": "#F4A9" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "dict_special", + "description": "

Similar to PFXDICTGET, but throws a cell deserialization failure exception on failure.

\n", + "fift": "PFXDICTGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4A9", + "stack": "s D n - s' x s''" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_get", + "line": 658, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4AA", + "tlb": "#F4AA" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to PFXDICTGETQ, but on success BLESSes the value x into a Continuation and transfers control to it as if by a JMPX. On failure, returns s unchanged and continues execution.

\n", + "fift": "PFXDICTGETJMP", + "fift_examples": [], + "gas": "26", + "opcode": "F4AA", + "stack": "s D n - s' s'' or s" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_get", + "line": 658, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTGETJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4AB", + "tlb": "#F4AB" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Similar to PFXDICTGETJMP, but EXECutes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.

\n", + "fift": "PFXDICTGETEXEC", + "fift_examples": [], + "gas": "26", + "opcode": "F4AB", + "stack": "s D n - s' s''" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_pfx_dict_get", + "line": 658, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTGETEXEC", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "size_var": "n", + "type": "dictionary" + } + ], + "name": "d", + "type": "ref" + }, + { + "display_hints": [], + "max_value": 1023, + "min_value": 0, + "name": "n", + "size": 10, + "type": "uint" + } + ], + "prefix": "F4AE_", + "tlb": "#F4AE_ d:^Cell n:uint10" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

Combines [n] DICTPUSHCONST for 0 <= n <= 1023 with PFXDICTGETJMP.

\n", + "fift": "[ref] [n] PFXDICTCONSTGETJMP\n[ref] [n] PFXDICTSWITCH", + "fift_examples": [], + "gas": "34", + "opcode": "F4AE_n", + "stack": "s - s' s'' or s" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_const_pfx_dict_switch", + "line": 692, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "PFXDICTCONSTGETJMP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4BC", + "tlb": "#F4BC" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

A variant of DICTIGETJMP that returns index i on failure.

\n", + "fift": "DICTIGETJMPZ", + "fift_examples": [], + "gas": "26", + "opcode": "F4BC", + "stack": "i D n - i or nothing" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETJMPZ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4BD", + "tlb": "#F4BD" + }, + "control_flow": { + "branches": [ + { + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

A variant of DICTUGETJMP that returns index i on failure.

\n", + "fift": "DICTUGETJMPZ", + "fift_examples": [], + "gas": "26", + "opcode": "F4BD", + "stack": "i D n - i or nothing" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETJMPZ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4BE", + "tlb": "#F4BE" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

A variant of DICTIGETEXEC that returns index i on failure.

\n", + "fift": "DICTIGETEXECZ", + "fift_examples": [], + "gas": "26", + "opcode": "F4BE", + "stack": "i D n - i or nothing" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTIGETEXECZ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4BF", + "tlb": "#F4BF" + }, + "control_flow": { + "branches": [ + { + "save": { + "c0": { + "save": { + "c0": { + "index": 0, + "type": "register" + } + }, + "type": "cc" + } + }, + "type": "variable", + "var_name": "x" + } + ], + "nobranch": false + }, + "doc": { + "category": "dict_special", + "description": "

A variant of DICTUGETEXEC that returns index i on failure.

\n", + "fift": "DICTUGETEXECZ", + "fift_examples": [], + "gas": "26", + "opcode": "F4BF", + "stack": "i D n - i or nothing" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_dict_get_exec", + "line": 593, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "DICTUGETEXECZ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [] + }, + "outputs": { + "registers": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B1", + "tlb": "#F4B1" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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'.

\n", + "fift": "SUBDICTGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B1", + "stack": "k l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B2", + "tlb": "#F4B2" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SUBDICTIGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B2", + "stack": "x l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTIGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B3", + "tlb": "#F4B3" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SUBDICTUGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B3", + "stack": "x l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTUGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B5", + "tlb": "#F4B5" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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).

\n", + "fift": "SUBDICTRPGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B5", + "stack": "k l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTRPGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B6", + "tlb": "#F4B6" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SUBDICTIRPGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B6", + "stack": "x l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTIRPGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F4B7", + "tlb": "#F4B7" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SUBDICTURPGET", + "fift_examples": [], + "gas": "26", + "opcode": "F4B7", + "stack": "x l D n - D'" + }, + "implementation": [ + { + "file": "dictops.cpp", + "function_name": "exec_subdict_get", + "line": 722, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/dictops.cpp" + } + ], + "mnemonic": "SUBDICTURPGET", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "l", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "D2", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F800", + "tlb": "#F800" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "ACCEPT", + "fift_examples": [], + "gas": "26", + "opcode": "F800", + "stack": "-" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_accept", + "line": 81, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "ACCEPT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "name": "gas", + "type": "special" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "name": "gas", + "type": "special" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F801", + "tlb": "#F801" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETGASLIMIT", + "fift_examples": [], + "gas": "26", + "opcode": "F801", + "stack": "g - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_gas_limit", + "line": 86, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETGASLIMIT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "name": "gas", + "type": "special" + } + ], + "stack": [ + { + "name": "g", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "name": "gas", + "type": "special" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F807", + "tlb": "#F807" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_gas", + "description": "

Returns gas consumed by VM so far (including this instruction).

\n", + "fift": "GASCONSUMED", + "fift_examples": [], + "gas": "26", + "opcode": "F807", + "stack": "- g_c" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_gas_consumed", + "line": 96, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GASCONSUMED", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [ + { + "name": "gas", + "type": "special" + } + ], + "stack": [ + { + "name": "g_c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F80F", + "tlb": "#F80F" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_gas", + "description": "

Commits the current state of registers c4 (''persistent data'') and c5 (''actions'') so that the current execution is considered ''successful'' with the saved values even if an exception is thrown later.

\n", + "fift": "COMMIT", + "fift_examples": [], + "gas": "26", + "opcode": "F80F", + "stack": "-" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_commit", + "line": 102, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "COMMIT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 4, + "type": "constant" + }, + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "name": "cstate", + "type": "special" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F810", + "tlb": "#F810" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "RANDU256", + "fift_examples": [], + "gas": "26+|c7|+|c1_1|", + "opcode": "F810", + "stack": "- x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_randu256", + "line": 542, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RANDU256", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F811", + "tlb": "#F811" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "RAND", + "fift_examples": [], + "gas": "26+|c7|+|c1_1|", + "opcode": "F811", + "stack": "y - z" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_rand_int", + "line": 548, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RAND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F814", + "tlb": "#F814" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_rnd", + "description": "

Sets the random seed to unsigned 256-bit Integer x.

\n", + "fift": "SETRAND", + "fift_examples": [], + "gas": "26+|c7|+|c1_1|", + "opcode": "F814", + "stack": "x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_rand", + "line": 561, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETRAND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F815", + "tlb": "#F815" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "ADDRAND\nRANDOMIZE", + "fift_examples": [], + "gas": "26", + "opcode": "F815", + "stack": "x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_rand", + "line": 561, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "ADDRAND", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "F82", + "tlb": "#F82 i:uint4" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[i] GETPARAM", + "fift_examples": [], + "gas": "26", + "opcode": "F82i", + "stack": " - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_var_param", + "line": 152, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETPARAM", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F830", + "tlb": "#F830" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Returns the global configuration dictionary along with its key length (32).\nEquivalent to CONFIGROOT 32 PUSHINT.

\n", + "fift": "CONFIGDICT", + "fift_examples": [], + "gas": "26", + "opcode": "F830", + "stack": " - D 32" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_config_dict", + "line": 182, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CONFIGDICT", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "type": "const", + "value": 32, + "value_type": "Integer" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F832", + "tlb": "#F832" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CONFIGPARAM", + "fift_examples": [], + "gas": "26", + "opcode": "F832", + "stack": "i - c -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_config_param", + "line": 188, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CONFIGPARAM", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F833", + "tlb": "#F833" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CONFIGOPTPARAM", + "fift_examples": [], + "gas": "26", + "opcode": "F833", + "stack": "i - c^?" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_config_param", + "line": 188, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CONFIGOPTPARAM", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83400", + "tlb": "#F83400" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Retrives last_mc_blocks part of PrevBlocksInfo from c7 (parameter 13).

\n", + "fift": "PREVMCBLOCKS", + "fift_examples": [], + "gas": "34", + "opcode": "F83400", + "stack": "- t" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_prev_blocks_info", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "PREVMCBLOCKS", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83401", + "tlb": "#F83401" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Retrives prev_key_block part of PrevBlocksInfo from c7 (parameter 13).

\n", + "fift": "PREVKEYBLOCK", + "fift_examples": [], + "gas": "34", + "opcode": "F83401", + "stack": "- t" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_prev_blocks_info", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "PREVKEYBLOCK", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83402", + "tlb": "#F83402" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Retrives last_mc_blocks_divisible_by_100 part of PrevBlocksInfo from c7 (parameter 13).

\n", + "fift": "PREVMCBLOCKS_100", + "fift_examples": [], + "gas": "34", + "opcode": "F83402", + "stack": "- t" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_prev_blocks_info", + "line": 259, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "PREVMCBLOCKS_100", + "since_version": 9, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F835", + "tlb": "#F835" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Retrieves global_id from 19 network config.

\n", + "fift": "GLOBALID", + "fift_examples": [], + "gas": "26", + "opcode": "F835", + "stack": "- i" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_global_id", + "line": 276, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GLOBALID", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "i", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F836", + "tlb": "#F836" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Calculates gas fee

\n", + "fift": "GETGASFEE", + "fift_examples": [], + "gas": "26", + "opcode": "F836", + "stack": "gas_used is_mc - price" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_gas_fee", + "line": 306, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETGASFEE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "gas_used", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "price", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F837", + "tlb": "#F837" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Calculates storage fees (only current StoragePrices entry is used).

\n", + "fift": "GETSTORAGEFEE", + "fift_examples": [], + "gas": "26", + "opcode": "F837", + "stack": "cells bits seconds is_mc - price" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_storage_fee", + "line": 317, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETSTORAGEFEE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "cells", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "bits", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "seconds", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "price", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F838", + "tlb": "#F838" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Calculates forward fee.

\n", + "fift": "GETFORWARDFEE", + "fift_examples": [], + "gas": "26", + "opcode": "F838", + "stack": "cells bits is_mc - price" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_forward_fee", + "line": 331, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETFORWARDFEE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "cells", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "bits", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "price", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F839", + "tlb": "#F839" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Returns gas usage for the current contract if it is precompiled, null otherwise.

\n", + "fift": "GETPRECOMPILEDGAS", + "fift_examples": [], + "gas": "26", + "opcode": "F839", + "stack": "- x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_precompiled_gas", + "line": 343, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETPRECOMPILEDGAS", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83A", + "tlb": "#F83A" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Calculate (fwd_fee * 2^16) / (2^16 - first_frac). Can be used to get the original fwd_fee of the message.

\n", + "fift": "GETORIGINALFWDFEE", + "fift_examples": [], + "gas": "26", + "opcode": "F83A", + "stack": "fwd_fee is_mc - orig_fwd_fee" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_original_fwd_fee", + "line": 350, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETORIGINALFWDFEE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "fwd_fee", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "orig_fwd_fee", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83B", + "tlb": "#F83B" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Same as GETGASFEE, but without flat price (just (gas_used * price) / 2^16).

\n", + "fift": "GETGASFEESIMPLE", + "fift_examples": [], + "gas": "26", + "opcode": "F83B", + "stack": "gas_used is_mc - price" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_gas_fee_simple", + "line": 364, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETGASFEESIMPLE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "gas_used", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "price", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F83C", + "tlb": "#F83C" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Same as GETFORWARDFEE, but without lump price (just (bits*bit_price + cells*cell_price) / 2^16).

\n", + "fift": "GETFORWARDFEESIMPLE", + "fift_examples": [], + "gas": "26", + "opcode": "F83C", + "stack": "cells bits is_mc - price" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_forward_fee_simple", + "line": 375, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETFORWARDFEESIMPLE", + "since_version": 6, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "cells", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "bits", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "is_mc", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "price", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F840", + "tlb": "#F840" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_global", + "description": "

Returns the k-th global variable for 0 <= k < 255.\nEquivalent to c7 PUSHCTR SWAP INDEXVARQ.

\n", + "fift": "GETGLOBVAR", + "fift_examples": [], + "gas": "26", + "opcode": "F840", + "stack": "k - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_global_var", + "line": 221, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETGLOBVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 1, + "name": "k", + "size": 5, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 5, + "to": 31 + }, + "prefix": "F85_", + "tlb": "#F85_ k:(## 5) {1 <= k}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_global", + "description": "

Returns the k-th global variable for 1 <= k <= 31.\nEquivalent to c7 PUSHCTR [k] INDEXQ.

\n", + "fift": "[k] GETGLOB", + "fift_examples": [], + "gas": "26", + "opcode": "F85_k", + "stack": " - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_global", + "line": 215, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETGLOB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F860", + "tlb": "#F860" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETGLOBVAR", + "fift_examples": [], + "gas": "26+|c7'|", + "opcode": "F860", + "stack": "x k - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_global_var", + "line": 252, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETGLOBVAR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple" + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 31, + "min_value": 1, + "name": "k", + "size": 5, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 5, + "to": 31 + }, + "prefix": "F87_", + "tlb": "#F87_ k:(## 5) {1 <= k}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[k] SETGLOB", + "fift_examples": [], + "gas": "26+|c7'|", + "opcode": "F87_k", + "stack": "x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_global", + "line": 245, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETGLOB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple" + } + ] + }, + "outputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F880", + "tlb": "#F880" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_global", + "description": "

Takes id of the extra currency (integer in range 0..2^32-1), returns the amount of this extra currency on the account balance. The first 5 executions of GETEXTRABALANCE consume at most 26 + 200 gas each. The subsequent executions incur the full gas cost of 26 (normal instruction cost) plus gas for loading cells (up to 3300 if the dictionary has maximum depth).

\n", + "fift": "GETEXTRABALANCE", + "fift_examples": [], + "gas": "26", + "opcode": "F880", + "stack": "id - amount" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_extra_currency_balance", + "line": 388, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETEXTRABALANCE", + "since_version": 10, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [ + { + "name": "id", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "amount", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 255, + "min_value": 0, + "name": "i", + "size": 8, + "type": "uint" + } + ], + "prefix": "F881", + "tlb": "#F881 i:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Returns the i-th parameter from the Tuple provided at c7 for 0 <= i <= 255. Equivalent to c7 PUSHCTR FIRST [i] INDEX.\nIf one of these internal operations fails, throws an appropriate type checking or range checking exception.

\n", + "fift": "[i] GETPARAMLONG", + "fift_examples": [], + "gas": "34", + "opcode": "F881ii", + "stack": " - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_var_param_long", + "line": 158, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "GETPARAMLONG", + "since_version": 11, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + } + ], + "prefix": "F89", + "tlb": "#F89 i:uint8" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_config", + "description": "

Equivalent to INMSGPARAMS i INDEX

\n", + "fift": "[i] INMSGPARAM", + "fift_examples": [], + "gas": "26", + "opcode": "F89i", + "stack": " - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_get_var_in_msg_param", + "line": 176, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "INMSGPARAM", + "since_version": 11, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 7, + "type": "constant" + } + ], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F900", + "tlb": "#F900" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "HASHCU", + "fift_examples": [], + "gas": "26", + "opcode": "F900", + "stack": "c - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_hash", + "line": 612, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHCU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F901", + "tlb": "#F901" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "HASHSU", + "fift_examples": [], + "gas": "526", + "opcode": "F901", + "stack": "s - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_hash", + "line": 612, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHSU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F902", + "tlb": "#F902" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SHA256U", + "fift_examples": [], + "gas": "26", + "opcode": "F902", + "stack": "s - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_sha256", + "line": 634, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SHA256U", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90400", + "tlb": "#F90400" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXT_SHA256", + "fift_examples": [], + "gas": "1/33 gas per byte", + "opcode": "F90400", + "stack": "s_1 ... s_n n - h" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXT_SHA256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90401", + "tlb": "#F90401" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXT_SHA512", + "fift_examples": [], + "gas": "1/16 gas per byte", + "opcode": "F90401", + "stack": "s_1 ... s_n n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXT_SHA512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90402", + "tlb": "#F90402" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXT_BLAKE2B", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90402", + "stack": "s_1 ... s_n n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXT_BLAKE2B", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90403", + "tlb": "#F90403" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXT_KECCAK256", + "fift_examples": [], + "gas": "1/11 gas per byte", + "opcode": "F90403", + "stack": "s_1 ... s_n n - h" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXT_KECCAK256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90404", + "tlb": "#F90404" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXT_KECCAK512", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90404", + "stack": "s_1 ... s_n n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXT_KECCAK512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90500", + "tlb": "#F90500" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXTR_SHA256", + "fift_examples": [], + "gas": "1/33 gas per byte", + "opcode": "F90500", + "stack": "s_n ... s_1 n - h" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTR_SHA256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90501", + "tlb": "#F90501" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXTR_SHA512", + "fift_examples": [], + "gas": "1/16 gas per byte", + "opcode": "F90501", + "stack": "s_n ... s_1 n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTR_SHA512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90502", + "tlb": "#F90502" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXTR_BLAKE2B", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90502", + "stack": "s_n ... s_1 n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTR_BLAKE2B", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90503", + "tlb": "#F90503" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXTR_KECCAK256", + "fift_examples": [], + "gas": "1/11 gas per byte", + "opcode": "F90503", + "stack": "s_n ... s_1 n - h" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTR_KECCAK256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90504", + "tlb": "#F90504" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates and returns hash of the concatenation of slices (or builders) s_1...s_n.

\n", + "fift": "HASHEXTR_KECCAK512", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90504", + "stack": "s_n ... s_1 n - h1 h2" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTR_KECCAK512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90600", + "tlb": "#F90600" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTA_SHA256", + "fift_examples": [], + "gas": "1/33 gas per byte", + "opcode": "F90600", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTA_SHA256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90601", + "tlb": "#F90601" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTA_SHA512", + "fift_examples": [], + "gas": "1/16 gas per byte", + "opcode": "F90601", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTA_SHA512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90602", + "tlb": "#F90602" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTA_BLAKE2B", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90602", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTA_BLAKE2B", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90603", + "tlb": "#F90603" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTA_KECCAK256", + "fift_examples": [], + "gas": "1/11 gas per byte", + "opcode": "F90603", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTA_KECCAK256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90604", + "tlb": "#F90604" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTA_KECCAK512", + "fift_examples": [], + "gas": "1/6 gas per byte", + "opcode": "F90604", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTA_KECCAK512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90700", + "tlb": "#F90700" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTAR_SHA256", + "fift_examples": [], + "gas": "1/33 gas per byte", + "opcode": "F90700", + "stack": "b s_1 ... s_n n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTAR_SHA256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90701", + "tlb": "#F90701" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTAR_SHA512", + "fift_examples": [], + "gas": "1/16 gas per byte", + "opcode": "F90701", + "stack": "b s_n ... s_1 n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTAR_SHA512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90702", + "tlb": "#F90702" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTAR_BLAKE2B", + "fift_examples": [], + "gas": "1/19 gas per byte", + "opcode": "F90702", + "stack": "b s_n ... s_1 n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTAR_BLAKE2B", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90703", + "tlb": "#F90703" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTAR_KECCAK256", + "fift_examples": [], + "gas": "1/11 gas per byte", + "opcode": "F90703", + "stack": "b s_n ... s_1 n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTAR_KECCAK256", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F90704", + "tlb": "#F90704" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates hash of the concatenation of slices (or builders) s_1...s_n. Appends the resulting hash to a builder b.

\n", + "fift": "HASHEXTAR_KECCAK512", + "fift_examples": [], + "gas": "1/6 gas per byte", + "opcode": "F90704", + "stack": "b s_n ... s_1 n - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_hash_ext", + "line": 652, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHEXTAR_KECCAK512", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "array_entry": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Builder" + ] + } + ], + "length_var": "n", + "name": "input_parts", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F910", + "tlb": "#F910" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CHKSIGNU", + "fift_examples": [], + "gas": "26", + "opcode": "F910", + "stack": "h s k - ?" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ed25519_check_signature", + "line": 724, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CHKSIGNU", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F911", + "tlb": "#F911" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CHKSIGNS", + "fift_examples": [], + "gas": "26", + "opcode": "F911", + "stack": "d s k - ?" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ed25519_check_signature", + "line": 724, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CHKSIGNS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "d", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F912", + "tlb": "#F912" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Recovers the public key from a secp256k1 signature, identical to Bitcoin/Ethereum operations. Takes a 32-byte hash as uint256 hash and a 65-byte signature as uint8 v, uint256 r, and uint256 s. In TON, the v value is strictly 0 or 1; no extra flags or extended values are supported. If the public key cannot be recovered, the instruction returns 0. On success, it returns the recovered 65-byte public key as uint8 h, uint256 x1, and uint256 x2, followed by -1.

\n", + "fift": "ECRECOVER", + "fift_examples": [], + "gas": "1526", + "opcode": "F912", + "stack": "hash v r s - 0 or h x1 x2 -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ecrecover", + "line": 760, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "ECRECOVER", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "hash", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "v", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "r", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F913", + "tlb": "#F913" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

performs secp256k1_xonly_pubkey_tweak_add. key and tweak are 256-bit unsigned integers. 65-byte public key is returned as uint8 f, uint256 x, y (as in ECRECOVER).

\n", + "fift": "SECP256K1_XONLY_PUBKEY_TWEAK_ADD", + "fift_examples": [], + "gas": "1576", + "opcode": "F913", + "stack": "key tweak - 0 or f x y -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_secp256k1_xonly_pubkey_tweak_add", + "line": 798, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SECP256K1_XONLY_PUBKEY_TWEAK_ADD", + "since_version": 9, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "key", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "tweak", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F914", + "tlb": "#F914" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks seck256r1-signature sig of a number h (a 256-bit unsigned integer, usually computed as the hash of some data) and public key k. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature sig is a 64-byte slice (two 256-bit unsigned integers r and s).

\n", + "fift": "P256_CHKSIGNU", + "fift_examples": [], + "gas": "3526", + "opcode": "F914", + "stack": "h sig k - ?" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_p256_chksign", + "line": 829, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "P256_CHKSIGNU", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "d", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "sig", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F915", + "tlb": "#F915" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks seck256r1-signature sig of data portion of slice d and public key k. Returns -1 on success, 0 on failure. Public key is a 33-byte slice (encoded according to Sec. 2.3.4 point 2 of SECG SEC 1). Signature sig is a 64-byte slice (two 256-bit unsigned integers r and s).

\n", + "fift": "P256_CHKSIGNS", + "fift_examples": [], + "gas": "3526", + "opcode": "F915", + "stack": "d sig k - ?" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_p256_chksign", + "line": 829, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "P256_CHKSIGNS", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "d", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "sig", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "k", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F916", + "tlb": "#F916" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Same as ENDC HASHCU, but without gas cost for cell creation.

\n", + "fift": "HASHBU", + "fift_examples": [], + "gas": "26", + "opcode": "F916", + "stack": "b - hash" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_hash", + "line": 612, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "HASHBU", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "hash", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F920", + "tlb": "#F920" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Deterministically generates a valid point x from a 512-bit hash (given as two 256-bit integers).

\n", + "fift": "RIST255_FROMHASH", + "fift_examples": [], + "gas": "626", + "opcode": "F920", + "stack": "h1 h2 - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_from_hash", + "line": 874, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_FROMHASH", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "h1", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "h2", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F921", + "tlb": "#F921" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that integer x is a valid representation of some curve point. Throws range_chk on error.

\n", + "fift": "RIST255_VALIDATE", + "fift_examples": [], + "gas": "226", + "opcode": "F921", + "stack": "x -" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_validate", + "line": 895, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_VALIDATE", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F922", + "tlb": "#F922" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Addition of two points on a curve.

\n", + "fift": "RIST255_ADD", + "fift_examples": [], + "gas": "626", + "opcode": "F922", + "stack": "x y - x+y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_add", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_ADD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F923", + "tlb": "#F923" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Subtraction of two points on curve.

\n", + "fift": "RIST255_SUB", + "fift_examples": [], + "gas": "626", + "opcode": "F923", + "stack": "x y - x-y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_sub", + "line": 938, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_SUB", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F924", + "tlb": "#F924" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies point x by a scalar n. Any n is valid, including negative.

\n", + "fift": "RIST255_MUL", + "fift_examples": [], + "gas": "2026", + "opcode": "F924", + "stack": "x n - x*n" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_mul", + "line": 976, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_MUL", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F925", + "tlb": "#F925" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies the generator point g by a scalar n. Any n is valid, including negative.

\n", + "fift": "RIST255_MULBASE", + "fift_examples": [], + "gas": "776", + "opcode": "F925", + "stack": "n - g*n" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_mul_base", + "line": 1007, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_MULBASE", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F926", + "tlb": "#F926" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Pushes integer l=2^252+27742317777372353535851937790883648493, which is the order of the group.

\n", + "fift": "RIST255_PUSHL", + "fift_examples": [], + "gas": "26", + "opcode": "F926", + "stack": "- l" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_push_l", + "line": 1032, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_PUSHL", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7F921", + "tlb": "#B7F921" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that integer x is a valid representation of some curve point. Returns -1 on success and 0 on failure.

\n", + "fift": "RIST255_QVALIDATE", + "fift_examples": [], + "gas": "234", + "opcode": "B7F921", + "stack": "x - 0 or -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_validate", + "line": 895, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_QVALIDATE", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7F922", + "tlb": "#B7F922" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Addition of two points on a curve. Returns -1 on success and 0 on failure.

\n", + "fift": "RIST255_QADD", + "fift_examples": [], + "gas": "634", + "opcode": "B7F922", + "stack": "x y - 0 or x+y -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_add", + "line": 914, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_QADD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7F923", + "tlb": "#B7F923" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Subtraction of two points on curve. Returns -1 on success and 0 on failure.

\n", + "fift": "RIST255_QSUB", + "fift_examples": [], + "gas": "634", + "opcode": "B7F923", + "stack": "x y - 0 or x-y -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_sub", + "line": 938, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_QSUB", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7F924", + "tlb": "#B7F924" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies point x by a scalar n. Any n is valid, including negative. Returns -1 on success and 0 on failure.

\n", + "fift": "RIST255_QMUL", + "fift_examples": [], + "gas": "2034", + "opcode": "B7F924", + "stack": "x n - 0 or x*n -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_mul", + "line": 976, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_QMUL", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "B7F925", + "tlb": "#B7F925" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies the generator point g by a scalar n. Any n is valid, including negative.

\n", + "fift": "RIST255_QMULBASE", + "fift_examples": [], + "gas": "784", + "opcode": "B7F925", + "stack": "n - 0 or g*n -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_ristretto255_mul_base", + "line": 1007, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RIST255_QMULBASE", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93000", + "tlb": "#F93000" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks BLS signature, return true on success, false otherwise.

\n", + "fift": "BLS_VERIFY", + "fift_examples": [], + "gas": "61034", + "opcode": "F93000", + "stack": "pk msg sgn - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_verify", + "line": 1095, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_VERIFY", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "pk", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "msg", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "sgn", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93001", + "tlb": "#F93001" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Aggregates signatures. n>0. Throw exception if n=0 or if some sig_i is not a valid signature.

\n", + "fift": "BLS_AGGREGATE", + "fift_examples": [], + "gas": "n*4350-2616", + "opcode": "F93001", + "stack": "sig_1 ... sig_n n - sig" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_aggregate", + "line": 1107, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_AGGREGATE", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "sig", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "length_var": "n", + "name": "signatures", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93002", + "tlb": "#F93002" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks aggregated BLS signature for keys pk_1...pk_n and message msg. Return true on success, false otherwise. Return false if n=0.

\n", + "fift": "BLS_FASTAGGREGATEVERIFY", + "fift_examples": [], + "gas": "58034+n*3000", + "opcode": "F93002", + "stack": "pk_1 ... pk_n n msg sig - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_fast_aggregate_verify", + "line": 1121, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_FASTAGGREGATEVERIFY", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "pk", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "length_var": "n", + "name": "public_keys", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "msg", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "sig", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93003", + "tlb": "#F93003" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks aggregated BLS signature for key-message pairs pk_1 msg_1...pk_n msg_n. Return true on success, false otherwise. Return false if n=0.

\n", + "fift": "BLS_AGGREGATEVERIFY", + "fift_examples": [], + "gas": "38534+n*22500", + "opcode": "F93003", + "stack": "pk_1 msg_1 ... pk_n msg_n n sgn - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_aggregate_verify", + "line": 1138, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_AGGREGATEVERIFY", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "pk", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "msg", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "length_var": "n", + "name": "key_message_pairs", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "sgn", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93010", + "tlb": "#F93010" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Addition on G1.

\n", + "fift": "BLS_G1_ADD", + "fift_examples": [], + "gas": "3934", + "opcode": "F93010", + "stack": "x y - x+y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_add", + "line": 1155, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_ADD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93011", + "tlb": "#F93011" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Subtraction on G1.

\n", + "fift": "BLS_G1_SUB", + "fift_examples": [], + "gas": "3934", + "opcode": "F93011", + "stack": "x y - x-y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_sub", + "line": 1166, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_SUB", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93012", + "tlb": "#F93012" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Negation on G1.

\n", + "fift": "BLS_G1_NEG", + "fift_examples": [], + "gas": "784", + "opcode": "F93012", + "stack": "x - -x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_neg", + "line": 1177, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_NEG", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93013", + "tlb": "#F93013" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies G1 point x by scalar s. Any s is valid, including negative.

\n", + "fift": "BLS_G1_MUL", + "fift_examples": [], + "gas": "5234", + "opcode": "F93013", + "stack": "x s - x*s" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_mul", + "line": 1186, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_MUL", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93014", + "tlb": "#F93014" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates x_1*s_1+...+x_n*s_n for G1 points x_i and scalars s_i. Returns zero point if n=0. Any s_i is valid, including negative.

\n", + "fift": "BLS_G1_MULTIEXP", + "fift_examples": [], + "gas": "11409+n*630+n/floor(max(log2(n),4))*8820", + "opcode": "F93014", + "stack": "x_1 s_1 ... x_n s_n n - x_1*s_1+...+x_n*s_n" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_multiexp", + "line": 1197, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_MULTIEXP", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "length_var": "n", + "name": "components", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93015", + "tlb": "#F93015" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Pushes zero point in G1.

\n", + "fift": "BLS_G1_ZERO", + "fift_examples": [], + "gas": "34", + "opcode": "F93015", + "stack": "- zero" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_zero", + "line": 1213, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_ZERO", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "zero", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93016", + "tlb": "#F93016" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Converts FP element f to a G1 point.

\n", + "fift": "BLS_MAP_TO_G1", + "fift_examples": [], + "gas": "2384", + "opcode": "F93016", + "stack": "f - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_map_to_g1", + "line": 1220, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_MAP_TO_G1", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93017", + "tlb": "#F93017" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that slice x represents a valid element of G1.

\n", + "fift": "BLS_G1_INGROUP", + "fift_examples": [], + "gas": "2984", + "opcode": "F93017", + "stack": "x - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_in_group", + "line": 1229, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_INGROUP", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93018", + "tlb": "#F93018" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that G1 point x is equal to zero.

\n", + "fift": "BLS_G1_ISZERO", + "fift_examples": [], + "gas": "34", + "opcode": "F93018", + "stack": "x - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g1_is_zero", + "line": 1238, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G1_ISZERO", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93020", + "tlb": "#F93020" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Addition on G2.

\n", + "fift": "BLS_G2_ADD", + "fift_examples": [], + "gas": "6134", + "opcode": "F93020", + "stack": "x y - x+y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_add", + "line": 1246, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_ADD", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93021", + "tlb": "#F93021" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Subtraction on G2.

\n", + "fift": "BLS_G2_SUB", + "fift_examples": [], + "gas": "6134", + "opcode": "F93021", + "stack": "x y - x-y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_sub", + "line": 1257, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_SUB", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93022", + "tlb": "#F93022" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Negation on G2.

\n", + "fift": "BLS_G2_NEG", + "fift_examples": [], + "gas": "1584", + "opcode": "F93022", + "stack": "x - -x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_neg", + "line": 1268, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_NEG", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93023", + "tlb": "#F93023" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Multiplies G2 point x by scalar s. Any s is valid, including negative.

\n", + "fift": "BLS_G2_MUL", + "fift_examples": [], + "gas": "10584", + "opcode": "F93023", + "stack": "x s - x*s" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_mul", + "line": 1277, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_MUL", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93024", + "tlb": "#F93024" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Calculates x_1*s_1+...+x_n*s_n for G2 points x_i and scalars s_i. Returns zero point if n=0. Any s_i is valid, including negative.

\n", + "fift": "BLS_G2_MULTIEXP", + "fift_examples": [], + "gas": "30422+n*1280+n/floor(max(log2(n),4))*22840", + "opcode": "F93024", + "stack": "x_1 s_1 ... x_n s_n n - x_1*s_1+...+x_n*s_n" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_multiexp", + "line": 1288, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_MULTIEXP", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "length_var": "n", + "name": "components", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93025", + "tlb": "#F93025" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Pushes zero point in G2.

\n", + "fift": "BLS_G2_ZERO", + "fift_examples": [], + "gas": "34", + "opcode": "F93025", + "stack": "- zero" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_zero", + "line": 1304, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_ZERO", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "zero", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93026", + "tlb": "#F93026" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Converts FP2 element f to a G2 point.

\n", + "fift": "BLS_MAP_TO_G2", + "fift_examples": [], + "gas": "7984", + "opcode": "F93026", + "stack": "f - x" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_map_to_g2", + "line": 1311, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_MAP_TO_G2", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "f", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93027", + "tlb": "#F93027" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that slice x represents a valid element of G2.

\n", + "fift": "BLS_G2_INGROUP", + "fift_examples": [], + "gas": "4284", + "opcode": "F93027", + "stack": "x - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_in_group", + "line": 1320, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_INGROUP", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93028", + "tlb": "#F93028" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Checks that G2 point x is equal to zero.

\n", + "fift": "BLS_G2_ISZERO", + "fift_examples": [], + "gas": "34", + "opcode": "F93028", + "stack": "x - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_g2_is_zero", + "line": 1329, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_G2_ISZERO", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93030", + "tlb": "#F93030" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Given G1 points x_i and G2 points y_i, calculates and multiply pairings of x_i,y_i. Returns true if the result is the multiplicative identity in FP12, false otherwise. Returns false if n=0.

\n", + "fift": "BLS_PAIRING", + "fift_examples": [], + "gas": "20034+n*11800", + "opcode": "F93030", + "stack": "x_1 y_1 ... x_n y_n n - bool" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_pairing", + "line": 1337, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_PAIRING", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "array_entry": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "length_var": "n", + "name": "components", + "type": "array" + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F93031", + "tlb": "#F93031" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_crypto", + "description": "

Pushes the order of G1 and G2 (approx. 2^255).

\n", + "fift": "BLS_PUSHR", + "fift_examples": [], + "gas": "34", + "opcode": "F93031", + "stack": "- r" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_bls_push_r", + "line": 1351, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "BLS_PUSHR", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "result", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F940", + "tlb": "#F940" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CDATASIZEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F940", + "stack": "c n - x y z -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_data_size", + "line": 1415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CDATASIZEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F941", + "tlb": "#F941" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_misc", + "description": "

A non-quiet version of CDATASIZEQ that throws a cell overflow exception (8) on failure.

\n", + "fift": "CDATASIZE", + "fift_examples": [], + "gas": "26", + "opcode": "F941", + "stack": "c n - x y z" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_data_size", + "line": 1415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CDATASIZE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F942", + "tlb": "#F942" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SDATASIZEQ", + "fift_examples": [], + "gas": "26", + "opcode": "F942", + "stack": "s n - x y z -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_data_size", + "line": 1415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SDATASIZEQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "F943", + "tlb": "#F943" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_misc", + "description": "

A non-quiet version of SDATASIZEQ that throws a cell overflow exception (8) on failure.

\n", + "fift": "SDATASIZE", + "fift_examples": [], + "gas": "26", + "opcode": "F943", + "stack": "s n - x y z" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_compute_data_size", + "line": 1415, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SDATASIZE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "n", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "z", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA00", + "tlb": "#FA00" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDGRAMS\nLDVARUINT16", + "fift_examples": [], + "gas": "26", + "opcode": "FA00", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_var_integer", + "line": 1453, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDGRAMS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA01", + "tlb": "#FA01" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Similar to LDVARUINT16, but loads a signed Integer x.\nApproximately equivalent to 4 LDU SWAP 3 LSHIFT# LDIX.

\n", + "fift": "LDVARINT16", + "fift_examples": [], + "gas": "26", + "opcode": "FA01", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_var_integer", + "line": 1453, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDVARINT16", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA02", + "tlb": "#FA02" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "STGRAMS\nSTVARUINT16", + "fift_examples": [], + "gas": "26", + "opcode": "FA02", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_var_integer", + "line": 1474, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STGRAMS", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA03", + "tlb": "#FA03" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Similar to STVARUINT16, but serializes a signed Integer x in the range -2^119...2^119-1.

\n", + "fift": "STVARINT16", + "fift_examples": [], + "gas": "26", + "opcode": "FA03", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_var_integer", + "line": 1474, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STVARINT16", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA04", + "tlb": "#FA04" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Loads (deserializes) a VarUInteger 32 amount from Slice s, and returns the amount as Integer x along with the remainder s' of s. The expected serialization of x consists of a 5-bit unsigned big-endian integer l, followed by an 8l-bit unsigned big-endian representation of x.\nThe net effect is approximately equivalent to 4 LDU SWAP 3 LSHIFT# LDUX.

\n", + "fift": "LDVARUINT32", + "fift_examples": [], + "gas": "26", + "opcode": "FA04", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_var_integer", + "line": 1453, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDVARUINT32", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA05", + "tlb": "#FA05" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Similar to LDVARUINT32, but loads a signed Integer x.\nApproximately equivalent to 5 LDU SWAP 3 LSHIFT# LDIX.

\n", + "fift": "LDVARINT32", + "fift_examples": [], + "gas": "26", + "opcode": "FA05", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_var_integer", + "line": 1453, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDVARINT32", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA06", + "tlb": "#FA06" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Stores (serializes) an Integer x in the range 0...2^248-1 into Builder b, and returns the resulting Builder b'. The serialization of x consists of a 5-bit unsigned big-endian integer l, which is the smallest integer l>=0, such that x<2^(8l), followed by an 8l-bit unsigned big-endian representation of x. If x does not belong to the supported range, a range check exception is thrown.

\n", + "fift": "STVARUINT32", + "fift_examples": [], + "gas": "26", + "opcode": "FA06", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_var_integer", + "line": 1474, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STVARUINT32", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA07", + "tlb": "#FA07" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_currency", + "description": "

Similar to STVARUINT32, but serializes a signed Integer x in the range -2^247...2^247-1.

\n", + "fift": "STVARINT32", + "fift_examples": [], + "gas": "26", + "opcode": "FA07", + "stack": "b x - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_var_integer", + "line": 1474, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STVARINT32", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA40", + "tlb": "#FA40" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDMSGADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA40", + "stack": "s - s' s''" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_message_addr", + "line": 1536, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDMSGADDR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA41", + "tlb": "#FA41" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "LDMSGADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA41", + "stack": "s - s' s'' -1 or s 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_message_addr", + "line": 1536, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDMSGADDRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s3", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA42", + "tlb": "#FA42" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "PARSEMSGADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA42", + "stack": "s - t" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_parse_message_addr", + "line": 1629, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "PARSEMSGADDR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA43", + "tlb": "#FA43" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of PARSEMSGADDR: returns a zero on error instead of throwing an exception.

\n", + "fift": "PARSEMSGADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA43", + "stack": "s - t -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_parse_message_addr", + "line": 1629, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "PARSEMSGADDRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "t", + "type": "simple", + "value_types": [ + "Tuple" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA44", + "tlb": "#FA44" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "REWRITESTDADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA44", + "stack": "s - x y" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_rewrite_message_addr", + "line": 1669, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "REWRITESTDADDR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA45", + "tlb": "#FA45" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive REWRITESTDADDR.

\n", + "fift": "REWRITESTDADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA45", + "stack": "s - x y -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_rewrite_message_addr", + "line": 1669, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "REWRITESTDADDRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA46", + "tlb": "#FA46" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

msg_addr_var not allowed since TVM v10, so it behaves like REWRITESTDADDR, but returns account id in Slice, not Integer: parses address s into workchain x and account id s.

\n", + "fift": "REWRITEVARADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA46", + "stack": "s - x s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_rewrite_message_addr", + "line": 1669, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "REWRITEVARADDR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA47", + "tlb": "#FA47" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive REWRITEVARADDR.

\n", + "fift": "REWRITEVARADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA47", + "stack": "s - x s' -1 or 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_rewrite_message_addr", + "line": 1669, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "REWRITEVARADDRQ", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [], + "value": 0 + }, + { + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "s'", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA48", + "tlb": "#FA48" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

Loads addr_std$10, if address is not addr_std, throws an error 9 (cannot load a MsgAddressInt).

\n", + "fift": "LDSTDADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA48", + "stack": "s - a s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_std_message_addr", + "line": 1568, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDSTDADDR", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA49", + "tlb": "#FA49" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive LDSTDADDR.

\n", + "fift": "LDSTDADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA49", + "stack": "s - a s' -1 or s 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_std_message_addr", + "line": 1568, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDSTDADDRQ", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "s'", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA50", + "tlb": "#FA50" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

Loads addr_std$10 or addr_none$00, if address is addr_none$00 pushes a Null, if address is not addr_std or addr_none, throws an error 9 (cannot load a MsgAddressInt).

\n", + "fift": "LDOPTSTDADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA50", + "stack": "s - a s'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_opt_std_message_addr", + "line": 1586, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDOPTSTDADDR", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "s2", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA51", + "tlb": "#FA51" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive LDOPTSTDADDR.

\n", + "fift": "LDOPTSTDADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA51", + "stack": "s - a s' -1 or s 0" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_load_opt_std_message_addr", + "line": 1586, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "LDOPTSTDADDRQ", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "s", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "s'", + "type": "simple", + "value_types": [ + "Slice" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA52", + "tlb": "#FA52" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

Stores addr_std$10, if address is not addr_std, throws an error 9 (cannot load a MsgAddressInt).

\n", + "fift": "STSTDADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA52", + "stack": "a b - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_std_address", + "line": 1822, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STSTDADDR", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA53", + "tlb": "#FA53" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive STSTDADDR.

\n", + "fift": "STSTDADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA53", + "stack": "a b - b' 0 or a b -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_std_address", + "line": 1822, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STSTDADDRQ", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA54", + "tlb": "#FA54" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

stores addr_std$10 or Null. Null is stored as addr_none$00, if address is not addr_std, throws an error 9 (cannot load a MsgAddressInt).

\n", + "fift": "STOPTSTDADDR", + "fift_examples": [], + "gas": "26", + "opcode": "FA54", + "stack": "a b - b'" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_opt_std_address", + "line": 1855, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STOPTSTDADDR", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FA55", + "tlb": "#FA55" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_addr", + "description": "

A quiet version of primitive STOPTSTDADDR.

\n", + "fift": "STOPTSTDADDRQ", + "fift_examples": [], + "gas": "26", + "opcode": "FA55", + "stack": "a b - b' 0 or a b -1" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_store_opt_std_address", + "line": 1855, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/f58297f1b668c7b49e8b30b65062951ca7c18acc/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "STOPTSTDADDRQ", + "since_version": 12, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [ + { + "match": [ + { + "stack": [ + { + "name": "b2", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": 0 + }, + { + "stack": [ + { + "name": "a", + "type": "simple", + "value_types": [ + "Slice", + "Null" + ] + }, + { + "name": "b", + "type": "simple", + "value_types": [ + "Builder" + ] + } + ], + "value": -1 + } + ], + "name": "status", + "type": "conditional" + }, + { + "name": "status", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB00", + "tlb": "#FB00" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SENDRAWMSG", + "fift_examples": [], + "gas": "526", + "opcode": "FB00", + "stack": "c x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_send_raw_message", + "line": 1762, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SENDRAWMSG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB02", + "tlb": "#FB02" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "RAWRESERVE", + "fift_examples": [], + "gas": "526", + "opcode": "FB02", + "stack": "x y - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_reserve_raw", + "line": 2035, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RAWRESERVE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB03", + "tlb": "#FB03" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "RAWRESERVEX", + "fift_examples": [], + "gas": "526", + "opcode": "FB03", + "stack": "x D y - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_reserve_raw", + "line": 2035, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "RAWRESERVEX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "D", + "type": "simple", + "value_types": [ + "Cell", + "Null" + ] + }, + { + "name": "y", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB04", + "tlb": "#FB04" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETCODE", + "fift_examples": [], + "gas": "526", + "opcode": "FB04", + "stack": "c - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_code", + "line": 2059, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETCODE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB06", + "tlb": "#FB06" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "SETLIBCODE", + "fift_examples": [], + "gas": "526", + "opcode": "FB06", + "stack": "c x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_set_lib_code", + "line": 2071, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SETLIBCODE", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB07", + "tlb": "#FB07" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "CHANGELIB", + "fift_examples": [], + "gas": "526", + "opcode": "FB07", + "stack": "h x - " + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_change_lib", + "line": 2095, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "CHANGELIB", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "h", + "type": "simple", + "value_types": [ + "Integer" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FB08", + "tlb": "#FB08" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "app_actions", + "description": "

Creates an output action and returns a fee for creating a message. Mode has the same effect as in the case of SENDRAWMSG. Additionally +1024 means - do not create an action, only estimate fee. Other modes affect the fee calculation as follows: +64 substitutes the entire balance of the incoming message as an outcoming value (slightly inaccurate, gas expenses that cannot be estimated before the computation is completed are not taken into account), +128 substitutes the value of the entire balance of the contract before the start of the computation phase (slightly inaccurate, since gas expenses that cannot be estimated before the completion of the computation phase are not taken into account).

\n", + "fift": "SENDMSG", + "fift_examples": [], + "gas": "526", + "opcode": "FB08", + "stack": "c x - fee" + }, + "implementation": [ + { + "file": "tonops.cpp", + "function_name": "exec_send_message", + "line": 1800, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/tonops.cpp" + } + ], + "mnemonic": "SENDMSG", + "since_version": 4, + "value_flow": { + "inputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Cell" + ] + }, + { + "name": "x", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [ + { + "index": 5, + "type": "constant" + } + ], + "stack": [ + { + "name": "fee", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 14, + "min_value": 0, + "name": "i", + "size": 4, + "type": "uint" + }, + { + "display_hints": [], + "max_value": 15, + "min_value": 0, + "name": "j", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 0, + "length": 4, + "to": 14 + }, + "prefix": "FE", + "tlb": "#FE i:(#<= 14) j:(## 4)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "debug", + "description": "", + "fift": "{i*16+j} DEBUG", + "fift_examples": [], + "gas": "26", + "opcode": "FEij", + "stack": "-" + }, + "implementation": [ + { + "file": "debugops.cpp", + "function_name": "exec_dummy_debug", + "line": 35, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/debugops.cpp" + } + ], + "mnemonic": "DEBUG", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "bits_length_var_size": 4, + "bits_padding": 8, + "completion_tag": false, + "display_hints": [], + "max_bits": 128, + "max_refs": 0, + "min_bits": 8, + "min_refs": 0, + "name": "s", + "type": "subslice" + } + ], + "prefix": "FEF", + "tlb": "#FEF n:(## 4) ssss:((n * 8 + 8) * Bit)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "debug", + "description": "

0 <= n < 16. Length of ssss is n+1 bytes.\n{string} is a string literal.\nDEBUGSTR: ssss is the given string.\nDEBUGSTRI: ssss is one-byte integer 0 <= x <= 255 followed by the given string.

\n", + "fift": "{string} DEBUGSTR\n{string} {x} DEBUGSTRI", + "fift_examples": [], + "gas": "26", + "opcode": "FEFnssss", + "stack": "-" + }, + "implementation": [ + { + "file": "debugops.cpp", + "function_name": "exec_dummy_debug_str", + "line": 41, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/debugops.cpp" + } + ], + "mnemonic": "DEBUGSTR", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [], + "max_value": 239, + "min_value": 0, + "name": "n", + "size": 8, + "type": "uint" + } + ], + "operands_range_check": { + "from": 0, + "length": 8, + "to": 239 + }, + "prefix": "FF", + "tlb": "#FF nn:(#<= 239)" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "codepage", + "description": "

Selects TVM codepage 0 <= nn < 240. If the codepage is not supported, throws an invalid opcode exception.

\n", + "fift": "[nn] SETCP", + "fift_examples": [], + "gas": "26", + "opcode": "FFnn", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_set_cp", + "line": 1237, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCP", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [ + { + "display_hints": [ + { + "type": "add", + "value": -16 + } + ], + "max_value": 15, + "min_value": 1, + "name": "z", + "size": 4, + "type": "uint" + } + ], + "operands_range_check": { + "from": 1, + "length": 4, + "to": 15 + }, + "prefix": "FFF", + "tlb": "#FFF z:(## 4) {1 <= z}" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "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.

\n", + "fift": "[z-16] SETCP", + "fift_examples": [], + "gas": "26", + "opcode": "FFFz", + "stack": "-" + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_set_cp", + "line": 1237, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCP_SPECIAL", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + }, + { + "bytecode": { + "operands": [], + "prefix": "FFF0", + "tlb": "#FFF0" + }, + "control_flow": { + "branches": [], + "nobranch": true + }, + "doc": { + "category": "codepage", + "description": "

Selects codepage c with -2^15 <= c < 2^15 passed in the top of the stack.

\n", + "fift": "SETCPX", + "fift_examples": [], + "gas": "26", + "opcode": "FFF0", + "stack": "c - " + }, + "implementation": [ + { + "file": "contops.cpp", + "function_name": "exec_set_cp_any", + "line": 1243, + "path": "https://raw.githubusercontent.com/ton-blockchain/ton/4ebd7412c52248360464c2df5f434c8aaa3edfe1/crypto/vm/contops.cpp" + } + ], + "mnemonic": "SETCPX", + "since_version": 0, + "value_flow": { + "inputs": { + "registers": [], + "stack": [ + { + "name": "c", + "type": "simple", + "value_types": [ + "Integer" + ] + } + ] + }, + "outputs": { + "registers": [], + "stack": [] + } + } + } + ] +} \ No newline at end of file diff --git a/src/Output.vue b/src/Output.vue index dbdf0e1..81c1c42 100644 --- a/src/Output.vue +++ b/src/Output.vue @@ -33,7 +33,7 @@ function makeDefaultState(): OutputState { const store = inject('store') as Store -const { fiftModule } = useFift(); +const { fiftModule } = useFift(store); const state = ref(makeDefaultState()) const tabs = ref(); diff --git a/src/monaco/Monaco.vue b/src/monaco/Monaco.vue index 3dc8cc0..256ca24 100644 --- a/src/monaco/Monaco.vue +++ b/src/monaco/Monaco.vue @@ -11,16 +11,14 @@ import { getOrCreateModel } from './utils'; import fiftGrammar from './fift.tmLanguage.json'; const registry = new Registry({ - getGrammarDefinition: async _ => { - return { - format: 'json', - content: fiftGrammar - }; - } + getGrammarDefinition: async () => ({ + format: 'json', + content: fiftGrammar + }) }); const grammars = new Map(); -grammars.set('fift', 'source.fif'); +grammars.set('fift', 'source.fift'); const props = withDefaults( defineProps<{ @@ -51,6 +49,9 @@ onMounted(async () => { throw new Error('Cannot find containerRef'); } + // Wait for WASM to load before creating editor + await initPromise; + const editorInstance = monaco.editor.create(containerRef.value, { ...(props.readonly ? { value: props.value, language: lang.value, wordWrap: 'on' } @@ -134,7 +135,8 @@ onMounted(async () => { ) } - initPromise.then(() => wireTmGrammars(monaco as any, registry, grammars, editorInstance as any)); + // Wire TextMate grammars (initPromise already resolved above) + await wireTmGrammars(monaco as any, registry, grammars, editorInstance as any); editorInstance.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, () => { // ignore save event diff --git a/src/monaco/env.ts b/src/monaco/env.ts index 25b017f..454df1a 100644 --- a/src/monaco/env.ts +++ b/src/monaco/env.ts @@ -6,6 +6,7 @@ import { watchEffect } from 'vue'; import { Store } from '../store'; import { getOrCreateModel } from './utils'; +import { createCompletionProvider, createHoverProvider } from './opcodes'; const URI_PREFIX_LEN = 'file:///'.length; @@ -53,4 +54,8 @@ export function loadMonacoEnv() { }; languages.register({ id: 'fift', extensions: ['.fif'] }); + + // Register completion and hover providers for TVM opcodes + languages.registerCompletionItemProvider('fift', createCompletionProvider()); + languages.registerHoverProvider('fift', createHoverProvider()); } diff --git a/src/monaco/opcodes.ts b/src/monaco/opcodes.ts new file mode 100644 index 0000000..3e5ca65 --- /dev/null +++ b/src/monaco/opcodes.ts @@ -0,0 +1,308 @@ +import { languages } from 'monaco-editor-core'; +import cp0Data from '../../cp0.json'; + +const fiftWordsWithStdlib = new Set(); +const fiftWordsWithoutStdlib = new Set(); +let fiftWordsWithStdlibLoaded = false; +let fiftWordsWithoutStdlibLoaded = false; +let currentIncludeStdlib = true; + +export interface OpcodeInfo { + mnemonic: string; + fift: string; + stack: string; + description: string; + category?: string; + gas?: string; + opcode?: string; + isAlias?: boolean; + aliasOf?: string; + snippet?: string; + hasOperands?: boolean; +} + +const opcodeMap = new Map(); + +function stripHtml(html: string): string { + return html + .replace(/<[^>]*>/g, '') + .replace(/</g, '<') + .replace(/>/g, '>') + .replace(/&/g, '&') + .replace(/"/g, '"') + .replace(/'/g, "'") + .replace(/ /g, ' ') + .trim(); +} + +/** + * Convert fift syntax like "s[i] s[j] XCHG" to snippet "s${1:i} s${2:j} XCHG" + */ +function createSnippet(fiftSyntax: string): { snippet: string; hasOperands: boolean } { + let snippet = fiftSyntax.trim(); + let placeholderIndex = 1; + let hasOperands = false; + + // Replace [var] patterns with ${n:var} placeholders + // Handle patterns like: [i], [j], [k], [n], [x], [y], [c], [args], etc. + snippet = snippet.replace(/\[([a-zA-Z_][a-zA-Z0-9_]*(?:\+\d+)?)\]/g, (_, varName) => { + hasOperands = true; + return `\${${placeholderIndex++}:${varName}}`; + }); + + return { snippet, hasOperands }; +} + +// Interface for Fift module (matches @fift exports) +interface FiftModule { + interpret( + fileProvider: { fileExists(name: string): boolean; readFile(name: string): ArrayBuffer }, + code: string, + includeStdlib: boolean + ): { success: boolean; stdout: string; stderr?: string }; +} + +const emptyFileProvider = { + fileExists: () => false, + readFile: () => { throw new Error('No files'); } +}; + +/** + * Load Fift words dynamically from the interpreter + */ +export function loadFiftWords(fiftModule: FiftModule, includeStdlib: boolean): void { + const targetSet = includeStdlib ? fiftWordsWithStdlib : fiftWordsWithoutStdlib; + const isLoaded = includeStdlib ? fiftWordsWithStdlibLoaded : fiftWordsWithoutStdlibLoaded; + + if (isLoaded) return; + + try { + const result = fiftModule.interpret(emptyFileProvider, 'words', includeStdlib); + if (result.success && result.stdout) { + const words = result.stdout.trim().split(/\s+/).filter(w => w.length > 0); + targetSet.clear(); + for (const word of words) { + targetSet.add(word); + } + if (includeStdlib) { + fiftWordsWithStdlibLoaded = true; + } else { + fiftWordsWithoutStdlibLoaded = true; + } + console.log(`Loaded ${targetSet.size} Fift words from interpreter (stdlib=${includeStdlib})`); + } + } catch (e) { + console.error('Failed to load Fift words:', e); + } +} + +/** + * Set the current includeStdlib preference for completions + */ +export function setIncludeStdlib(includeStdlib: boolean): void { + currentIncludeStdlib = includeStdlib; +} + +function initOpcodes() { + if (opcodeMap.size > 0) return; + + // Process aliases + for (const alias of (cp0Data as any).aliases || []) { + const fiftNames = (alias.doc_fift || alias.mnemonic || '').split('\n'); + for (const fiftSyntax of fiftNames) { + const trimmedSyntax = fiftSyntax.trim(); + if (!trimmedSyntax) continue; + + // Extract the opcode name (last word without brackets) + const cleanName = trimmedSyntax.replace(/\[.*?\]/g, '').replace(/\s+/g, ' ').trim(); + const parts = cleanName.split(' '); + const key = parts[parts.length - 1].toUpperCase(); + + const { snippet, hasOperands } = createSnippet(trimmedSyntax); + + opcodeMap.set(key, { + mnemonic: alias.mnemonic, + fift: alias.doc_fift || alias.mnemonic, + stack: alias.doc_stack || '', + description: stripHtml(alias.description || ''), + isAlias: true, + aliasOf: alias.alias_of, + snippet, + hasOperands, + }); + } + } + + // Process instructions + for (const instr of (cp0Data as any).instructions || []) { + const doc = instr.doc || {}; + const fiftNames = (doc.fift || instr.mnemonic || '').split('\n'); + + for (const fiftSyntax of fiftNames) { + const trimmedSyntax = fiftSyntax.trim(); + if (!trimmedSyntax) continue; + + // Extract the opcode name (last word without brackets) + const cleanName = trimmedSyntax.replace(/\[.*?\]/g, '').replace(/\s+/g, ' ').trim(); + const parts = cleanName.split(' '); + const key = parts[parts.length - 1].toUpperCase(); + + if (opcodeMap.has(key)) continue; // Don't override aliases + + const { snippet, hasOperands } = createSnippet(trimmedSyntax); + + opcodeMap.set(key, { + mnemonic: instr.mnemonic, + fift: doc.fift || instr.mnemonic, + stack: doc.stack || '', + description: stripHtml(doc.description || ''), + category: doc.category, + gas: doc.gas, + opcode: doc.opcode, + snippet, + hasOperands, + }); + } + } +} + +export function createCompletionProvider(): languages.CompletionItemProvider { + return { + triggerCharacters: [], + provideCompletionItems(model, position) { + initOpcodes(); + + const word = model.getWordUntilPosition(position); + const range = { + startLineNumber: position.lineNumber, + endLineNumber: position.lineNumber, + startColumn: word.startColumn, + endColumn: word.endColumn, + }; + + const suggestions: languages.CompletionItem[] = []; + + // Add TVM opcodes + for (const [name, info] of opcodeMap) { + let detail = ''; + if (info.stack) { + detail = info.stack; + } + + let documentation = ''; + if (info.fift && info.hasOperands) { + documentation += `**Syntax:** \`${info.fift}\`\n\n`; + } + if (info.description) { + documentation += info.description; + } + if (info.gas) { + documentation += `\n\n**Gas:** ${info.gas}`; + } + if (info.isAlias && info.aliasOf) { + documentation += `\n\n**Alias of:** ${info.aliasOf}`; + } + if (info.category) { + documentation += `\n\n**Category:** ${info.category.replace(/_/g, ' ')}`; + } + + // Use snippet if the opcode has operands + const useSnippet = info.hasOperands && info.snippet; + + suggestions.push({ + label: { + label: name, + detail: info.hasOperands ? ` ${info.fift.split('\n')[0]}` : undefined, + description: 'TVM', + }, + kind: useSnippet ? languages.CompletionItemKind.Snippet : languages.CompletionItemKind.Keyword, + detail, + documentation: { + value: documentation, + }, + insertText: useSnippet ? info.snippet! : name, + insertTextRules: useSnippet ? 4 : undefined, // InsertAsSnippet + range, + }); + } + + // Add Fift built-in words (respecting current stdlib setting) + const fiftWordSet = currentIncludeStdlib ? fiftWordsWithStdlib : fiftWordsWithoutStdlib; + for (const word of fiftWordSet) { + suggestions.push({ + label: { + label: word, + description: 'Fift', + }, + kind: languages.CompletionItemKind.Function, + insertText: word, + range, + }); + } + + return { suggestions }; + }, + }; +} + +export function createHoverProvider(): languages.HoverProvider { + return { + provideHover(model, position) { + initOpcodes(); + + const word = model.getWordAtPosition(position); + if (!word) return null; + + const info = opcodeMap.get(word.word.toUpperCase()); + if (!info) return null; + + const contents: { value: string }[] = []; + + // Main title with stack effect + let header = `**${word.word.toUpperCase()}**`; + if (info.stack) { + header += ` \`${info.stack}\``; + } + contents.push({ value: header }); + + // Syntax with operands + if (info.hasOperands && info.fift) { + contents.push({ value: `Syntax: \`${info.fift.split('\n')[0]}\`` }); + } + + // Description + if (info.description) { + contents.push({ value: info.description }); + } + + // Additional info + const details: string[] = []; + if (info.gas) { + details.push(`**Gas:** ${info.gas}`); + } + if (info.opcode) { + details.push(`**Opcode:** \`${info.opcode}\``); + } + if (info.category) { + details.push(`**Category:** ${info.category.replace(/_/g, ' ')}`); + } + if (info.isAlias && info.aliasOf) { + details.push(`**Alias of:** ${info.aliasOf}`); + } + + if (details.length > 0) { + contents.push({ value: details.join(' | ') }); + } + + return { + range: { + startLineNumber: position.lineNumber, + endLineNumber: position.lineNumber, + startColumn: word.startColumn, + endColumn: word.endColumn, + }, + contents, + }; + }, + }; +} diff --git a/src/providers/useFift.ts b/src/providers/useFift.ts index 4a14f71..827829a 100644 --- a/src/providers/useFift.ts +++ b/src/providers/useFift.ts @@ -1,17 +1,35 @@ -import { shallowRef } from 'vue'; +import { shallowRef, watch } from 'vue'; import init, * as wasm from '@fift'; +import { loadFiftWords, setIncludeStdlib } from '../monaco/opcodes'; +import type { Store } from '../store'; let startedLoading = false; let fiftModule = shallowRef(); +let storeWatcherSetup = false; -export function useFift() { +export function useFift(store?: Store) { if (!startedLoading) { startedLoading = true; init().then(() => { fiftModule.value = wasm; + // Load Fift words for autocompletion (for both stdlib settings) + loadFiftWords(wasm, true); + loadFiftWords(wasm, false); }); } + // Set up watcher for includeStdlib changes (only once) + if (store && !storeWatcherSetup) { + storeWatcherSetup = true; + watch( + () => store.state.includeStdlib, + (includeStdlib) => { + setIncludeStdlib(includeStdlib); + }, + { immediate: true } + ); + } + return { fiftModule }; From 4119997f634101f00171c29ce059f5c02aa180cb Mon Sep 17 00:00:00 2001 From: pavelkhachatrian Date: Fri, 16 Jan 2026 15:45:18 +0100 Subject: [PATCH 2/2] Add script to update TVM opcodes --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index 52f63fc..79ab75e 100644 --- a/package.json +++ b/package.json @@ -6,6 +6,7 @@ "dev": "vite", "wasm": "wasm-pack build fift-wasm --release --target web", "build": "vue-tsc --noEmit && vite build", + "update-opcodes": "wget -O cp0.json https://raw.githubusercontent.com/ton-org/docs/refs/heads/main/resources/tvm/cp0.txt", "preview": "vite preview" }, "dependencies": {