tvm_instructions

	name	alias	tlb	category	opcode	fift_asm	stack	gas	desc	tvm_asm	extra_info
0	NOP		#00	stack_basic	00	NOP	-	18	Does nothing.		Expand Basically does nothing. Look at compile_XHIG in ever-assembler for more stacks info
1	SWAP	XCHG_0I	#01	stack_basic	01	SWAP	x y - y x	18	Same as s1 XCHG0.		Expand Do nonsense Really nonsense
2	XCHG_0I		#0 i:(## 4) {1 <= i}	stack_basic	0i	s[i] XCHG0		18	Interchanges s0 with s[i], 1 <= i <= 15.		Expand How to calculate the tvm_asm?
3	XCHG_IJ		#10 i:(## 4) j:(## 4) {1 <= i} {i + 1 <= j}	stack_basic	10ij	s[i] s[j] XCHG		26	Interchanges s[i] with s[j], 1 <= i < j <= 15.		Expand
4	XCHG_0I_LONG		#11 ii:uint8	stack_basic	11ii	s0 [ii] s() XCHG		26	Interchanges s0 with s[ii], 0 <= ii <= 255.		Expand
5	XCHG_1I		#1 i:(## 4) {2 <= i}	stack_basic	1i	s1 s[i] XCHG		18	Interchanges s1 with s[i], 2 <= i <= 15.		Expand
6	PUSH		#2 i:uint4	stack_basic	2i	s[i] PUSH		18	Pushes a copy of the old s[i] into the stack.		Expand
7	DUP	PUSH	#20	stack_basic	20	DUP	x - x x	18	Same as s0 PUSH.	0x20	Expand
8	OVER	PUSH	#21	stack_basic	21	OVER	x y - x y x	18	Same as s1 PUSH.	0x21	Expand
9	POP		#3 i:uint4	stack_basic	3i	s[i] POP		18	Pops the old s0 value into the old s[i].		Expand
10	DROP	POP	#30	stack_basic	30	DROP	x -	18	Same as s0 POP, discards the top-of-stack value.	0x30	Expand
11	NIP	POP	#31	stack_basic	31	NIP	x y - y	18	Same as s1 POP.	0x31	Expand
12	XCHG3		#4 i:uint4 j:uint4 k:uint4	stack_complex	4ijk	s[i] s[j] s[k] XCHG3		26	Equivalent to s2 s[i] XCHG s1 s[j] XCHG s[k] XCHG0.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] [s3 = parse_stack_register_u4] 0x40 | s1, (s2 << 4) | s3	Expand
13	XCHG2		#50 i:uint4 j:uint4	stack_complex	50ij	s[i] s[j] XCHG2		26	Equivalent to s1 s[i] XCHG s[j] XCHG0.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] 0x50, (s1 << 4) | s2	Expand
14	XCPU		#51 i:uint4 j:uint4	stack_complex	51ij	s[i] s[j] XCPU		26	Equivalent to s[i] XCHG0 s[j] PUSH.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] 0x51, (s1 << 4) | s2	Expand
15	PUXC		#52 i:uint4 j:uint4	stack_complex	52ij	s[i] s[j-1] PUXC		26	Equivalent to s[i] PUSH SWAP s[j] XCHG0.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4_minus_one] 0x52, (s1 << 4) | s2	Expand
16	PUSH2		#53 i:uint4 j:uint4	stack_complex	53ij	s[i] s[j] PUSH2		26	Equivalent to s[i] PUSH s[j+1] PUSH.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] 0x53, (s1 << 4) | s2	Expand
17	XCHG3_ALT		#540 i:uint4 j:uint4 k:uint4	stack_complex	540ijk	s[i] s[j] s[k] XCHG3_l		34	Long form of XCHG3.		Expand
18	XC2PU		#541 i:uint4 j:uint4 k:uint4	stack_complex	541ijk	s[i] s[j] s[k] XC2PU		34	Equivalent to s[i] s[j] XCHG2 s[k] PUSH.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] [s3 = parse_stack_register_u4] 0x54, 0x10 | s1, (s2 << 4) | s3	Expand
19	XCPUXC		#542 i:uint4 j:uint4 k:uint4	stack_complex	542ijk	s[i] s[j] s[k-1] XCPUXC		34	Equivalent to s1 s[i] XCHG s[j] s[k-1] PUXC.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] [s3 = parse_stack_register_u4_minus_one] 0x54, 0x20 | s1, (s2 << 4) | s3	Expand
20	XCPU2		#543 i:uint4 j:uint4 k:uint4	stack_complex	543ijk	s[i] s[j] s[k] XCPU2		34	Equivalent to s[i] XCHG0 s[j] s[k] PUSH2.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4] [s3 = parse_stack_register_u4] 0x54, 0x30 | s1, (s2 << 4) | s3	Expand
21	PUXC2		#544 i:uint4 j:uint4 k:uint4	stack_complex	544ijk	s[i] s[j-1] s[k-1] PUXC2		34	Equivalent to s[i] PUSH s2 XCHG0 s[j] s[k] XCHG2.		Expand
22	PUXCPU		#545 i:uint4 j:uint4 k:uint4	stack_complex	545ijk	s[i] s[j-1] s[k-1] PUXCPU		34	Equivalent to s[i] s[j-1] PUXC s[k] PUSH.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4_minus_one] [s3 = parse_stack_register_u4_minus_one] 0x54, 0x50 | s1, (s2 << 4) | s3	Expand
23	PU2XC		#546 i:uint4 j:uint4 k:uint4	stack_complex	546ijk	s[i] s[j-1] s[k-2] PU2XC		34	Equivalent to s[i] PUSH SWAP s[j] s[k-1] PUXC.	[s1 = parse_stack_register_u4][s2 = parse_stack_register_u4_minus_one] [s3 = parse_stack_register_u4_minus_two] 0x54, 0x60 | s1, (s2 << 4) | s3	Expand
24	PUSH3		#547 i:uint4 j:uint4 k:uint4	stack_complex	547ijk	s[i] s[j] s[k] PUSH3		34	Equivalent to s[i] PUSH s[j+1] s[k+1] PUSH2.		Expand
25	BLKSWAP		#55 i:uint4 j:uint4	stack_complex	55ij	[i+1][j+1] BLKSWAP		26	Permutes two blocks s[j+i+1] … s[j+1] and s[j] … s0.	[c1 = parse_const_u4_plus_one][c2 = parse_const_u4_plus_one] => 0x55, (c1 << 4) | c2	Expand
									0 <= i,j <= 15
									Equivalent to [i+1] [j+1] REVERSE [j+1] 0 REVERSE [i+j+2] 0 REVERSE.
26	ROT2	BLKSWAP	#5513	stack_complex	5513	ROT2	a b c d e f - c d e f a b	26	Rotates the three topmost pairs of stack entries.	0x55, 0x13	Expand
						2ROT
27	ROLL	BLKSWAP	#550 i:uint4	stack_complex	550i	[i+1] ROLL		26	Rotates the top i+1 stack entries.	[c = parse_const_u4_plus_one] 0x55, c	Expand
									Equivalent to 1 [i+1] BLKSWAP.
28	ROLLREV	BLKSWAP	#55 i:uint4 zero:(## 4) {zero = 0}	stack_complex	55i0	[i+1] -ROLL		26	Rotates the top i+1 stack entries in the other direction.	[c = parse_const_u4_plus_one] 0x55, c << 4	Expand
						[i+1] ROLLREV			Equivalent to [i+1] 1 BLKSWAP.
29	PUSH_LONG		#56 ii:uint8	stack_complex	56ii	[ii] s() PUSH		26	Pushes a copy of the old s[ii] into the stack.		Expand
									0 <= ii <= 255
30	POP_LONG		#57 ii:uint8	stack_complex	57ii	[ii] s() POP		26	Pops the old s0 value into the old s[ii].		Expand
									0 <= ii <= 255
31	ROT		#58	stack_complex	58	ROT	a b c - b c a	18	Equivalent to 1 2 BLKSWAP or to s2 s1 XCHG2.	0x58	Expand
32	ROTREV		#59	stack_complex	59	ROTREV	a b c - c a b	18	Equivalent to 2 1 BLKSWAP or to s2 s2 XCHG2.	0x59	Expand
						-ROT
33	SWAP2		#5A	stack_complex	5A	SWAP2	a b c d - c d a b	18	Equivalent to 2 2 BLKSWAP or to s3 s2 XCHG2.	0x5A	Expand
						2SWAP
34	DROP2		#5B	stack_complex	5B	DROP2	a b -	18	Equivalent to DROP DROP.	0x5B	Expand
						2DROP
35	DUP2		#5C	stack_complex	5C	DUP2	a b - a b a b	18	Equivalent to s1 s0 PUSH2.	0x5C	Expand
						2DUP
36	OVER2		#5D	stack_complex	5D	OVER2	a b c d - a b c d a b	18	Equivalent to s3 s2 PUSH2.	0x5D	Expand
						2OVER
37	REVERSE		#5E i:uint4 j:uint4	stack_complex	5Eij	[i+2][j] REVERSE		26	Reverses the order of s[j+i+1] … s[j].	[c1 = parse_const_u4_plus_two][c2 = parse_const_u4] 0x5E, (c1 << 4) | c2	Expand
38	BLKDROP		#5F0 i:uint4	stack_complex	5F0i	[i] BLKDROP		26	Equivalent to DROP performed i times.	[c = parse_const_u4] 0x5F, c	Expand
39	BLKPUSH		#5F i:(## 4) j:uint4 {1 <= i}	stack_complex	5Fij	[i][j] BLKPUSH		26	Equivalent to PUSH s(j) performed i times.	[c1 = parse_const_u4_nonzero][c2 = parse_const_u4] 0x5F, (c1 << 4) | c2	Expand
									1 <= i <= 15, 0 <= j <= 15.
40	PICK		#60	stack_complex	60	PICK		18	Pops integer i from the stack, then performs s[i] PUSH.	0x60	Expand
						PUSHX
41	ROLLX		#61	stack_complex	61	ROLLX		18	Pops integer i from the stack, then performs 1 [i] BLKSWAP.	0x61	Expand
42	-ROLLX		#62	stack_complex	62	-ROLLX		18	Pops integer i from the stack, then performs [i] 1 BLKSWAP.	0x62	Expand
						ROLLREVX
43	BLKSWX		#63	stack_complex	63	BLKSWX		18	Pops integers i,j from the stack, then performs [i] [j] BLKSWAP.	0x63	Expand
44	REVX		#64	stack_complex	64	REVX		18	Pops integers i,j from the stack, then performs [i] [j] REVERSE.	0x64	Expand
45	DROPX		#65	stack_complex	65	DROPX		18	Pops integer i from the stack, then performs [i] BLKDROP.	0x65	Expand
46	TUCK		#66	stack_complex	66	TUCK	a b - b a b	18	Equivalent to SWAP OVER or to s1 s1 XCPU.	0x66	Expand
47	XCHGX		#67	stack_complex	67	XCHGX		18	Pops integer i from the stack, then performs s[i] XCHG.	0x67	Expand
48	DEPTH		#68	stack_complex	68	DEPTH	- depth	18	Pushes the current depth of the stack.	0x68	Expand
49	CHKDEPTH		#69	stack_complex	69	CHKDEPTH	i -	18/58	Pops integer i from the stack, then checks whether there are at least i elements, generating a stack underflow exception otherwise.	0x69	Expand
50	ONLYTOPX		#6A	stack_complex	6A	ONLYTOPX		18	Pops integer i from the stack, then removes all but the top i elements.	0x6A	Expand
51	ONLYX		#6B	stack_complex	6B	ONLYX		18	Pops integer i from the stack, then leaves only the bottom i elements. Approximately equivalent to DEPTH SWAP SUB DROPX.	0x6B	Expand
52	BLKDROP2		#6C i:(## 4) j:uint4 {1 <= i}	stack_complex	6Cij	[i][j] BLKDROP2		26	Drops i stack elements under the top j elements.	[c1 = parse_const_u4_nonzero][c2 = parse_const_u4] 0x6C, (c1 << 4) | c2	Expand
									1 <= i <= 15, 0 <= j <= 15
									Equivalent to [i+j] 0 REVERSE [i] BLKDROP [j] 0 REVERSE.
53	NULL		#6D	tuple	6D	NULL	- null	18	Pushes the only value of type Null.	0x6D	Expand
						PUSHNULL
54	ISNULL		#6E	tuple	6E	ISNULL	x - ?	18	Checks whether x is a Null, and returns -1 or 0 accordingly.	0x6E	Expand
55	TUPLE		#6F0 n:uint4	tuple	6F0n	[n] TUPLE	x_1 ... x_n - t	26+n	Creates a new Tuple t=(x_1, … ,x_n) containing n values x_1,..., x_n.	[s = parse_const_u4] 0x6F, s	Expand
									0 <= n <= 15
56	NIL	TUPLE	#6F00	tuple	6F00	NIL	- t	26	Pushes the only Tuple t=() of length zero.	0x6F, 0x00	Expand
57	SINGLE	TUPLE	#6F01	tuple	6F01	SINGLE	x - t	27	Creates a singleton t:=(x), i.e., a Tuple of length one.	0x6F, 0x01	Expand
58	PAIR	TUPLE	#6F02	tuple	6F02	PAIR	x y - t	28	Creates pair t:=(x,y).	0x6F, 0x02	Expand
						CONS
59	TRIPLE	TUPLE	#6F03	tuple	6F03	TRIPLE	x y z - t	29	Creates triple t:=(x,y,z).	0x6F, 0x03	Expand
60	INDEX		#6F1 k:uint4	tuple	6F1k	[k] INDEX	t - x	26	Returns the k-th element of a Tuple t.	[c = parse_const_u4] 0x6F, 0x10 | c	Expand
									0 <= k <= 15.
61	FIRST	INDEX	#6F10	tuple	6F10	FIRST	t - x	26	Returns the first element of a Tuple.	0x6F, 0x10	Expand
						CAR
62	SECOND	INDEX	#6F11	tuple	6F11	SECOND	t - y	26	Returns the second element of a Tuple.	0x6F, 0x11	Expand
						CDR
63	THIRD	INDEX	#6F12	tuple	6F12	THIRD	t - z	26	Returns the third element of a Tuple.	0x6F, 0x12	Expand
64	UNTUPLE		#6F2 n:uint4	tuple	6F2n	[n] UNTUPLE	t - x_1 ... x_n	26+n	Unpacks a Tuple t=(x_1,...,x_n) of length equal to 0 <= n <= 15.	[c = parse_const_u4] 0x6F, 0x20 | c	Expand
									If t is not a Tuple, or if \|t\| != n, a type check exception is thrown.
65	UNSINGLE	UNTUPLE	#6F21	tuple	6F21	UNSINGLE	t - x	27	Unpacks a singleton t=(x).	0x6F, 0x21	Expand
66	UNPAIR	UNTUPLE	#6F22	tuple	6F22	UNPAIR	t - x y	28	Unpacks a pair t=(x,y).	0x6F, 0x22	Expand
						UNCONS
67	UNTRIPLE	UNTUPLE	#6F23	tuple	6F23	UNTRIPLE	t - x y z	29	Unpacks a triple t=(x,y,z).	0x6F, 0x23	Expand
68	UNPACKFIRST		#6F3 k:uint4	tuple	6F3k	[k] UNPACKFIRST	t - x_1 ... x_k	26+k	Unpacks first 0 <= k <= 15 elements of a Tuple t.	[c = parse_const_u4] 0x6F, 0x30 | c	Expand
									If \|t\|<k, throws a type check exception.
69	CHKTUPLE	UNPACKFIRST	#6F30	tuple	6F30	CHKTUPLE	t -	26	Checks whether t is a Tuple. If not, throws a type check exception.	0x6F, 0x30	Expand
70	EXPLODE		#6F4 n:uint4	tuple	6F4n	[n] EXPLODE	t - x_1 ... x_m m	26+m	Unpacks a Tuple t=(x_1,...,x_m) and returns its length m, but only if m <= n <= 15. Otherwise throws a type check exception.	[c = parse_const_u4] 0x6F, 0x40 | c	Expand
71	SETINDEX		#6F5 k:uint4	tuple	6F5k	[k] SETINDEX	t x - t'	26+|t|	Computes Tuple t' that differs from t only at position t'_{k+1}, which is set to x.	[c = parse_const_u4] 0x6F, 0x50 | c	Expand
									0 <= k <= 15
									If k >= \|t\|, throws a range check exception.
72	SETFIRST	SETINDEX	#6F50	tuple	6F50	SETFIRST	t x - t'	26+|t|	Sets the first component of Tuple t to x and returns the resulting Tuple t'.	0x6F, 0x50	Expand
73	SETSECOND	SETINDEX	#6F51	tuple	6F51	SETSECOND	t x - t'	26+|t|	Sets the second component of Tuple t to x and returns the resulting Tuple t'.	0x6F, 0x51	Expand
74	SETTHIRD	SETINDEX	#6F52	tuple	6F52	SETTHIRD	t x - t'	26+|t|	Sets the third component of Tuple t to x and returns the resulting Tuple t'.	0x6F, 0x52	Expand
75	INDEXQ		#6F6 k:uint4	tuple	6F6k	[k] INDEXQ	t - x	26	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.	[c = parse_const_u4] 0x6F, 0x60 | c	Expand
76	FIRSTQ	INDEXQ	#6F60	tuple	6F60	FIRSTQ	t - x	26	Returns the first element of a Tuple.	0x6F, 0x60	Expand
						CARQ
77	SECONDQ	INDEXQ	#6F61	tuple	6F61	SECONDQ	t - y	26	Returns the second element of a Tuple.	0x6F, 0x61	Expand
						CDRQ
78	THIRDQ	INDEXQ	#6F62	tuple	6F62	THIRDQ	t - z	26	Returns the third element of a Tuple.	0x6F, 0x62	Expand
79	SETINDEXQ		#6F7 k:uint4	tuple	6F7k	[k] SETINDEXQ	t x - t'	26+|t’|	Sets the k-th component of Tuple t to x, where 0 <= k < 16, and returns the resulting Tuple t'.	[c = parse_const_u4] 0x6F, 0x70 | c	Expand
									If \|t\| <= k, first extends the original Tuple to length n’=k+1 by setting all new components to Null. If the original value of t is Null, treats it as an empty Tuple. If t is not Null or Tuple, throws an exception. If x is Null and either \|t\| <= k or t is Null, then always returns t'=t (and does not consume tuple creation gas).
80	SETFIRSTQ	SETINDEXQ	#6F70	tuple	6F70	SETFIRSTQ	t x - t'	26+|t’|	Sets the first component of Tuple t to x and returns the resulting Tuple t'.	0x6F , 0x70	Expand
81	SETSECONDQ	SETINDEXQ	#6F71	tuple	6F71	SETSECONDQ	t x - t'	26+|t’|	Sets the second component of Tuple t to x and returns the resulting Tuple t'.	0x6F , 0x71	Expand
82	SETTHIRDQ	SETINDEXQ	#6F72	tuple	6F72	SETTHIRDQ	t x - t'	26+|t’|	Sets the third component of Tuple t to x and returns the resulting Tuple t'.	0x6F , 0x72	Expand
83	TUPLEVAR		#6F80	tuple	6F80	TUPLEVAR	x_1 ... x_n n - t	26+n	Creates a new Tuple t of length n similarly to TUPLE, but with 0 <= n <= 255 taken from the stack.	0x6F , 0x80	Expand
84	INDEXVAR		#6F81	tuple	6F81	INDEXVAR	t k - x	26	Similar to k INDEX, but with 0 <= k <= 254 taken from the stack.	0x6F , 0x81	Expand
85	UNTUPLEVAR		#6F82	tuple	6F82	UNTUPLEVAR	t n - x_1 ... x_n	26+n	Similar to n UNTUPLE, but with 0 <= n <= 255 taken from the stack.	0x6F , 0x82	Expand
86	UNPACKFIRSTVAR		#6F83	tuple	6F83	UNPACKFIRSTVAR	t n - x_1 ... x_n	26+n	Similar to n UNPACKFIRST, but with 0 <= n <= 255 taken from the stack.	0x6F , 0x83	Expand
87	EXPLODEVAR		#6F84	tuple	6F84	EXPLODEVAR	t n - x_1 ... x_m m	26+m	Similar to n EXPLODE, but with 0 <= n <= 255 taken from the stack.	0x6F , 0x84	Expand
88	SETINDEXVAR		#6F85	tuple	6F85	SETINDEXVAR	t x k - t'	26+|t’|	Similar to k SETINDEX, but with 0 <= k <= 254 taken from the stack.	0x6F , 0x85	Expand
89	INDEXVARQ		#6F86	tuple	6F86	INDEXVARQ	t k - x	26	Similar to n INDEXQ, but with 0 <= k <= 254 taken from the stack.	0x6F , 0x86	Expand
90	SETINDEXVARQ		#6F87	tuple	6F87	SETINDEXVARQ	t x k - t'	26+|t’|	Similar to k SETINDEXQ, but with 0 <= k <= 254 taken from the stack.	0x6F , 0x87	Expand
91	TLEN		#6F88	tuple	6F88	TLEN	t - n	26	Returns the length of a Tuple.	0x6F , 0x88	Expand
92	QTLEN		#6F89	tuple	6F89	QTLEN	t - n or -1	26	Similar to TLEN, but returns -1 if t is not a Tuple.	0x6F , 0x89	Expand
93	ZEROSWAPIF		#6F90	tuple	6F90	ZEROSWAPIF	x - x or 0 x	26	Pushes a Zero under the topmost Integer x, but only if x != 0.	0x6F, 0x90	Expand
94	ZEROSWAPIFNOT		#6F91	tuple	6F91	ZEROSWAPIFNOT	x – x or 0 x	26	Pushes a Zero under the topmost Integer x, but only if x = 0.	0x6F, 0x91	Expand
95	ZEROROTRIF		#6F92	tuple	6F92	ZEROROTRIF	x y – x y or 0 x	26	Pushes a Zero under the second stack entry from the top, but only if the topmost Integer y is non-zero.	0x6F, 0x92	Expand
96	ZEROROTRIFNOT		#6F93	tuple	6F93	ZEROROTRIFNOT	x y – x y or 0 x y	26	Pushes a Zero under the second stack entry from the top, but only if the topmost Integer y is zero.	0x6F, 0x93	Expand
97	ZEROSWAPIF2		#6F94	tuple	6F94	ZEROSWAPIF2	x – x or 0 0 x	26	Pushes two Zeros under the topmost Integer x, but only if x != 0. Equivalent to ZEROSWAPIF; ZEROSWAPIF.	0x6F, 0x94	Expand
98	ZEROSWAPIFNOT2		#6F95	tuple	6F95	ZEROSWAPIFNOT2	x – x or 0 0 x	26	Pushes two Zeros under the topmost Integer x, but only if x = 0. Equivalent to ZEROSWAPIFNOT; ZEROSWAPIFNOT.	0x6F, 0x95	Expand
99	ZEROROTRIF2		#6F96	tuple	6F96	ZEROROTRIF2	x y – x y or 0 0 x y	26	Pushes two Zeros under the second stack entry from the top, but only if the topmost Integer y is non-zero. Equivalent to ZEROROTRIF; ZEROROTRIF.	0x6F, 0x96	Expand
100	ZEROROTRIFNOT2		#6F97	tuple	6F97	ZEROROTRIFNOT2	x y – x y or 0 0 x y	26	Pushes two Zeros under the second stack entry from the top, but only if the topmost Integer y is zero. Equivalent to ZEROROTRIFNOT; ZEROROTRIFNOT.	0x6F, 0x97	Expand
101	ISTUPLE		#6F8A	tuple	6F8A	ISTUPLE	t - ?	26	Returns -1 or 0 depending on whether t is a Tuple.	0x6F , 0x8A	Expand
102	LAST		#6F8B	tuple	6F8B	LAST	t - x	26	Returns the last element of a non-empty Tuple t.	0x6F , 0x8B	Expand
103	TPUSH		#6F8C	tuple	6F8C	TPUSH	t x - t'	26+|t’|	Appends a value x to a Tuple t=(x_1,...,x_n), but only if the resulting Tuple t'=(x_1,...,x_n,x) is of length at most 255. Otherwise throws a type check exception.	0x6F , 0x8C	Expand
						COMMA
104	TPOP		#6F8D	tuple	6F8D	TPOP	t - t' x	26+|t’|	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.	0x6F , 0x8D	Expand
105	NULLSWAPIF		#6FA0	tuple	6FA0	NULLSWAPIF	x - x or null x	26	Pushes a Null under the topmost Integer x, but only if x!=0.	0x6F , 0xA0	Expand
106	NULLSWAPIFNOT		#6FA1	tuple	6FA1	NULLSWAPIFNOT	x - x or null x	26	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.	0x6F , 0xA1	Expand
107	NULLROTRIF		#6FA2	tuple	6FA2	NULLROTRIF	x y - x y or null x y	26	Pushes a Null under the second stack entry from the top, but only if the topmost Integer y is non-zero.	0x6F , 0xA2	Expand
108	NULLROTRIFNOT		#6FA3	tuple	6FA3	NULLROTRIFNOT	x y - x y or null x y	26	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.	0x6F , 0xA3	Expand
109	NULLSWAPIF2		#6FA4	tuple	6FA4	NULLSWAPIF2	x - x or null null x	26	Pushes two nulls under the topmost Integer x, but only if x!=0.	0x6F , 0xA4	Expand
									Equivalent to NULLSWAPIF NULLSWAPIF.
110	NULLSWAPIFNOT2		#6FA5	tuple	6FA5	NULLSWAPIFNOT2	x - x or null null x	26	Pushes two nulls under the topmost Integer x, but only if x=0.	0x6F , 0xA5	Expand
									Equivalent to NULLSWAPIFNOT NULLSWAPIFNOT.
111	NULLROTRIF2		#6FA6	tuple	6FA6	NULLROTRIF2	x y - x y or null null x y	26	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer y is non-zero.	0x6F , 0xA6	Expand
									Equivalent to NULLROTRIF NULLROTRIF.
112	NULLROTRIFNOT2		#6FA7	tuple	6FA7	NULLROTRIFNOT2	x y - x y or null null x y	26	Pushes two nulls under the second stack entry from the top, but only if the topmost Integer y is zero.	0x6F , 0xA7	Expand
									Equivalent to NULLROTRIFNOT NULLROTRIFNOT.
113	INDEX2		#6FB i:uint2 j:uint2	tuple	6FBij	[i][j] INDEX2	t - x	26	Recovers x=(t_{i+1})_{j+1} for 0 <= i,j <= 3.	[i = parse_const_u2][j = parse_const_u2] 0x6F, 0xB0 | (i << 2) | j	Expand
									Equivalent to [i] INDEX [j] INDEX.
114	CADR	INDEX2	#6FB4	tuple	6FB4	CADR	t - x	26	Recovers x=(t_2)_1.	0x6F, 0xB4	Expand
115	CDDR	INDEX2	#6FB5	tuple	6FB5	CDDR	t - x	26	Recovers x=(t_2)_2.	0x6F, 0xB5	Expand
116	INDEX3		#6FE_ i:uint2 j:uint2 k:uint2	tuple	6FE_ijk	[i][j] [k] INDEX3	t - x	26	Recovers x=t_{i+1}_{j+1}_{k+1}.	[i = parse_const_u2][j = parse_const_u2] [k = parse_const_u2] 0x6F, 0xC0 | (i << 4) | (j << 2) | k	Expand
									0 <= i,j,k <= 3
									Equivalent to [i] [j] INDEX2 [k] INDEX.
117	CADDR	INDEX3	#6FD4	tuple	6FD4	CADDR	t - x	26	Recovers x=t_2_2_1.	0x6F, 0xD4	Expand
118	CDDDR	INDEX3	#6FD5	tuple	6FD5	CDDDR	t - x	26	Recovers x=t_2_2_2.	0x6F, 0xD5	Expand
119	PUSHINT_4		#7 i:uint4	const_int	7i	[x] PUSHINT	- x	18	Pushes integer x into the stack. -5 <= x <= 10.		Expand
						[x] INT			Here i equals four lower-order bits of x (i=x mod 16).
120	ZERO	PUSHINT_4	#70	const_int	70	ZERO	- 0	18	Pushes a zero.	0x70	Expand
						FALSE
121	ONE	PUSHINT_4	#71	const_int	71	ONE	- 1	18		0x71	Expand
122	TWO	PUSHINT_4	#72	const_int	72	TWO	- 2	18		0x72	Expand
123	TEN	PUSHINT_4	#7A	const_int	7A	TEN	- 10	18	Pushes a ten.	0x7A	Expand
124	TRUE	PUSHINT_4	#7F	const_int	7F	TRUE	- -1	18		0x7F	Expand
125	PUSHINT_8		#80 xx:int8	const_int	80xx	[xx] PUSHINT	- xx	26	Pushes integer xx. -128 <= xx <= 127.		Expand
						[xx] INT
126	PUSHINT_16		#81 xxxx:int16	const_int	81xxxx	[xxxx] PUSHINT	- xxxx	34	Pushes integer xxxx. -2^15 <= xx < 2^15.		Expand
						[xxxx] INT
127			#81FC18	const_int	81FC18	[1000] PUSHINT	- 1000	34			Expand
128	PUSHINT_LONG		#82 l:(## 5) xxx:(int (8 * l + 19))	const_int	82lxxx	[xxx] PUSHINT	- xxx	23	Pushes integer xxx.		Expand
						[xxx] INT			Details: 5-bit 0 <= l <= 30 determines the length n=8l+19 of signed big-endian integer xxx.
									The total length of this instruction is l+4 bytes or n+13=8l+32 bits.
129	PUSHPOW2		#83 xx:uint8	const_int	83xx	[xx+1] PUSHPOW2	- 2^(xx+1)	26	(Quietly) pushes 2^(xx+1) for 0 <= xx <= 255.	[s1 = parse_const_u8_plus_one] 0x83, s1	Expand
									2^256 is a NaN.
130	PUSHNAN	PUSHPOW2	#83FF	const_int	83FF	PUSHNAN	- NaN	26	Pushes a NaN.	0x83, 0xFF	Expand
131	PUSHPOW2DEC		#84 xx:uint8	const_int	84xx	[xx+1] PUSHPOW2DEC	- 2^(xx+1)-1	26	Pushes 2^(xx+1)-1 for 0 <= xx <= 255.	[s1 = parse_const_u8_plus_one] 0x84, s1	Expand
132	PUSHNEGPOW2		#85 xx:uint8	const_int	85xx	[xx+1] PUSHNEGPOW2	- -2^(xx+1)	26	Pushes -2^(xx+1) for 0 <= xx <= 255.	[s1 = parse_const_u8_plus_one] 0x85, s1	Expand
133	PUSHREF		#88 c:^Cell	const_data	88	[ref] PUSHREF	- c	18	Pushes the reference ref into the stack.		Expand
									Details: Pushes the first reference of cc.code into the stack as a Cell (and removes this reference from the current continuation).
134	PUSHREFSLICE		#89 c:^Cell	const_data	89	[ref] PUSHREFSLICE	- s	118/43	Similar to PUSHREF, but converts the cell into a Slice.		Expand
135	PUSHREFCONT		#8A c:^Cell	const_data	8A	[ref] PUSHREFCONT	- cont	118/43	Similar to PUSHREFSLICE, but makes a simple ordinary Continuation out of the cell.		Expand
136	PUSHSLICE		#8B x:(## 4) sss:((8 x + 4) Bit)	const_data	8Bxsss	[slice] PUSHSLICE	- s	22	Pushes the slice slice into the stack.		Expand
						[slice] SLICE			Details: Pushes the (prefix) subslice of cc.code consisting of its first 8x+4 bits and no references (i.e., essentially a bitstring), where 0 <= x <= 15.
									A completion tag is assumed, meaning that all trailing zeroes and the last binary one (if present) are removed from this bitstring.
									If the original bitstring consists only of zeroes, an empty slice will be pushed.
137			#8B04	const_data	8B04	[x8] PUSHSLICE	- s		Pushes an empty slice (bitstring ``).		Expand
138			#8B08	const_data	8B08	[x4] PUSHSLICE	- s		Pushes bitstring 0.		Expand
139			#8B0C	const_data	8B0C	[xC] PUSHSLICE	- s		pushes bitstring 1.		Expand
140	PUSHSLICE_REFS		#8C r:(## 2) xx:(## 5) c:((r + 1) ^Cell) ssss:((8 xx + 1) * Bit)	const_data	8Crxxssss	[slice] PUSHSLICE	- s	25	Pushes the slice slice into the stack.		Expand
						[slice] SLICE			Details: Pushes the (prefix) subslice of cc.code consisting of its first 1 <= r+1 <= 4 references and up to first 8xx+1 bits of data, with 0 <= xx <= 31.
									A completion tag is also assumed.
141			#8C01	const_data	8C01	[ref] PUSHREFSLICE	- s	118/43	Is equivalent to PUSHREFSLICE.		Expand
142	PUSHSLICE_LONG		#8D r:(#<= 4) xx:(## 7) c:(r ^Cell) ssss:((8 xx + 6) * Bit)	const_data	8Drxxsssss	[slice] PUSHSLICE	- s	28	Pushes the slice slice into the stack.		Expand
						[slice] SLICE			Details: Pushes the subslice of cc.code consisting of 0 <= r <= 4 references and up to 8xx+6 bits of data, with 0 <= xx <= 127.
									A completion tag is assumed.
143				const_data		x{} PUSHSLICE	- s		Examples of PUSHSLICE.		Expand
						x{ABCD1234} PUSHSLICE			x{} is an empty slice. x{...} is a hexadecimal literal. b{...} is a binary literal.
						b{01101} PUSHSLICE			More on slice literals here.
									Note that the assembler can replace PUSHSLICE with PUSHREFSLICE in certain situations (e.g. if there’s not enough space in the current continuation).
144				const_data		<b x{AB12} s, b> PUSHREF	- c/s		Examples of PUSHREF and PUSHREFSLICE.		Expand
						<b x{AB12} s, b> PUSHREFSLICE			More on building cells in fift here.
145	PUSHCONT		#8F_ r:(## 2) xx:(## 7) c:(r ^Cell) ssss:((8 xx) * Bit)	const_data	8F_rxxcccc	[builder] PUSHCONT	- c	26	Pushes a continuation made from builder.		Expand
						[builder] CONT			Details: Pushes the simple ordinary continuation cccc made from the first 0 <= r <= 3 references and the first 0 <= xx <= 127 bytes of cc.code.
146	PUSHCONT_SHORT		#9 x:(## 4) ssss:((8 x) Bit)	const_data	9xccc	[builder] PUSHCONT	- c	18	Pushes a continuation made from builder.		Expand
						[builder] CONT			Details: Pushes an x-byte continuation for 0 <= x <= 15.
147				const_data		<{ code }> PUSHCONT	- c		Pushes a continuation with code code.		Expand
						<{ code }> CONT			Note that the assembler can replace PUSHCONT with PUSHREFCONT in certain situations (e.g. if there’s not enough space in the current continuation).
						CONT:<{ code }>
148	ADD		#A0	arithm_basic	A0	ADD	x y - x+y	18	Adds together two integers	0xA0	Expand
149	SUB		#A1	arithm_basic	A1	SUB	x y - x-y	18		0xA1	Expand
150	SUBR		#A2	arithm_basic	A2	SUBR	x y - y-x	18	Equivalent to SWAP SUB.	0xA2	Expand
151	NEGATE		#A3	arithm_basic	A3	NEGATE	x - -x	18	Equivalent to -1 MULCONST or to ZERO SUBR.	0xA3	Expand
									Notice that it triggers an integer overflow exception if x=-2^256.
152	INC		#A4	arithm_basic	A4	INC	x - x+1	18	Equivalent to 1 ADDCONST.	0xA4	Expand
153	DEC		#A5	arithm_basic	A5	DEC	x - x-1	18	Equivalent to -1 ADDCONST.	0xA5	Expand
154	ADDCONST		#A6 cc:int8	arithm_basic	A6cc	[cc] ADDCONST	x - x+cc	26	-128 <= cc <= 127.	[z = parse_const_i8] 0xA6, z	Expand
						[cc] ADDINT
						[-cc] SUBCONST
						[-cc] SUBINT
155	MULCONST		#A7 cc:int8	arithm_basic	A7cc	[cc] MULCONST	x - x*cc	26	-128 <= cc <= 127.	[z = parse_const_i8] 0xA7, z	Expand
						[cc] MULINT
156	MUL		#A8	arithm_basic	A8	MUL	x y - x*y	18		0xA8	Expand
157	DIV_BASE		#A9 m:uint1 s:uint2 cdft:(Either [ d:uint2 f:uint2 ][ d:uint2 f:uint2 tt:uint8 ])	arithm_div	A9mscdf			26	This is the general encoding of division, with an optional pre-multiplication and an optional replacement of the division or multiplication by a shift. Variable fields are as follows:		Expand
									0 <= m <= 1 - Indicates whether there is pre-multiplication (MULDIV and its variants), possibly replaced by a left shift.
									0 <= s <= 2 - Indicates whether either the multiplication or the division have been replaced by shifts: s=0 - no replacement, s=1 - division replaced by a right shift, s=2 - multiplication replaced by a left shift (possible only for m=1).
									0 <= c <= 1 - Indicates whether there is a constant one-byte argument tt for the shift operator (if s!=0). For s=0, c=0. If c=1, then 0 <= tt <= 255, and the shift is performed by tt+1 bits. If s!=0 and c=0, then the shift amount is provided to the instruction as a top-of-stack Integer in range 0...256.
									1 <= d <= 3 - Indicates which results of division are required: 1 - only the quotient, 2 - only the remainder, 3 - both.
									0 <= f <= 2 - Rounding mode: 0 - floor, 1 - nearest integer, 2 - ceiling.
									All instructions below are variants of this.
158	DIV	DIV_BASE	#A904	arithm_div	A904	DIV	x y - q	26	q=floor(x/y), r=x-y*q	0xA9, 0x04	Expand
159	DIVR	DIV_BASE	#A905	arithm_div	A905	DIVR	x y - q’	26	q’=round(x/y), r’=x-y*q’	0xA9, 0x05	Expand
160	DIVC	DIV_BASE	#A906	arithm_div	A906	DIVC	x y - q''	26	q’’=ceil(x/y), r’’=x-y*q’’	0xA9, 0x06	Expand
161	MOD	DIV_BASE	#A908	arithm_div	A908	MOD	x y - r	26	where q=floor(x/y), r=x mod y=x-yq.	0xA9, 0x08	Expand
162	DIVMOD	DIV_BASE	#A90C	arithm_div	A90C	DIVMOD	x y - q r	26	where q=floor(x/y), r=x-yq.	0xA9, 0x0C	Expand
163	DIVMODR	DIV_BASE	#A90D	arithm_div	A90D	DIVMODR	x y - q' r'	26	where q' = floor(x/y + 1/2), r' = x - yq'.	0xA9, 0x0D	Expand
164	DIVMODC	DIV_BASE	#A90E	arithm_div	A90E	DIVMODC	x y - q'' r''	26	where q'' = ceil(x/y), r'' = x - yq''.	0xA9, 0x0E	Expand
165			#A924	arithm_div	A924	RSHIFT	x y - floor(x*c/2^y)				Expand
166	RSHIFTR_VAR	DIV_BASE	#A925	arithm_div	A925	RSHIFTR	x y - round(x/2^y)	26		0xA9, 0x25	Expand
167	RSHIFTC_VAR	DIV_BASE	#A926	arithm_div	A926	RSHIFTC	x y - ceil(x/2^y)	34		0xA9, 0x26	Expand
168			#A934 tt:uint8	arithm_div	A934tt	[tt+1] RSHIFT	x - x mod 2^(tt+1)	34			Expand
169	RSHIFTR	DIV_BASE	#A935 tt:uint8	arithm_div	A935tt	[tt+1] RSHIFTR#	x y - round(x/2^(tt+1))	34			Expand
170	RSHIFTC	DIV_BASE	#A936 tt:uint8	arithm_div	A936tt	[tt+1] RSHIFTC#	x y - ceil(x/2^(tt+1))	34			Expand
171	MODPOW2	DIV_BASE	#A938 tt:uint8	arithm_div	A938tt	[tt+1] MODPOW2#	x - x mod 2^(tt+1)	26			Expand
172	MULDIV	DIV_BASE	#A984	arithm_div	A98	MULDIV	x y z - q	26	q=floor(x*y/z)	0xA9, 0x84	Expand
173	MULDIVR	DIV_BASE	#A985	arithm_div	A985	MULDIVR	x y z - q'	26	q'=round(x*y/z)	0xA9, 0x85	Expand
174	MULDIVMOD	DIV_BASE	#A98C	arithm_div	A98C	MULDIVMOD	x y z - q r	26	q=floor(x*y/z), r=x*y-z*q	0xA9, 0x8C	Expand
175	MULRSHIFT_VAR	DIV_BASE	#A9A4	arithm_div	A9A4	MULRSHIFT	x y z - floor(x*y/2^z)	26	0 <= z <= 256	0xA9, 0xA4	Expand
176	MULRSHIFTR_VAR	DIV_BASE	#A9A5	arithm_div	A9A5	MULRSHIFTR	x y z - round(x*y/2^z)	26	0 <= z <= 256	0xA9, 0xA5	Expand
177	MULRSHIFTC_VAR	DIV_BASE	#A9A6	arithm_div	A9A6	MULRSHIFTC	x y z - ceil(x*y/2^z)	34	0 <= z <= 256	0xA9, 0xA6	Expand
178	MULRSHIFT	DIV_BASE	#A9B4 tt:uint8	arithm_div	A9B4tt	[tt+1] MULRSHIFT#	x y - floor(x*y/2^(tt+1))	34			Expand
179	MULRSHIFTR	DIV_BASE	#A9B5 tt:uint8	arithm_div	A9B5tt	[tt+1] MULRSHIFTR#	x y - round(x*y/2^(tt+1))	34			Expand
180	MULRSHIFTC	DIV_BASE	#A9B6 tt:uint8	arithm_div	A9B6tt	[tt+1] MULRSHIFTC#	x y - ceil(x*y/2^(tt+1))	26			Expand
181	LSHIFTDIV_VAR	DIV_BASE	#A9C4	arithm_div	A9C4	LSHIFTDIV	x y z - floor(2^z*x/y)	26	0 <= z <= 256	0xA9, 0xC4	Expand
182	LSHIFTDIVR_VAR	DIV_BASE	#A9C5	arithm_div	A9C5	LSHIFTDIVR	x y z - round(2^z*x/y)	26	0 <= z <= 256	0xA9, 0xC5	Expand
183	LSHIFTDIVC_VAR	DIV_BASE	#A9C6	arithm_div	A9C6	LSHIFTDIVC	x y z - ceil(2^z*x/y)	34	0 <= z <= 256	0xA9, 0xC6	Expand
184	LSHIFTDIV	DIV_BASE	#A9D4 tt:uint8	arithm_div	A9D4tt	[tt+1] LSHIFT#DIV	x y - floor(2^(tt+1)*x/y)	34			Expand
185	LSHIFTDIVR	DIV_BASE	#A9D5 tt:uint8	arithm_div	A9D5tt	[tt+1] LSHIFT#DIVR	x y - round(2^(tt+1)*x/y)	34			Expand
186	LSHIFTDIVC	DIV_BASE	#A9D6 tt:uint8	arithm_div	A9D6tt	[tt+1] LSHIFT#DIVC	x y - ceil(2^(tt+1)*x/y)	26			Expand
187	LSHIFT		#AA cc:uint8	arithm_logical	AAcc	[cc+1] LSHIFT#	x - x*2^(cc+1)	26	0 <= cc <= 255		Expand
188			#AA00	arithm_logical	AA00	[1] LSHIFT#			Equivalent to MULCONST 2 or to Forth's 2*.		Expand
189	RSHIFT		#AB cc:uint8	arithm_logical	ABcc	[cc+1] RSHIFT#	x - floor(x/2^(cc+1))	18	0 <= cc <= 255		Expand
190	LSHIFT_VAR		#AC	arithm_logical	AC	LSHIFT	x y - x*2^y	18	0 <= y <= 1023	0xAC	Expand
191	RSHIFT_VAR		#AD	arithm_logical	AD	RSHIFT	x y - floor(x/2^y)	18	0 <= y <= 1023	0xAD	Expand
192	POW2		#AE	arithm_logical	AE	POW2	y - 2^y	18	0 <= y <= 1023	0xAE	Expand
									Equivalent to ONE SWAP LSHIFT.
193	AND		#B0	arithm_logical	B0	AND	x y - x&y	18	Bitwise and of two signed integers x and y, sign-extended to infinity.	0xB0	Expand
194	OR		#B1	arithm_logical	B1	OR	x y - x|y	18	Bitwise or of two integers.	0xB1	Expand
195	XOR		#B2	arithm_logical	B2	XOR	x y - x xor y	18	Bitwise xor of two integers.	0xB2	Expand
196	NOT		#B3	arithm_logical	B3	NOT	x - ~x	26	Bitwise not of an integer.	0xB3	Expand
197	FITS		#B4 cc:uint8	arithm_logical	B4cc	[cc+1] FITS	x - x	26/76	Checks whether x is a cc+1-bit signed integer for 0 <= cc <= 255 (i.e., whether -2^cc <= x < 2^cc).	[z = parse_const_u8_plus_one] 0xB4, z	Expand
									If not, either triggers an integer overflow exception, or replaces x with a NaN (quiet version).
198	CHKBOOL	FITS	#B400	arithm_logical	B400	CHKBOOL	x - x	26/76	Checks whether x is a “boolean value'' (i.e., either 0 or -1).	0xB4, 0x00	Expand
199	UFITS		#B5 cc:uint8	arithm_logical	B5cc	[cc+1] UFITS	x - x	26/76	Checks whether x is a cc+1-bit unsigned integer for 0 <= cc <= 255 (i.e., whether 0 <= x < 2^(cc+1)).	[z = parse_const_u8_plus_one] 0xB5, z	Expand
200	CHKBIT	UFITS	#B500	arithm_logical	B500	CHKBIT	x - x	26/76	Checks whether x is a binary digit (i.e., zero or one).	0xB5, 0x00	Expand
201	FITSX		#B600	arithm_logical	B600	FITSX	x c - x	26/76	Checks whether x is a c-bit signed integer for 0 <= c <= 1023.	0xB6, 0x00	Expand
202	UFITSX		#B601	arithm_logical	B601	UFITSX	x c - x	26/76	Checks whether x is a c-bit unsigned integer for 0 <= c <= 1023.	0xB6, 0x01	Expand
203	BITSIZE		#B602	arithm_logical	B602	BITSIZE	x - c	26	Computes smallest c >= 0 such that x fits into a c-bit signed integer (-2^(c-1) <= c < 2^(c-1)).	0xB6, 0x02	Expand
204	UBITSIZE		#B603	arithm_logical	B603	UBITSIZE	x - c	26	Computes smallest c >= 0 such that x fits into a c-bit unsigned integer (0 <= x < 2^c), or throws a range check exception.	0xB6, 0x03	Expand
205	MIN		#B608	arithm_logical	B608	MIN	x y - x or y	26	Computes the minimum of two integers x and y.	0xB6, 0x08	Expand
206	MAX		#B609	arithm_logical	B609	MAX	x y - x or y	26	Computes the maximum of two integers x and y.	0xB6, 0x09	Expand
207	MINMAX		#B60A	arithm_logical	B60A	MINMAX	x y - x y or y x	26	Sorts two integers. Quiet version of this operation returns two NaNs if any of the arguments are NaNs.	0xB6, 0x0A	Expand
						INTSORT2
208	ABS		#B60B	arithm_logical	B60B	ABS	x - |x|	26	Computes the absolute value of an integer x.	0xB6, 0x0B	Expand
209	QUIET		#B7 xx:uint8	arthim_quiet	B7xx	QUIET			prefix, transforming any arithmetic operation into its "quiet" variant, indicated by prefixing a Q to its mnemonic. Such operations return NaNs instead of throwing integer overflow exceptions if the results do not fit in Integer's, or if one of their arguments is a NaN. Notice that this does not extend to shift amounts and other parameters that must be within a small range (e.g., 0-1023). Also notice that this does not disable type-checking exceptions if a value of a type other than Integer is supplied.		Expand
210	QADD		#B7A0	arithm_quiet	B7A0	QADD	x y - x+y	26	Always works if x and y are Integers, but returns a NaN if the addition cannot be performed.	0xB7, 0xA0	Expand
211	QSUB		#B7A1	arithm_quiet	B7A1	QSUB	x y - x-y	26		0xB7, 0xA1	Expand
212	QSUBR		#B7A2	arithm_quiet	B7A2	QSUBR	x y - y-x	26		0xB7, 0xA2	Expand
213	QNEGATE		#B7A3	arithm_quiet	B7A3	QNEGATE	x - -x	26		0xB7, 0xA3	Expand
214	QINC		#B7A4	arithm_quiet	B7A4	QINC	x - x+1	26		0xB7, 0xA4	Expand
215	QDEC		#B7A5	arithm_quiet	B7A5	QDEC	x - x-1	26		0xB7, 0xA5	Expand
216	QMUL		#B7A8	arithm_quiet	B7A8	QMUL	x y - x*y	26		0xB7, 0xA8	Expand
217	QDIV		#B7A904	arithm_quiet	B7A904	QDIV	x y - q	34	Division returns NaN if y=0.	0xB7, 0xA9, 0x04	Expand
218	QDIVR		#B7A905	arithm_quiet	B7A905	QDIVR	x y - q’	34		0xB7, 0xA9, 0x05	Expand
219	QDIVC		#B7A906	arithm_quiet	B7A906	QDIVC	x y - q''	34		0xB7, 0xA9, 0x06	Expand
220	QMOD		#B7A908	arithm_quiet	B7A908	QMOD	x y - r	34		0xB7, 0xA9, 0x08	Expand
221	QDIVMOD		#B7A90C	arithm_quiet	B7A90C	QDIVMOD	x y - q r	34		0xB7, 0xA9, 0x0C	Expand
222	QDIVMODR		#B7A90D	arithm_quiet	B7A90D	QDIVMODR	x y - q' r'	34		0xB7, 0xA9, 0x0D	Expand
223	QDIVMODC		#B7A90E	arithm_quiet	B7A90E	QDIVMODC	x y - q'' r''	34		0xB7, 0xA9, 0x0E	Expand
224	QMULDIVR		#B7A985	arithm_quiet	B7A985	QMULDIVR	x y z - q'	34		0xB7, 0xA9, 0x85	Expand
225	QMULDIVMOD		#B7A98C	arithm_quiet	B7A98C	QMULDIVMOD	x y z - q r	34		0xB7, 0xA9, 0x8C	Expand
226	QLSHIFT		#B7AC	arithm_quiet	B7AC	QLSHIFT	x y - x*2^y	26		0xB7, 0xAC	Expand
227	QRSHIFT		#B7AD	arithm_quiet	B7AD	QRSHIFT	x y - floor(x/2^y)	26		0xB7, 0xAD	Expand
228	QPOW2		#B7AE	arithm_quiet	B7AE	QPOW2	y - 2^y	26		0xB7, 0xAE	Expand
229	QAND		#B7B0	arithm_quiet	B7B0	QAND	x y - x&y	26	Bitwise and (similar to AND), but returns a NaN if either x or y is a NaN instead of throwing an integer overflow exception. However, if one of the arguments is zero, and the other is a NaN, the result is zero.	0xB7, 0xB0	Expand
230	QOR		#B7B1	arithm_quiet	B7B1	QOR	x y - x|y	26	Bitwise or. If x = -1 or y = -1, the result is always -1, even if the other argument is a NaN.	0xB7, 0xB1	Expand
231	QXOR		#B7B2	arithm_quiet	B7B2	QXOR	x y - x xor y	26		0xB7, 0xB2	Expand
232	QNOT		#B7B3	arithm_quiet	B7B3	QNOT	x - ~x	26		0xB7, 0xB3	Expand
233	QFITS		#B7B4 cc:uint8	arithm_quiet	B7B4cc	[cc+1] QFITS	x - x	34	Replaces x with a NaN if x is not a cc+1-bit signed integer, leaves it intact otherwise.	[z = parse_const_u8_plus_one] 0xB7, 0xB4, z	Expand
234	QUFITS		#B7B5 cc:uint8	arithm_quiet	B7B5cc	[cc+1] QUFITS	x - x	34	Replaces x with a NaN if x is not a cc+1-bit unsigned integer, leaves it intact otherwise.	[z = parse_const_u8_plus_one] 0xB7, 0xB5, z	Expand
235	QUFITS_8		#B7B507	arithm_quiet	B7B507	[8] QUFITS	x - x'	34	Checks whether x is an unsigned byte (i.e., whether 0 <= x < 2^8), and replaces x with a NaN if this is not the case; leaves x intact otherwise (i.e., if x is an unsigned byte).		Expand
236	QFITSX		#B7B600	arithm_quiet	B7B600	QFITSX	x c - x	34	Replaces x with a NaN if x is not a c-bit signed integer, leaves it intact otherwise.	0xB7, 0xB6, 0x00	Expand
237	QUFITSX		#B7B601	arithm_quiet	B7B601	QUFITSX	x c - x	34	Replaces x with a NaN if x is not a c-bit unsigned integer, leaves it intact otherwise.	0xB7, 0xB6, 0x01	Expand
238	SGN		#B8	compare_int	B8	SGN	x - sgn(x)	18	Computes the sign of an integer x:	0xB8	Expand
									-1 if x<0, 0 if x=0, 1 if x>0.
239	LESS		#B9	compare_int	B9	LESS	x y - x<y	18	Returns -1 if x<y, 0 otherwise.	0xB9	Expand
240	EQUAL		#BA	compare_int	BA	EQUAL	x y - x=y	18	Returns -1 if x=y, 0 otherwise.	0xBA	Expand
241	LEQ		#BB	compare_int	BB	LEQ	x y - x<=y	18		0xBB	Expand
242	GREATER		#BC	compare_int	BC	GREATER	x y - x>y	18		0xBC	Expand
243	NEQ		#BD	compare_int	BD	NEQ	x y - x!=y	18	Equivalent to EQUAL NOT.	0xBD	Expand
244	GEQ		#BE	compare_int	BE	GEQ	x y - x>=y	18	Equivalent to LESS NOT.	0xBE	Expand
245	CMP		#BF	compare_int	BF	CMP	x y - sgn(x-y)	18	Computes the sign of x-y:	0xBF	Expand
									-1 if x<y, 0 if x=y, 1 if x>y.
									No integer overflow can occur here unless x or y is a NaN.
246	EQINT		#C0 yy:int8	compare_int	C0yy	[yy] EQINT	x - x=yy	26	Returns -1 if x=yy, 0 otherwise.	[z = parse_const_i8] 0xC0, z	Expand
									-2^7 <= yy < 2^7.
247	ISZERO	EQINT	#C000	compare_int	C000	ISZERO	x - x=0	26	Checks whether an integer is zero. Corresponds to Forth's 0=.	0xC0, 0x00	Expand
248	LESSINT		#C1 yy:int8	compare_int	C1yy	[yy] LESSINT	x - x<yy	26	Returns -1 if x<yy, 0 otherwise.	[z = parse_const_i8] 0xC1, z	Expand
						[yy-1] LEQINT			-2^7 <= yy < 2^7.
249	ISNEG	LESSINT	#C100	compare_int	C100	ISNEG	x - x<0	26	Checks whether an integer is negative. Corresponds to Forth's 0<.	0xC1, 0x00	Expand
250	ISNPOS	LESSINT	#C101	compare_int	C101	ISNPOS	x - x<=0	26	Checks whether an integer is non-positive.	0xC1, 0x01	Expand
251	GTINT		#C2 yy:int8	compare_int	C2yy	[yy] GTINT	x - x>yy	26	Returns -1 if x>yy, 0 otherwise.	[z = parse_const_i8] 0xC2, z	Expand
						[yy+1] GEQINT			-2^7 <= yy < 2^7.
252	ISPOS	GTINT	#C200	compare_int	C200	ISPOS	x - x>0	26	Checks whether an integer is positive. Corresponds to Forth's 0>.	0xC2, 0x00	Expand
253	ISNNEG	GTINT	#C2FF	compare_int	C2FF	ISNNEG	x - x >=0	26	Checks whether an integer is non-negative.	0xC2, 0xFF	Expand
254	NEQINT		#C3 yy:int8	compare_int	C3yy	[yy] NEQINT	x - x!=yy	26	Returns -1 if x!=yy, 0 otherwise.	[z = parse_const_i8] 0xC3, z	Expand
									-2^7 <= yy < 2^7.
255	ISNAN		#C4	compare_int	C4	ISNAN	x - x=NaN	18	Checks whether x is a NaN.	0xC4	Expand
256	CHKNAN		#C5	compare_int	C5	CHKNAN	x - x	18/68	Throws an arithmetic overflow exception if x is a NaN.	0xC5	Expand
257	SEMPTY		#C700	compare_other	C700	SEMPTY	s - ?	26	Checks whether a Slice s is empty (i.e., contains no bits of data and no cell references).	0xC7, 0x00	Expand
258	SDEMPTY		#C701	compare_other	C701	SDEMPTY	s - ?	26	Checks whether Slice s has no bits of data.	0xC7, 0x01	Expand
259	SREMPTY		#C702	compare_other	C702	SREMPTY	s - ?	26	Checks whether Slice s has no references.	0xC7, 0x02	Expand
260	SDFIRST		#C703	compare_other	C703	SDFIRST	s - ?	26	Checks whether the first bit of Slice s is a one.	0xC7, 0x03	Expand
261	SDLEXCMP		#C704	compare_other	C704	SDLEXCMP	s s' - x	26	Compares the data of s lexicographically with the data of s', returning -1, 0, or 1 depending on the result.	0xC7, 0x04	Expand
262	SDEQ		#C705	compare_other	C705	SDEQ	s s' - ?	26	Checks whether the data parts of s and s' coincide, equivalent to SDLEXCMP ISZERO.	0xC7, 0x05	Expand
263	SDPFX		#C708	compare_other	C708	SDPFX	s s' - ?	26	Checks whether s is a prefix of s'.	0xC7, 0x08	Expand
264	SDPFXREV		#C709	compare_other	C709	SDPFXREV	s s' - ?	26	Checks whether s' is a prefix of s, equivalent to SWAP SDPFX.	0xC7, 0x09	Expand
265	SDPPFX		#C70A	compare_other	C70A	SDPPFX	s s' - ?	26	Checks whether s is a proper prefix of s' (i.e., a prefix distinct from s').	0xC7, 0x0A	Expand
266	SDPPFXREV		#C70B	compare_other	C70B	SDPPFXREV	s s' - ?	26	Checks whether s' is a proper prefix of s.	0xC7, 0x0B	Expand
267	SDSFX		#C70C	compare_other	C70C	SDSFX	s s' - ?	26	Checks whether s is a suffix of s'.	0xC7, 0x0C	Expand
268	SDSFXREV		#C70D	compare_other	C70D	SDSFXREV	s s' - ?	26	Checks whether s' is a suffix of s.	0xC7, 0x0D	Expand
269	SDPSFX		#C70E	compare_other	C70E	SDPSFX	s s' - ?	26	Checks whether s is a proper suffix of s'.	0xC7, 0x0E	Expand
270	SDPSFXREV		#C70F	compare_other	C70F	SDPSFXREV	s s' - ?	26	Checks whether s' is a proper suffix of s.	0xC7, 0x0F	Expand
271	SDCNTLEAD0		#C710	compare_other	C710	SDCNTLEAD0	s - n	26	Returns the number of leading zeroes in s.	0xC7, 0x10	Expand
272	SDCNTLEAD1		#C711	compare_other	C711	SDCNTLEAD1	s - n	26	Returns the number of leading ones in s.	0xC7, 0x11	Expand
273	SDCNTTRAIL0		#C712	compare_other	C712	SDCNTTRAIL0	s - n	26	Returns the number of trailing zeroes in s.	0xC7, 0x12	Expand
274	SDCNTTRAIL1		#C713	compare_other	C713	SDCNTTRAIL1	s - n	26	Returns the number of trailing ones in s.	0xC7, 0x13	Expand
275	DIFF		#C714	diff_operation	C714	DIFF	c c - c	26	Calculates diff between first and second parameters and returns it as cell.	0xC7, 0x14	Expand
276	DIFF_PATCH		#C715	diff_operation	C715	DIFF_PATCH	c c - c	26	Takes the first parameter as document, the second parameter as patch, received on DIFF command, applies patch and saves result document to cell.	0xC7, 0x15	Expand
277	ZIP		#C716	diff_operation	C716	ZIP	c - c	26	Zip string to cell	0xC7, 0x16	Expand
278	UNZIP		#C717	diff_operation	C717	UNZIP	c - c	26	Unzip cell to string	0xC7, 0x17	Expand
279	DIFF_ZIP		#C718	diff_operation	C718	DIFF_ZIP	c c - c	26	like DIFF but unzip parameters before operation and zip to cell after operation.	0xC7, 0x18	Expand
280	DIFF_PATCH_ZIP		#C719	diff_operation	C719	DIFF_PATCH_ZIP	c c - c	26	like DIFF_PATCH but unzip parameters before operation and zip to cell after operation.	0xC7, 0x19	Expand
281	DIFF_PATCH_Q		#C720	diff_operation	C720	DIFF_PATCH_Q	c c - c	26	quiet version of DIFF_PATCH	0xC7, 0x20	Expand
282	DIFF_PATCH_ZIPQ		#C721	diff_operation	C721	DIFF_PATCH_ZIPQ	c c - c	26	quiet version of DIFF_PATCH_ZIP	0xC7, 0x21	Expand
283	DIFF_PATCH_BINARY		#C722	diff_operation	C722	DIFF_PATCH_BINARY	c c - c	26	like DIFF_PATCH but takes and returns binary arrays instead of string.	0xC7, 0x22	Expand
284	DIFF_PATCH_BINARY_ZIP		#C723	diff_operation	C723	DIFF_PATCH_BINARY_ZIP	c c - c	26	like DIFF_PATCH_ZIP but takes and returns binary arrays instead of string.	0xC7, 0x23	Expand
285	DIFF_PATCH_BINARYQ		#C724	diff_operation	C724	DIFF_PATCH_BINARYQ	c c - c	26	like DIFF_PATCHQ but takes and returns binary arrays instead of string.	0xC7, 0x24	Expand
286	DIFF_PATCH_BINARY_ZIPQ		#C725	diff_operation	C725	DIFF_PATCH_BINARY_ZIPQ	c c - c	26	like DIFF_PATCH_ZIPQ but takes and returns binary arrays instead of string.	0xC7, 0x25	Expand
287	NEWC		#C8	cell_build	C8	NEWC	- b	18	Creates a new empty Builder.	0xC8	Expand
288	ENDC		#C9	cell_build	C9	ENDC	b - c	518	Converts a Builder into an ordinary Cell.	0xC9	Expand
289	STI		#CA cc:uint8	cell_build	CAcc	[cc+1] STI	x b - b'	26	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.	[z = parse_const_u8_plus_one] 0xCA, z	Expand
290	STU		#CB cc:uint8	cell_build	CBcc	[cc+1] STU	x b - b'	26	Stores an unsigned cc+1-bit integer x into Builder b. In all other respects it is similar to STI.	[z = parse_const_u8_plus_one] 0xCB, z	Expand
291	STREF		#CC	cell_build	CC	STREF	c b - b'	18	Stores a reference to Cell c into Builder b.	0xCC	Expand
292	STBREFR		#CD	cell_build	CD	STBREFR	b b'' - b	518	Equivalent to ENDC SWAP STREF.	0xCD	Expand
						ENDCST
293	STSLICE		#CE	cell_build	CE	STSLICE	s b - b'	18	Stores Slice s into Builder b.	0xCE	Expand
294	STIX		#CF00	cell_build	CF00	STIX	x b l - b'	26	Stores a signed l-bit integer x into b for 0 <= l <= 257.	0xCF, 0x00	Expand
295	STUX		#CF01	cell_build	CF01	STUX	x b l - b'	26	Stores an unsigned l-bit integer x into b for 0 <= l <= 256.	0xCF, 0x01	Expand
296	STIXR		#CF02	cell_build	CF02	STIXR	b x l - b'	26	Similar to STIX, but with arguments in a different order.	0xCF, 0x02	Expand
297	STUXR		#CF03	cell_build	CF03	STUXR	b x l - b'	26	Similar to STUX, but with arguments in a different order.	0xCF, 0x03	Expand
298	STIXQ		#CF04	cell_build	CF04	STIXQ	x b l - x b f or b' 0	26	A quiet version of STIX. If there is no space in b, sets b'=b and f=-1.	0xCF, 0x04	Expand
									If x does not fit into l bits, sets b'=b and f=1.
									If the operation succeeds, b' is the new Builder and f=0.
									However, 0 <= l <= 257, with a range check exception if this is not so.
299	STUXQ		#CF05	cell_build	CF05	STUXQ	x b l - x b f or b' 0	26	A quiet version of STUX.	0xCF, 0x05	Expand
300	STIXRQ		#CF06	cell_build	CF06	STIXRQ	b x l - b x f or b' 0	26	A quiet version of STIXR.	0xCF, 0x06	Expand
301	STUXRQ		#CF07	cell_build	CF07	STUXRQ	b x l - b x f or b' 0	26	A quiet version of STUXR.	0xCF, 0x07	Expand
302	STI_ALT		#CF08 cc:uint8	cell_build	CF08cc	[cc+1] STI_l	x b - b'	34	A longer version of [cc+1] STI.		Expand
303	STU_ALT		#CF09 cc:uint8	cell_build	CF09cc	[cc+1] STU_l	x b - b'	34	A longer version of [cc+1] STU.		Expand
304	STIR		#CF0A cc:uint8	cell_build	CF0Acc	[cc+1] STIR	b x - b'	34	Equivalent to SWAP [cc+1] STI.	[z = parse_const_u8_plus_one] 0xCF, 0x0A, z	Expand
305	STUR		#CF0B cc:uint8	cell_build	CF0Bcc	[cc+1] STUR	b x - b'	34	Equivalent to SWAP [cc+1] STU.	[z = parse_const_u8_plus_one] 0xCF, 0x0B, z	Expand
306	STIQ		#CF0C cc:uint8	cell_build	CF0Ccc	[cc+1] STIQ	x b - x b f or b' 0	34	A quiet version of STI.	[z = parse_const_u8_plus_one] 0xCF, 0x0C, z	Expand
307	STUQ		#CF0D cc:uint8	cell_build	CF0Dcc	[cc+1] STUQ	x b - x b f or b' 0	34	A quiet version of STU.	[z = parse_const_u8_plus_one] 0xCF, 0x0D, z	Expand
308	STIRQ		#CF0E cc:uint8	cell_build	CF0Ecc	[cc+1] STIRQ	b x - b x f or b' 0	34	A quiet version of STIR.	[z = parse_const_u8_plus_one] 0xCF, 0x0E, z	Expand
309	STURQ		#CF0F cc:uint8	cell_build	CF0Fcc	[cc+1] STURQ	b x - b x f or b' 0	34	A quiet version of STUR.	[z = parse_const_u8_plus_one] 0xCF, 0x0F, z	Expand
310	STREF_ALT		#CF10	cell_build	CF10	STREF_l	c b - b'	26	A longer version of STREF.	0xCF, 0x10	Expand
311	STBREF		#CF11	cell_build	CF11	STBREF	b' b - b''	526	Equivalent to SWAP STBREFR.	0xCF, 0x11	Expand
312	STSLICE_ALT		#CF12	cell_build	CF12	STSLICE_l	s b - b'	26	A longer version of STSLICE.	0xCF, 0x12	Expand
313	STB		#CF13	cell_build	CF13	STB	b' b - b''	26	Appends all data from Builder b' to Builder b.	0xCF, 0x13	Expand
314	STREFR		#CF14	cell_build	CF14	STREFR	b c - b'	26	Equivalent to SWAP STREF.	0xCF, 0x14	Expand
315	STBREFR_ALT		#CF15	cell_build	CF15	STBREFR_l	b b' - b''	526	A longer encoding of STBREFR.	0xCF, 0x15	Expand
316	STSLICER		#CF16	cell_build	CF16	STSLICER	b s - b'	26	Equivalent to SWAP STSLICE.	0xCF, 0x16	Expand
317	STBR		#CF17	cell_build	CF17	STBR	b b' - b''	26	Concatenates two builders.	0xCF, 0x17	Expand
						BCONCAT			Equivalent to SWAP STB.
318	STREFQ		#CF18	cell_build	CF18	STREFQ	c b - c b -1 or b' 0	26	Quiet version of STREF.	0xCF, 0x18	Expand
319	STBREFQ		#CF19	cell_build	CF19	STBREFQ	b' b - b' b -1 or b'' 0	526	Quiet version of STBREF.	0xCF, 0x19	Expand
320	STSLICEQ		#CF1A	cell_build	CF1A	STSLICEQ	s b - s b -1 or b' 0	26	Quiet version of STSLICE.	0xCF, 0x1A	Expand
321	STBQ		#CF1B	cell_build	CF1B	STBQ	b' b - b' b -1 or b'' 0	26	Quiet version of STB.	0xCF, 0x1B	Expand
322	STREFRQ		#CF1C	cell_build	CF1C	STREFRQ	b c - b c -1 or b' 0	26	Quiet version of STREFR.	0xCF, 0x1C	Expand
323	STBREFRQ		#CF1D	cell_build	CF1D	STBREFRQ	b b' - b b' -1 or b'' 0	526	Quiet version of STBREFR.	0xCF, 0x1D	Expand
324	STSLICERQ		#CF1E	cell_build	CF1E	STSLICERQ	b s - b s -1 or b'' 0	26	Quiet version of STSLICER.	0xCF, 0x1E	Expand
325	STBRQ		#CF1F	cell_build	CF1F	STBRQ	b b' - b b' -1 or b'' 0	26	Quiet version of STBR.	0xCF, 0x1F	Expand
						BCONCATQ
326	STREFCONST		#CF20 c:^Cell	cell_build	CF20	[ref] STREFCONST	b - b’	26	Equivalent to PUSHREF STREFR.	0xCF, 0x20	Expand
327	STREF2CONST		#CF21 c1:^Cell c2:^Cell	cell_build	CF21	[ref][ref] STREF2CONST	b - b’	26	Equivalent to STREFCONST STREFCONST.	0xCF, 0x21	Expand
328	ENDXC		#CF23	cell_build	CF23		b x - c	526	If x!=0, creates a special or exotic cell from Builder b.	0xCF, 0x23	Expand
									The type of the exotic cell must be stored in the first 8 bits of b.
									If x=0, it is equivalent to ENDC. Otherwise some validity checks on the data and references of b are performed before creating the exotic cell.
329	STILE4		#CF28	cell_build	CF28	STILE4	x b - b'	26	Stores a little-endian signed 32-bit integer.	0xCF, 0x28	Expand
330	STULE4		#CF29	cell_build	CF29	STULE4	x b - b'	26	Stores a little-endian unsigned 32-bit integer.	0xCF, 0x29	Expand
331	STILE8		#CF2A	cell_build	CF2A	STILE8	x b - b'	26	Stores a little-endian signed 64-bit integer.	0xCF, 0x2A	Expand
332	STULE8		#CF2B	cell_build	CF2B	STULE8	x b - b'	26	Stores a little-endian unsigned 64-bit integer.	0xCF, 0x2B	Expand
333	BDEPTH		#CF30	cell_build	CF30	BDEPTH	b - x	26	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.	0xCF, 0x30	Expand
334	BBITS		#CF31	cell_build	CF31	BBITS	b - x	26	Returns the number of data bits already stored in Builder b.	0xCF, 0x31	Expand
335	BREFS		#CF32	cell_build	CF32	BREFS	b - y	26	Returns the number of cell references already stored in b.	0xCF, 0x32	Expand
336	BBITREFS		#CF33	cell_build	CF33	BBITREFS	b - x y	26	Returns the numbers of both data bits and cell references in b.	0xCF, 0x33	Expand
337	BREMBITS		#CF35	cell_build	CF35	BREMBITS	b - x'	26	Returns the number of data bits that can still be stored in b.	0xCF, 0x35	Expand
338	BREMREFS		#CF36	cell_build	CF36	BREMREFS	b - y'	26	Returns the number of references that can still be stored in b.	0xCF, 0x36	Expand
339	BREMBITREFS		#CF37	cell_build	CF37	BREMBITREFS	b - x' y'	26	Returns the numbers of both data bits and references that can still be stored in b.	0xCF, 0x37	Expand
340	BCHKBITS		#CF38 cc:uint8	cell_build	CF38cc	[cc+1] BCHKBITS#	b -	34/84	Checks whether cc+1 bits can be stored into b, where 0 <= cc <= 255.		Expand
341	BCHKBITS_VAR		#CF39	cell_build	CF39	BCHKBITS	b x -	26/76	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.	0xCF, 0x39	Expand
342	BCHKREFS		#CF3A	cell_build	CF3A	BCHKREFS	b y -	26/76	Checks whether y references can be stored into b, 0 <= y <= 7.	0xCF, 0x3A	Expand
343	BCHKBITREFS		#CF3B	cell_build	CF3B	BCHKBITREFS	b x y -	26/76	Checks whether x bits and y references can be stored into b, 0 <= x <= 1023, 0 <= y <= 7.	0xCF, 0x3B	Expand
344	BCHKBITSQ		#CF3C cc:uint8	cell_build	CF3Ccc	[cc+1] BCHKBITSQ#	b - ?	34	Checks whether cc+1 bits can be stored into b, where 0 <= cc <= 255.		Expand
345	BCHKBITSQ_VAR		#CF3D	cell_build	CF3D	BCHKBITSQ	b x - ?	26	Checks whether x bits can be stored into b, 0 <= x <= 1023.	0xCF, 0x3D	Expand
346	BCHKREFSQ		#CF3E	cell_build	CF3E	BCHKREFSQ	b y - ?	26	Checks whether y references can be stored into b, 0 <= y <= 7.	0xCF, 0x3E	Expand
347	BCHKBITREFSQ		#CF3F	cell_build	CF3F	BCHKBITREFSQ	b x y - ?	26	Checks whether x bits and y references can be stored into b, 0 <= x <= 1023, 0 <= y <= 7.	0xCF, 0x3F	Expand
348	STZEROES		#CF40	cell_build	CF40	STZEROES	b n - b'	26	Stores n binary zeroes into Builder b.	0xCF, 0x40	Expand
349	STONES		#CF41	cell_build	CF41	STONES	b n - b'	26	Stores n binary ones into Builder b.	0xCF, 0x41	Expand
350	STSAME		#CF42	cell_build	CF42	STSAME	b n x - b'	26	Stores n binary xes (0 <= x <= 1) into Builder b.	0xCF, 0x42	Expand
351	STCONT		#CF43	cell_build	CF43	STCONT	cont b - b'	26	Stores Continuation cont into Builder b.	0xCF, 0x43	Expand
352	STSLICECONST		#CFC0_ x:(## 2) y:(## 3) c:(x ^Cell) sss:((8 y + 2) * Bit)	cell_build	CFC0_xysss	[slice] STSLICECONST	b - b'	24	Stores a constant subslice sss.		Expand
									Details: sss consists of 0 <= x <= 3 references and up to 8y+2 data bits, with 0 <= y <= 7. Completion bit is assumed.
									Note that the assembler can replace STSLICECONST with PUSHSLICE STSLICER if the slice is too big.
353	STZERO	STSLICECONST	#CF81	cell_build	CF81	STZERO	b - b'	24	Stores one binary zero.	0xCF, 0x81	Expand
354	STONE	STSLICECONST	#CF83	cell_build	CF83	STONE	b - b'	24	Stores one binary one.	0xCF, 0x83	Expand
355	CTOS		#D0	cell_parse	D0	CTOS	c - s	118/43	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.	0xD0	Expand
356	ENDS		#D1	cell_parse	D1	ENDS	s -	18/68	Removes a Slice s from the stack, and throws an exception if it is not empty.	0xD1	Expand
357	LDI		#D2 cc:uint8	cell_parse	D2cc	[cc+1] LDI	s - x s'	26	Loads (i.e., parses) a signed cc+1-bit integer x from Slice s, and returns the remainder of s as s'.		Expand
358	LDU		#D3 cc:uint8	cell_parse	D3cc	[cc+1] LDU	s - x s'	26	Loads an unsigned cc+1-bit integer x from Slice s.	[cc = parse_const_u8_plus_one] 0xD2, cc	Expand
359	LDREF		#D4	cell_parse	D4	LDREF	s - c s'	18	Loads a cell reference c from s.	0xD4	Expand
360	LDREFRTOS		#D5	cell_parse	D5	LDREFRTOS	s - s' s''	118/43	Equivalent to LDREF SWAP CTOS.	0xD5	Expand
361	LDSLICE		#D6 cc:uint8	cell_parse	D6cc	[cc+1] LDSLICE	s - s'' s'	26	Cuts the next cc+1 bits of s into a separate Slice s''.	[cc = parse_const_u8_plus_one] 0xD6, cc	Expand
362	LDIX		#D700	cell_parse	D700	LDIX	s l - x s'	26	Loads a signed l-bit (0 <= l <= 257) integer x from Slice s, and returns the remainder of s as s'.	0xD7, 0x00	Expand
363	LDUX		#D701	cell_parse	D701	LDUX	s l - x s'	26	Loads an unsigned l-bit integer x from (the first l bits of) s, with 0 <= l <= 256.	0xD7, 0x01	Expand
364	PLDIX		#D702	cell_parse	D702	PLDIX	s l - x	26	Preloads a signed l-bit integer from Slice s, for 0 <= l <= 257.	0xD7, 0x02	Expand
365	PLDUX		#D703	cell_parse	D703	PLDUX	s l - x	26	Preloads an unsigned l-bit integer from s, for 0 <= l <= 256.	0xD7, 0x03	Expand
366	LDIXQ		#D704	cell_parse	D704	LDIXQ	s l - x s' -1 or s 0	26	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.	0xD7, 0x04	Expand
367	LDUXQ		#D705	cell_parse	D705	LDUXQ	s l - x s' -1 or s 0	26	Quiet version of LDUX.	0xD7, 0x05	Expand
368	PLDIXQ		#D706	cell_parse	D706	PLDIXQ	s l - x -1 or 0	26	Quiet version of PLDIX.	0xD7, 0x06	Expand
369	PLDUXQ		#D707	cell_parse	D707	PLDUXQ	s l - x -1 or 0	26	Quiet version of PLDUX.	0xD7, 0x08	Expand
370	LDI_ALT		#D708 cc:uint8	cell_parse	D708cc	[cc+1] LDI_l	s - x s'	34	A longer encoding for LDI.		Expand
371	LDU_ALT		#D709 cc:uint8	cell_parse	D709cc	[cc+1] LDU_l	s - x s'	34	A longer encoding for LDU.		Expand
372	PLDI		#D70A cc:uint8	cell_parse	D70Acc	[cc+1] PLDI	s - x	34	Preloads a signed cc+1-bit integer from Slice s.	[cc = parse_const_u8_plus_one] 0xD7, 0x0A, cc	Expand
373	PLDU		#D70B cc:uint8	cell_parse	D70Bcc	[cc+1] PLDU	s - x	34	Preloads an unsigned cc+1-bit integer from s.	[cc = parse_const_u8_plus_one] 0xD7, 0x0B, cc	Expand
374	LDIQ		#D70C cc:uint8	cell_parse	D70Ccc	[cc+1] LDIQ	s - x s' -1 or s 0	34	A quiet version of LDI.	[cc = parse_const_u8_plus_one] 0xD7, 0x0C, cc	Expand
375	LDUQ		#D70D cc:uint8	cell_parse	D70Dcc	[cc+1] LDUQ	s - x s' -1 or s 0	34	A quiet version of LDU.	[cc = parse_const_u8_plus_one] 0xD7, 0x0D, cc	Expand
376	PLDIQ		#D70E cc:uint8	cell_parse	D70Ecc	[cc+1] PLDIQ	s - x -1 or 0	34	A quiet version of PLDI.	[cc = parse_const_u8_plus_one] 0xD7, 0x0E, cc	Expand
377	PLDUQ		#D70F cc:uint8	cell_parse	D70Fcc	[cc+1] PLDUQ	s - x -1 or 0	34	A quiet version of PLDU.	[cc = parse_const_u8_plus_one] 0xD7, 0x0F, cc	Expand
378	PLDUZ		#D714_ c:uint3	cell_parse	D714_c	[32(c+1)] PLDUZ	s - s x	26	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.	[c = parse_plduz_parameter] 0xD7, 0x10 | c	Expand
379	LDSLICEX		#D718	cell_parse	D718	LDSLICEX	s l - s'' s'	26	Loads the first 0 <= l <= 1023 bits from Slice s into a separate Slice s'', returning the remainder of s as s'.	0xD7, 0x18	Expand
380	PLDSLICEX		#D719	cell_parse	D719	PLDSLICEX	s l - s''	26	Returns the first 0 <= l <= 1023 bits of s as s''.	0xD7, 0x19	Expand
381	LDSLICEXQ		#D71A	cell_parse	D71A	LDSLICEXQ	s l - s'' s' -1 or s 0	26	A quiet version of LDSLICEX.	0xD7, 0x1A	Expand
382	PLDSLICEXQ		#D71B	cell_parse	D71B	PLDSLICEXQ	s l - s' -1 or 0	26	A quiet version of LDSLICEXQ.	0xD7, 0x1B	Expand
383	LDSLICE_ALT		#D71C cc:uint8	cell_parse	D71Ccc	[cc+1] LDSLICE_l	s - s'' s'	34	A longer encoding for LDSLICE.		Expand
384	PLDSLICE		#D71D cc:uint8	cell_parse	D71Dcc	[cc+1] PLDSLICE	s - s''	34	Returns the first 0 < cc+1 <= 256 bits of s as s''.	[cc = parse_const_u8_plus_one] 0xD7, 0x1D, cc	Expand
385	LDSLICEQ		#D71E cc:uint8	cell_parse	D71Ecc	[cc+1] LDSLICEQ	s - s'' s' -1 or s 0	34	A quiet version of LDSLICE.	[cc = parse_const_u8_plus_one] 0xD7, 0x1E, cc	Expand
386	PLDSLICEQ		#D71F cc:uint8	cell_parse	D71Fcc	[cc+1] PLDSLICEQ	s - s'' -1 or 0	34	A quiet version of PLDSLICE.	[cc = parse_const_u8_plus_one] 0xD7, 0x1F, cc	Expand
387	SDCUTFIRST		#D720	cell_parse	D720	SDCUTFIRST	s l - s'	26	Returns the first 0 <= l <= 1023 bits of s. It is equivalent to PLDSLICEX.	0xD7, 0x20	Expand
388	SDSKIPFIRST		#D721	cell_parse	D721	SDSKIPFIRST	s l - s'	26	Returns all but the first 0 <= l <= 1023 bits of s. It is equivalent to LDSLICEX NIP.	0xD7, 0x21	Expand
389	SDCUTLAST		#D722	cell_parse	D722	SDCUTLAST	s l - s'	26	Returns the last 0 <= l <= 1023 bits of s.	0xD7, 0x22	Expand
390	SDSKIPLAST		#D723	cell_parse	D723	SDSKIPLAST	s l - s'	26	Returns all but the last 0 <= l <= 1023 bits of s.	0xD7, 0x23	Expand
391	SDSUBSTR		#D724	cell_parse	D724	SDSUBSTR	s l l' - s'	26	Returns 0 <= l' <= 1023 bits of s starting from offset 0 <= l <= 1023, thus extracting a bit substring out of the data of s.	0xD7, 0x24	Expand
392	SDBEGINSX		#D726	cell_parse	D726	SDBEGINSX	s s' - s''	26	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.	0xD7, 0x26	Expand
393	SDBEGINSXQ		#D727	cell_parse	D727	SDBEGINSXQ	s s' - s'' -1 or s 0	26	A quiet version of SDBEGINSX.	0xD7, 0x27	Expand
394	SDBEGINS		#D72A_ x:(## 7) sss:((8 x + 3) Bit)	cell_parse	D72A_xsss	[slice] SDBEGINS	s - s''	31	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.		Expand
395	SDBEGINS_0		#D72802	cell_parse	D72802	[0] SDBEGINS	s - s''	31	Checks whether s begins with a binary zero.		Expand
396	SDBEGINS_1		#D72806	cell_parse	D72802	[1] SDBEGINS	s - s''	31	Checks whether s begins with a binary one.		Expand
397	SDBEGINSQ		#D72E_ x:(## 7) sss:((8 x + 3) Bit)	cell_parse	D72E_xsss	[slice] SDBEGINSQ	s - s'' -1 or s 0	31	A quiet version of SDBEGINS.		Expand
398	SCUTFIRST		#D730	cell_parse	D730	SCUTFIRST	s l r - s'	26	Returns the first 0 <= l <= 1023 bits and first 0 <= r <= 4 references of s.	0xD7, 0x30	Expand
399	SSKIPFIRST		#D731	cell_parse	D731	SSKIPFIRST	s l r - s'	26	Returns all but the first l bits of s and r references of s.	0xD7, 0x31	Expand
400	SCUTLAST		#D732	cell_parse	D732	SCUTLAST	s l r - s'	26	Returns the last 0 <= l <= 1023 data bits and last 0 <= r <= 4 references of s.	0xD7, 0x32	Expand
401	SSKIPLAST		#D733	cell_parse	D733	SSKIPLAST	s l r - s'	26	Returns all but the last l bits of s and r references of s.	0xD7, 0x33	Expand
402	SUBSLICE		#D734	cell_parse	D734	SUBSLICE	s l r l' r' - s'	26	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.	0xD7, 0x34	Expand
403	SPLIT		#D736	cell_parse	D736	SPLIT	s l r - s' s''	26	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''.	0xD7, 0x36	Expand
404	SPLITQ		#D737	cell_parse	D737	SPLITQ	s l r - s' s'' -1 or s 0	26	A quiet version of SPLIT.	0xD7, 0x37	Expand
405	XCTOS		#D739	cell_parse	D739		c - s ?		Transforms an ordinary or exotic cell into a Slice, as if it were an ordinary cell. A flag is returned indicating whether c is exotic. If that be the case, its type can later be deserialized from the first eight bits of s.	0xD7, 0x39	Expand
406	XLOAD		#D73A	cell_parse	D73A		c - c'		Loads an exotic cell c and returns an ordinary cell c'. If c is already ordinary, does nothing. If c cannot be loaded, throws an exception.	0xD7, 0x3A	Expand
407	XLOADQ		#D73B	cell_parse	D73B		c - c' -1 or c 0		Loads an exotic cell c and returns an ordinary cell c'. If c is already ordinary, does nothing. If c cannot be loaded, returns 0.	0xD7, 0x3B	Expand
408	SCHKBITS		#D741	cell_parse	D741	SCHKBITS	s l -	26/76	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.	0xD7, 0x41	Expand
409	SCHKREFS		#D742	cell_parse	D742	SCHKREFS	s r -	26/76	Checks whether there are at least r references in Slice s.	0xD7, 0x42	Expand
410	SCHKBITREFS		#D743	cell_parse	D743	SCHKBITREFS	s l r -	26/76	Checks whether there are at least l data bits and r references in Slice s.	0xD7, 0x43	Expand
411	SCHKBITSQ		#D745	cell_parse	D745	SCHKBITSQ	s l - ?	26	Checks whether there are at least l data bits in Slice s.	0xD7, 0x45	Expand
412	SCHKREFSQ		#D746	cell_parse	D746	SCHKREFSQ	s r - ?	26	Checks whether there are at least r references in Slice s.	0xD7, 0x46	Expand
413	SCHKBITREFSQ		#D747	cell_parse	D747	SCHKBITREFSQ	s l r - ?	26	Checks whether there are at least l data bits and r references in Slice s.	0xD7, 0x47	Expand
414	PLDREFVAR		#D748	cell_parse	D748	PLDREFVAR	s n - c	26	Returns the n-th cell reference of Slice s for 0 <= n <= 3.	0xD7, 0x48	Expand
415	SBITS		#D749	cell_parse	D749	SBITS	s - l	26	Returns the number of data bits in Slice s.	0xD7, 0x49	Expand
416	SREFS		#D74A	cell_parse	D74A	SREFS	s - r	26	Returns the number of references in Slice s.	0xD7, 0x4A	Expand
417	SBITREFS		#D74B	cell_parse	D74B	SBITREFS	s - l r	26	Returns both the number of data bits and the number of references in s.	0xD7, 0x4B	Expand
418	PLDREFIDX		#D74E_ n:uint2	cell_parse	D74E_n	[n] PLDREFIDX	s - c	26	Returns the n-th cell reference of Slice s, where 0 <= n <= 3.	[n = parse_const_u2] 0xD7, 0x4C | n	Expand
419	PLDREF	PLDREFIDX	#D74C	cell_parse	D74C	PLDREF	s - c	26	Preloads the first cell reference of a Slice.	0xD7, 0x4C	Expand
420	LDILE4		#D750	cell_parse	D750	LDILE4	s - x s'	26	Loads a little-endian signed 32-bit integer.	0xD7, 0x50	Expand
421	LDULE4		#D751	cell_parse	D751	LDULE4	s - x s'	26	Loads a little-endian unsigned 32-bit integer.	0xD7, 0x51	Expand
422	LDILE8		#D752	cell_parse	D752	LDILE8	s - x s'	26	Loads a little-endian signed 64-bit integer.	0xD7, 0x52	Expand
423	LDULE8		#D753	cell_parse	D753	LDULE8	s - x s'	26	Loads a little-endian unsigned 64-bit integer.	0xD7, 0x53	Expand
424	PLDILE4		#D754	cell_parse	D754	PLDILE4	s - x	26	Preloads a little-endian signed 32-bit integer.	0xD7, 0x54	Expand
425	PLDULE4		#D755	cell_parse	D755	PLDULE4	s - x	26	Preloads a little-endian unsigned 32-bit integer.	0xD7, 0x55	Expand
426	PLDILE8		#D756	cell_parse	D756	PLDILE8	s - x	26	Preloads a little-endian signed 64-bit integer.	0xD7, 0x56	Expand
427	PLDULE8		#D757	cell_parse	D757	PLDULE8	s - x	26	Preloads a little-endian unsigned 64-bit integer.	0xD7, 0x57	Expand
428	LDILE4Q		#D758	cell_parse	D758	LDILE4Q	s - x s' -1 or s 0	26	Quietly loads a little-endian signed 32-bit integer.	0xD7, 0x58	Expand
429	LDULE4Q		#D759	cell_parse	D759	LDULE4Q	s - x s' -1 or s 0	26	Quietly loads a little-endian unsigned 32-bit integer.	0xD7, 0x59	Expand
430	LDILE8Q		#D75A	cell_parse	D75A	LDILE8Q	s - x s' -1 or s 0	26	Quietly loads a little-endian signed 64-bit integer.	0xD7, 0x5A	Expand
431	LDULE8Q		#D75B	cell_parse	D75B	LDULE8Q	s - x s' -1 or s 0	26	Quietly loads a little-endian unsigned 64-bit integer.	0xD7, 0x5B	Expand
432	PLDILE4Q		#D75C	cell_parse	D75C	PLDILE4Q	s - x -1 or 0	26	Quietly preloads a little-endian signed 32-bit integer.	0xD7, 0x5C	Expand
433	PLDULE4Q		#D75D	cell_parse	D75D	PLDULE4Q	s - x -1 or 0	26	Quietly preloads a little-endian unsigned 32-bit integer.	0xD7, 0x5D	Expand
434	PLDILE8Q		#D75E	cell_parse	D75E	PLDILE8Q	s - x -1 or 0	26	Quietly preloads a little-endian signed 64-bit integer.	0xD7, 0x5E	Expand
435	PLDULE8Q		#D75F	cell_parse	D75F	PLDULE8Q	s - x -1 or 0	26	Quietly preloads a little-endian unsigned 64-bit integer.	0xD7, 0x5F	Expand
436	LDZEROES		#D760	cell_parse	D760	LDZEROES	s - n s'	26	Returns the count n of leading zero bits in s, and removes these bits from s.	0xD7, 0x60	Expand
437	LDONES		#D761	cell_parse	D761	LDONES	s - n s'	26	Returns the count n of leading one bits in s, and removes these bits from s.	0xD7, 0x61	Expand
438	LDSAME		#D762	cell_parse	D762	LDSAME	s x - n s'	26	Returns the count n of leading bits equal to 0 <= x <= 1 in s, and removes these bits from s.	0xD7, 0x62	Expand
439	SDEPTH		#D764	cell_parse	D764	SDEPTH	s - x	26	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.	0xD7, 0x64	Expand
440	CDEPTH		#D765	cell_parse	D765	CDEPTH	c - x	26	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.	0xD7, 0x65	Expand
441	LDCONT		#D766	cell_parse	D766	LDCONT	s - cont s'	26	Loads a continuation cont from s.	0xD7, 0x66	Expand
442	EXECUTE		#D8	cont_basic	D8	EXECUTE	c -	18	Calls, or executes, continuation c.	0xD8	Expand
						CALLX
443	JMPX		#D9	cont_basic	D9	JMPX	c -	18	Jumps, or transfers control, to continuation c.	0xD9	Expand
									The remainder of the previous current continuation cc is discarded.
444	CALLXARGS		#DA p:uint4 r:uint4	cont_basic	DApr	[p][r] CALLXARGS	c -	26	Calls continuation c with p parameters and expecting r return values		Expand
									0 <= p <= 15, 0 <= r <= 15
445	CALLXARGS_VAR		#DB0 p:uint4	cont_basic	DB0p	[p] -1 CALLXARGS	c -	26	Calls continuation c with 0 <= p <= 15 parameters, expecting an arbitrary number of return values.		Expand
446	JMPXARGS		#DB1 p:uint4	cont_basic	DB1p	[p] JMPXARGS	c -	26	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).	[p = parse_const_u4] 0xDB, 0x10 | p	Expand
447	RETARGS		#DB2 r:uint4	cont_basic	DB2r	[r] RETARGS		26	Returns to c0, with 0 <= r <= 15 return values taken from the current stack.	[r = parse_const_u4] 0xDB, 0x20 | r	Expand
448	RET		#DB30	cont_basic	DB30	RET		26	Returns to the continuation at c0. The remainder of the current continuation cc is discarded.	0xDB, 0x30	Expand
						RETTRUE			Approximately equivalent to c0 PUSHCTR JMPX.
449	RETALT		#DB31	cont_basic	DB31	RETALT		26	Returns to the continuation at c1.	0xDB, 0x31	Expand
						RETFALSE			Approximately equivalent to c1 PUSHCTR JMPX.
450	BRANCH		#DB32	cont_basic	DB32	BRANCH	f -	26	Performs RETTRUE if integer f!=0, or RETFALSE if f=0.	0xDB, 0x32	Expand
						RETBOOL
451	CALLCC		#DB34	cont_basic	DB34	CALLCC	c -	26	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).	0xDB, 0x34	Expand
452	JMPXDATA		#DB35	cont_basic	DB35	JMPXDATA	c -	26	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.	0xDB, 0x35	Expand
453	CALLCCARGS		#DB36 p:uint4 r:uint4	cont_basic	DB36pr	[p][r] CALLCCARGS	c -	34	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.	[c1 = parse_const_u4][c2 = parse_const_i4] 0xDB, 0x36, (c1 << 4) | c2	Expand
454	CALLXVARARGS		#DB38	cont_basic	DB38	CALLXVARARGS	c p r -	26	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.	0xDB, 0x38	Expand
455	RETVARARGS		#DB39	cont_basic	DB39	RETVARARGS	p r -	26	Similar to RETARGS.	0xDB, 0x39	Expand
456	JMPXVARARGS		#DB3A	cont_basic	DB3A	JMPXVARARGS	c p r -	26	Similar to JMPXARGS.	0xDB, 0x3A	Expand
457	CALLCCVARARGS		#DB3B	cont_basic	DB3B	CALLCCVARARGS	c p r -	26	Similar to CALLCCARGS.	0xDB, 0x3B	Expand
458	CALLREF		#DB3C c:^Cell	cont_basic	DB3C	[ref] CALLREF		126/51	Equivalent to PUSHREFCONT CALLX.		Expand
459	JMPREF		#DB3D c:^Cell	cont_basic	DB3D	[ref] JMPREF		126/51	Equivalent to PUSHREFCONT JMPX.		Expand
460	JMPREFDATA		#DB3E c:^Cell	cont_basic	DB3E	[ref] JMPREFDATA		126/51	Equivalent to PUSHREFCONT JMPXDATA.	0xDB, 0x3E	Expand
461	RETDATA		#DB3F	cont_basic	DB3F	RETDATA		26	Equivalent to c0 PUSHCTR JMPXDATA. In this way, the remainder of the current continuation is converted into a Slice and returned to the caller.	0xDB, 0x3F	Expand
462	IFRET		#DC	cont_conditional	DC	IFRET	f -	18	Performs a RET, but only if integer f is non-zero. If f is a NaN, throws an integer overflow exception.	0xDC	Expand
						IFNOT:
463	IFNOTRET		#DD	cont_conditional	DD	IFNOTRET	f -	18	Performs a RET, but only if integer f is zero.	0xDD	Expand
						IF:
464	IF		#DE	cont_conditional	DE	IF	f c -	18	Performs EXECUTE for c (i.e., executes c), but only if integer f is non-zero. Otherwise simply discards both values.	0xDE	Expand
465				cont_conditional	DE	IF:<{ code }>	f -		Equivalent to <{ code }> CONT IF.		Expand
						<{ code }>IF
466	IFNOT		#DF	cont_conditional	DF	IFNOT	f c -	18	Executes continuation c, but only if integer f is zero. Otherwise simply discards both values.	0xDF	Expand
467				cont_conditional	DF	IFNOT:<{ code }>	f -		Equivalent to <{ code }> CONT IFNOT.		Expand
						<{ code }>IFNOT
468	IFJMP		#E0	cont_conditional	E0	IFJMP	f c -	18	Jumps to c (similarly to JMPX), but only if f is non-zero.	0xE0	Expand
469				cont_conditional	E0	IFJMP:<{ code }>	f -		Equivalent to <{ code }> CONT IFJMP.		Expand
470	IFNOTJMP		#E1	cont_conditional	E1	IFNOTJMP	f c -	18	Jumps to c (similarly to JMPX), but only if f is zero.	0xE1	Expand
471				cont_conditional	E1	IFNOTJMP:<{ code }>	f -		Equivalent to <{ code }> CONT IFNOTJMP.		Expand
472	IFELSE		#E2	cont_conditional	E2	IFELSE	f c c' -	18	If integer f is non-zero, executes c, otherwise executes c'. Equivalent to CONDSELCHK EXECUTE.	0xE2	Expand
473				cont_conditional	E2	IF:<{ code1 }>ELSE<{ code2 }>	f -		Equivalent to <{ code1 }> CONT <{ code2 }> CONT IFELSE.		Expand
474	IFREF		#E300 c:^Cell	cont_conditional	E300	[ref] IFREF	f -	26/126/51	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.		Expand
									Gas consumption of this primitive depends on whether f=0 and whether the reference was loaded before.
									Similar remarks apply other primitives that accept a continuation as a reference.
475	IFNOTREF		#E301 c:^Cell	cont_conditional	E301	[ref] IFNOTREF	f -	26/126/51	Equivalent to PUSHREFCONT IFNOT.		Expand
476	IFJMPREF		#E302 c:^Cell	cont_conditional	E302	[ref] IFJMPREF	f -	26/126/51	Equivalent to PUSHREFCONT IFJMP.		Expand
477	IFNOTJMPREF		#E303 c:^Cell	cont_conditional	E303	[ref] IFNOTJMPREF	f -	26/126/51	Equivalent to PUSHREFCONT IFNOTJMP.		Expand
478	CONDSEL		#E304	cont_conditional	E304	CONDSEL	f x y - x or y	26	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.	0xE3, 0x04	Expand
479	CONDSELCHK		#E305	cont_conditional	E305	CONDSELCHK	f x y - x or y	26	Same as CONDSEL, but first checks whether x and y have the same type.	0xE3, 0x05	Expand
480	IFRETALT		#E308	cont_conditional	E308	IFRETALT	f -	26	Performs RETALT if integer f!=0.	0xE3, 0x08	Expand
481	IFNOTRETALT		#E309	cont_conditional	E309	IFNOTRETALT	f -	26	Performs RETALT if integer f=0.	0xE3, 0x09	Expand
482	IFREFELSE		#E30D c:^Cell	cont_conditional	E30D	[ref] IFREFELSE	f c -	26/126/51	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.		Expand
483	IFELSEREF		#E30E c:^Cell	cont_conditional	E30E	[ref] IFELSEREF	f c -	26/126/51	Equivalent to PUSHREFCONT IFELSE.		Expand
484	IFREFELSEREF		#E30F c1:^Cell c2:^Cell	cont_conditional	E30F	[ref][ref] IFREFELSEREF	f -	126/51	Equivalent to PUSHREFCONT PUSHREFCONT IFELSE.		Expand
485	IFBITJMP		#E39_ n:uint5	cont_conditional	E39_n	[n] IFBITJMP	x c - x	26	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 = parse_const_u5] 0xE3, 0x80 | n	Expand
486	IFNBITJMP		#E3B_ n:uint5	cont_conditional	E3B_n	[n] IFNBITJMP	x c - x	26	Jumps to c if bit 0 <= n <= 31 is not set in integer x.	[n = parse_const_u5] 0xE3, 0xA0 | n	Expand
487	IFBITJMPREF		#E3D_ n:uint5 c:^Cell	cont_conditional	E3D_n	[ref][n] IFBITJMPREF	x - x	126/51	Performs a JMPREF if bit 0 <= n <= 31 is set in integer x.	[n = parse_const_u5] 0xE3, 0xC0 | n	Expand
488	IFNBITJMPREF		#E3F_ n:uint5 c:^Cell	cont_conditional	E3F_n	[ref][n] IFNBITJMPREF	x - x	126/51	Performs a JMPREF if bit 0 <= n <= 31 is not set in integer x.	[n = parse_const_u5] 0xE3, 0xE0 | n	Expand
489	REPEAT		#E4	cont_loops	E4	REPEAT	n c -	18	Executes continuation c n times, if integer n is non-negative. If n>=2^31 or n<-2^31, generates a range check exception.	0xE4	Expand
									Notice that a RET inside the code of c works as a continue, not as a break. One should use either alternative (experimental) loops or alternative RETALT (along with a SETEXITALT before the loop) to break out of a loop.
490				cont_loops	E4	REPEAT:<{ code }>	n -		Equivalent to <{ code }> CONT REPEAT.		Expand
						<{ code }>REPEAT
491	REPEATEND		#E5	cont_loops	E5	REPEATEND	n -	18	Similar to REPEAT, but it is applied to the current continuation cc.	0xE5	Expand
						REPEAT:
492	UNTIL		#E6	cont_loops	E6	UNTIL	c -	18	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.	0xE6	Expand
493				cont_loops	E6	UNTIL:<{ code }>	-		Equivalent to <{ code }> CONT UNTIL.		Expand
						<{ code }>UNTIL
494	UNTILEND		#E7	cont_loops	E7	UNTILEND	-	18	Similar to UNTIL, but executes the current continuation cc in a loop. When the loop exit condition is satisfied, performs a RET.	0xE7	Expand
						UNTIL:
495	WHILE		#E8	cont_loops	E8	WHILE	c' c -	18	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.	0xE8	Expand
496				cont_loops	E8	WHILE:<{ cond }>DO<{ code }>	-		Equivalent to <{ cond }> CONT <{ code }> CONT WHILE.		Expand
497	WHILEEND		#E9	cont_loops	E9	WHILEEND	c' -	18	Similar to WHILE, but uses the current continuation cc as the loop body.	0xE9	Expand
498	AGAIN		#EA	cont_loops	EA	AGAIN	c -	18	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).	0xEA	Expand
499				cont_loops	EA	AGAIN:<{ code }>	-		Equivalent to <{ code }> CONT AGAIN.		Expand
						<{ code }>AGAIN
500	AGAINEND		#EB	cont_loops	EB	AGAINEND	-	18	Similar to AGAIN, but performed with respect to the current continuation cc.	0xEB	Expand
						AGAIN:
501	REPEATBRK		#E314	cont_loops	E314	REPEATBRK	n c -	26	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.	0xE3, 0x14	Expand
502				cont_loops	E314	REPEATBRK:<{ code }>	n -		Equivalent to <{ code }> CONT REPEATBRK.		Expand
						<{ code }>REPEATBRK
503	REPEATENDBRK		#E315	cont_loops	E315	REPEATENDBRK	n -	26	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.	0xE3, 0x15	Expand
504	UNTILBRK		#E316	cont_loops	E316	UNTILBRK	c -	26	Similar to UNTIL, but also modifies c1 in the same way as REPEATBRK.	0xE3, 0x16	Expand
505				cont_loops	E316	UNTILBRK:<{ code }>	-		Equivalent to <{ code }> CONT UNTILBRK.		Expand
506	UNTILENDBRK		#E317	cont_loops	E317	UNTILENDBRK	-	26	Equivalent to SAMEALTSAVE UNTILEND.	0xE3, 0x17	Expand
						UNTILBRK:
507	WHILEBRK		#E318	cont_loops	E318	WHILEBRK	c' c -	26	Similar to WHILE, but also modifies c1 in the same way as REPEATBRK.	0xE3, 0x18	Expand
508				cont_loops	E318	WHILEBRK:<{ cond }>DO<{ code }>	-		Equivalent to <{ cond }> CONT <{ code }> CONT WHILEBRK.		Expand
509	WHILEENDBRK		#E319	cont_loops	E319	WHILEENDBRK	c -	26	Equivalent to SAMEALTSAVE WHILEEND.	0xE3, 0x19	Expand
510	AGAINBRK		#E31A	cont_loops	E31A	AGAINBRK	c -	26	Similar to AGAIN, but also modifies c1 in the same way as REPEATBRK.	0xE3, 0x1A	Expand
511				cont_loops	E31A	AGAINBRK:<{ code }>	-		Equivalent to <{ code }> CONT AGAINBRK.		Expand
512	AGAINENDBRK		#E31B	cont_loops	E31B	AGAINENDBRK	-	26	Equivalent to SAMEALTSAVE AGAINEND.	0xE3, 0x1B	Expand
						AGAINBRK:
513	SETCONTARGS_N		#EC r:uint4 n:(#<= 14)	cont_stack	ECrn	[r][n] SETCONTARGS	x_1 x_2...x_r c - c'	26+s”	Similar to [r] -1 SETCONTARGS, but sets c.nargs to the final size of the stack of c' plus n. In other words, transforms c into a closure or a partially applied function, with 0 <= n <= 14 arguments missing.		Expand
514	SETNUMARGS	SETCONTARGS_N	#EC0 n:(#<= 14)	cont_stack	EC0n	[n] SETNUMARGS	c - c'	26	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.	[c = parse_const_u4_14] 0xEC, c	Expand
515	SETCONTARGS		#EC r:uint4 n:(## 4) {n = 15}	cont_stack	ECrF	[r] -1 SETCONTARGS	x_1 x_2...x_r c - c'	26+s”	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.		Expand
516	RETURNARGS		#ED0 p:uint4	cont_stack	ED0p	[p] RETURNARGS	-	26+s”	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.	[c = parse_const_u4] 0xED, c	Expand
517	RETURNVARARGS		#ED10	cont_stack	ED10	RETURNVARARGS	p -	26+s”	Similar to RETURNARGS, but with Integer 0 <= p <= 255 taken from the stack.	0xED, 0x10	Expand
518	SETCONTVARARGS		#ED11	cont_stack	ED11	SETCONTVARARGS	x_1 x_2...x_r c r n - c'	26+s”	Similar to SETCONTARGS, but with 0 <= r <= 255 and -1 <= n <= 255 taken from the stack.	0xED, 0x11	Expand
519	SETNUMVARARGS		#ED12	cont_stack	ED12	SETNUMVARARGS	c n - c'	26	-1 <= n <= 255	0xED, 0x12	Expand
									If n=-1, this operation does nothing (c'=c).
									Otherwise its action is similar to [n] SETNUMARGS, but with n taken from the stack.
520	BLESS		#ED1E	cont_create	ED1E	BLESS	s - c	26	Transforms a Slice s into a simple ordinary continuation c, with c.code=s and an empty stack and savelist.	0xED, 0x1E	Expand
521	BLESSVARARGS		#ED1F	cont_create	ED1F	BLESSVARARGS	x_1...x_r s r n - c	26+s”	Equivalent to ROT BLESS ROTREV SETCONTVARARGS.	0xED, 0x1F	Expand
522	BLESSARGS		#EE r:uint4 n:uint4	cont_create	EErn	[r][n] BLESSARGS	x_1...x_r s - c	26	0 <= r <= 15, -1 <= n <= 14	[c1 = parse_const_u4][c2 = parse_const_i4] 0xEE, (c1 << 4) | c2	Expand
									Equivalent to BLESS [r] [n] SETCONTARGS.
									The value of n is represented inside the instruction by the 4-bit integer n mod 16.
523	BLESSNUMARGS	BLESSARGS	#EE0 n:uint4	cont_create	EE0n	[n] BLESSNUMARGS	s - c	26	Also transforms a Slice s into a Continuation c, but sets c.nargs to 0 <= n <= 14.	[c = parse_const_u4_14] 0xEE, c	Expand
524	PUSHCTR		#ED4 i:uint4	cont_registers	ED4i	c[i] PUSHCTR	- x	26	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.	[z = parse_control_register] 0xED, 0x40 | z	Expand
						c[i] PUSH
525	PUSHROOT	PUSHCTR	#ED44	cont_registers	ED44	c4 PUSHCTR	- x	26	Pushes the “global data root'' cell reference, thus enabling access to persistent smart-contract data.	0xED, 0x44	Expand
						c4 PUSH
526	POPCTR		#ED5 i:uint4	cont_registers	ED5i	c[i] POPCTR	x -	26	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.	[z = parse_control_register] 0xED, 0x50 | z	Expand
						c[i] POP
527	POPROOT	POPCTR	#ED54	cont_registers	ED54	c4 POPCTR	x -	26	Sets the “global data root'' cell reference, thus allowing modification of persistent smart-contract data.	0xED, 0x54	Expand
						c4 POP
528	SETCONTCTR		#ED6 i:uint4	cont_registers	ED6i	c[i] SETCONT	x c - c'	26	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.	[z = parse_control_register] 0xED, 0x60 | z	Expand
						c[i] SETCONTCTR
529	SETRETCTR		#ED7 i:uint4	cont_registers	ED7i	c[i] SETRETCTR	x -	26	Equivalent to c0 PUSHCTR c[i] SETCONTCTR c0 POPCTR.	[z = parse_control_register] 0xED, 0x70 | z	Expand
530	SETALTCTR		#ED8 i:uint4	cont_registers	ED8i	c[i] SETALTCTR	x -	26	Equivalent to c1 PUSHCTR c[i] SETCONTCTR c0 POPCTR.	[z = parse_control_register] 0xED, 0x80 | z	Expand
531	POPSAVE		#ED9 i:uint4	cont_registers	ED9i	c[i] POPSAVE	x -	26	Similar to c[i] POPCTR, but also saves the old value of c[i] into continuation c0.	[z = parse_control_register] 0xED, 0x90 | z	Expand
						c[i] POPCTRSAVE			Equivalent (up to exceptions) to c[i] SAVECTR c[i] POPCTR.
532	SAVE		#EDA i:uint4	cont_registers	EDAi	c[i] SAVE		26	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.	[z = parse_control_register] 0xED, 0xA0 | z	Expand
						c[i] SAVECTR
533	SAVEALT		#EDB i:uint4	cont_registers	EDBi	c[i] SAVEALT		26	Similar to c[i] SAVE, but saves the current value of c[i] into the savelist of c1, not c0.	[z = parse_control_register] 0xED, 0xB0 | z	Expand
						c[i] SAVEALTCTR
534	SAVEBOTH		#EDC i:uint4	cont_registers	EDCi	c[i] SAVEBOTH		26	Equivalent to DUP c[i] SAVE c[i] SAVEALT.	[z = parse_control_register] 0xED, 0xC0 | z	Expand
						c[i] SAVEBOTHCTR
535	PUSHCTRX		#EDE0	cont_registers	EDE0	PUSHCTRX	i - x	26	Similar to c[i] PUSHCTR, but with i, 0 <= i <= 255, taken from the stack.	0xED, 0xE0	Expand
									Notice that this primitive is one of the few “exotic'' primitives, which are not polymorphic like stack manipulation primitives, and at the same time do not have well-defined types of parameters and return values, because the type of x depends on i.
536	POPCTRX		#EDE1	cont_registers	EDE1	POPCTRX	x i -	26	Similar to c[i] POPCTR, but with 0 <= i <= 255 from the stack.	0xED, 0xE1	Expand
537	SETCONTCTRX		#EDE2	cont_registers	EDE2	SETCONTCTRX	x c i - c'	26	Similar to c[i] SETCONTCTR, but with 0 <= i <= 255 from the stack.	0xED, 0xE2	Expand
538	COMPOS		#EDF0	cont_registers	EDF0	COMPOS	c c' - c''	26	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.	0xED, 0xF0	Expand
						BOOLAND
539	COMPOSALT		#EDF1	cont_registers	EDF1	COMPOSALT	c c' - c''	26	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.	0xED, 0xF1	Expand
						BOOLOR
540	COMPOSBOTH		#EDF2	cont_registers	EDF2	COMPOSBOTH	c c' - c''	26	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''.	0xED, 0xF2	Expand
541	ATEXIT		#EDF3	cont_registers	EDF3	ATEXIT	c -	26	Sets c0 to compose0(c, c0). In other words, c will be executed before exiting current subroutine.	0xED, 0xF3	Expand
542				cont_registers	EDF3	ATEXIT:<{ code }>	-		Equivalent to <{ code }> CONT ATEXIT.		Expand
						<{ code }>ATEXIT
543	ATEXITALT		#EDF4	cont_registers	EDF4	ATEXITALT	c -	26	Sets c1 to compose1(c, c1). In other words, c will be executed before exiting current subroutine by its alternative return path.	0xED, 0xF4	Expand
544				cont_registers	EDF4	ATEXITALT:<{ code }>	-		Equivalent to <{ code }> CONT ATEXITALT.		Expand
						<{ code }>ATEXITALT
545	SETEXITALT		#EDF5	cont_registers	EDF5	SETEXITALT	c -	26	Sets c1 to compose1(compose0(c, c0), c1),	0xED, 0xF5	Expand
									In this way, a subsequent RETALT will first execute c, then transfer control to the original c0. This can be used, for instance, to exit from nested loops.
546	THENRET		#EDF6	cont_registers	EDF6	THENRET	c - c'	26	Computes compose0(c, c0).	0xED, 0xF6	Expand
547	THENRETALT		#EDF7	cont_registers	EDF7	THENRETALT	c - c'	26	Computes compose0(c, c1)	0xED, 0xF7	Expand
548	INVERT		#EDF8	cont_registers	EDF8	INVERT	-	26	Interchanges c0 and c1.	0xED, 0xF8	Expand
549	BOOLEVAL		#EDF9	cont_registers	EDF9	BOOLEVAL	c - ?	26	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.	0xED, 0xF9	Expand
550	SAMEALT		#EDFA	cont_registers	EDFA	SAMEALT	-	26	Sets c1 to c0. Equivalent to c0 PUSHCTR c1 POPCTR.	0xED, 0xFA	Expand
551	SAMEALTSAVE		#EDFB	cont_registers	EDFB	SAMEALTSAVE	-	26	Sets c1 to c0, but first saves the old value of c1 into the savelist of c0.	0xED, 0xFB	Expand
									Equivalent to c1 SAVE SAMEALT.
552	CALLDICT		#F0 n:uint8	cont_dict	F0nn	[nn] CALL	- nn		Calls the continuation in c3, pushing integer 0 <= nn <= 255 into its stack as an argument.		Expand
						[nn] CALLDICT			Approximately equivalent to [nn] PUSHINT c3 PUSHCTR EXECUTE.
553	CALLDICT_LONG		#F12_ n:uint14	cont_dict	F12_n	[n] CALL	- n		For 0 <= n < 2^14, an encoding of [n] CALL for larger values of n.		Expand
						[n] CALLDICT
554	JMPDICT		#F16_ n:uint14	cont_dict	F16_n	[n] JMP	- n		Jumps to the continuation in c3, pushing integer 0 <= n < 2^14 as its argument.		Expand
									Approximately equivalent to n PUSHINT c3 PUSHCTR JMPX.
555	PREPAREDICT		#F1A_ n:uint14	cont_dict	F1A_n	[n] PREPARE	- n c		Equivalent to n PUSHINT c3 PUSHCTR, for 0 <= n < 2^14.	[n = parse_const_u14] 0xF1, 0x80 | ((n / 256) as u8), ((n % 256) as u8)	Expand
						[n] PREPAREDICT			In this way, [n] CALL is approximately equivalent to [n] PREPARE EXECUTE, and [n] JMP is approximately equivalent to [n] PREPARE JMPX.
									One might use, for instance, CALLXARGS or CALLCC instead of EXECUTE here.
556	THROW_SHORT		#F22_ n:uint6	exceptions	F22_n	[n] THROW	- 0 n	76	Throws exception 0 <= n <= 63 with parameter zero.		Expand
									In other words, it transfers control to the continuation in c2, pushing 0 and n into its stack, and discarding the old stack altogether.
557	THROWIF_SHORT		#F26_ n:uint6	exceptions	F26_n	[n] THROWIF	f -	26/76	Throws exception 0 <= n <= 63 with parameter zero only if integer f!=0.		Expand
558	THROWIFNOT_SHORT		#F2A_ n:uint6	exceptions	F2A_n	[n] THROWIFNOT	f -	26/76	Throws exception 0 <= n <= 63 with parameter zero only if integer f=0.		Expand
559	THROW		#F2C4_ n:uint11	exceptions	F2C4_n	[n] THROW	- 0 nn	84	For 0 <= n < 2^11, an encoding of [n] THROW for larger values of n.		Expand
560	THROWARG		#F2CC_ n:uint11	exceptions	F2CC_n	[n] THROWARG	x - x nn	84	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 = parse_const_u11] 0xF2, 0xC8 | ((n / 256) as u8), ((n % 256) as u8)	Expand
561	THROWIF		#F2D4_ n:uint11	exceptions	F2D4_n	[n] THROWIF	f -	34/84	For 0 <= n < 2^11, an encoding of [n] THROWIF for larger values of n.		Expand
562	THROWARGIF		#F2DC_ n:uint11	exceptions	F2DC_n	[n] THROWARGIF	x f -	34/84	Throws exception 0 <= nn < 2^11 with parameter x only if integer f!=0.	[n = parse_const_u11] 0xF2, 0xD8 | ((n / 256) as u8), ((n % 256) as u8)	Expand
563	THROWIFNOT		#F2E4_ n:uint11	exceptions	F2E4_n	[n] THROWIFNOT	f -	34/84	For 0 <= n < 2^11, an encoding of [n] THROWIFNOT for larger values of n.		Expand
564	THROWARGIFNOT		#F2EC_ n:uint11	exceptions	F2EC_n	[n] THROWARGIFNOT	x f -	34/84	Throws exception 0 <= n < 2^11 with parameter x only if integer f=0.	[n = parse_const_u11] 0xF2, 0xE8 | ((n / 256) as u8), ((n % 256) as u8)	Expand
565	THROWANY		#F2F0	exceptions	F2F0	THROWANY	n - 0 n	76	Throws exception 0 <= n < 2^16 with parameter zero.	0xF2, 0xF0	Expand
									Approximately equivalent to ZERO SWAP THROWARGANY.
566	THROWARGANY		#F2F1	exceptions	F2F1	THROWARGANY	x n - x n	76	Throws exception 0 <= n < 2^16 with parameter x, transferring control to the continuation in c2.	0xF2, 0xF1	Expand
									Approximately equivalent to c2 PUSHCTR 2 JMPXARGS.
567	THROWANYIF		#F2F2	exceptions	F2F2	THROWANYIF	n f -	26/76	Throws exception 0 <= n < 2^16 with parameter zero only if f!=0.	0xF2, 0xF2	Expand
568	THROWARGANYIF		#F2F3	exceptions	F2F3	THROWARGANYIF	x n f -	26/76	Throws exception 0 <= n<2^16 with parameter x only if f!=0.	0xF2, 0xF3	Expand
569	THROWANYIFNOT		#F2F4	exceptions	F2F4	THROWANYIFNOT	n f -	26/76	Throws exception 0 <= n<2^16 with parameter zero only if f=0.	0xF2, 0xF4	Expand
570	THROWARGANYIFNOT		#F2F5	exceptions	F2F5	THROWARGANYIFNOT	x n f -	26/76	Throws exception 0 <= n<2^16 with parameter x only if f=0.	0xF2, 0xF5	Expand
571	TRY		#F2FF	exceptions	F2FF	TRY	c c' -	26	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.	0xF2, 0xFF	Expand
572				exceptions	F2FF	TRY:<{ code1 }>CATCH<{ code2 }>	-		Equivalent to <{ code1 }> CONT <{ code2 }> CONT TRY.		Expand
573	TRYARGS		#F3 p:uint4 r:uint4	exceptions	F3pr	[p][r] TRYARGS	c c' -	26	Similar to TRY, but with [p] [r] CALLXARGS internally used instead of EXECUTE.	[s1 = parse_const_u4][s2 = parse_const_u4] 0xF3, (s1 << 4 | s2)	Expand
									In this way, all but the top 0 <= p <= 15 stack elements will be saved into current continuation's stack, and then restored upon return from either c or c', with the top 0 <= r <= 15 values of the resulting stack of c or c' copied as return values.
574	NEWDICT	NULL	#6D	dict_create	6D	NEWDICT	- D	18	Returns a new empty dictionary.	0x6D	Expand
									It is an alternative mnemonics for PUSHNULL.
575	DICTEMPTY	ISNULL	#6E	dict_create	6E	DICTEMPTY	D - ?	18	Checks whether dictionary D is empty, and returns -1 or 0 accordingly.	0x6E	Expand
									It is an alternative mnemonics for ISNULL.
576	STDICTS	STSLICE	#CE	dict_serial	CE	STDICTS	s b - b'	18	Stores a Slice-represented dictionary s into Builder b.	0xCE	Expand
									It is actually a synonym for STSLICE.
577	STDICT		#F400	dict_serial	F400	STDICT	D b - b'	26	Stores dictionary D into Builder b, returing the resulting Builder b'.	0xF4, 0x00	Expand
						STOPTREF			In other words, if D is a cell, performs STONE and STREF; if D is Null, performs NIP and STZERO; otherwise throws a type checking exception.
578	SKIPDICT		#F401	dict_serial	F401	SKIPDICT	s - s'	26	Equivalent to LDDICT NIP.	0xF4, 0x01	Expand
						SKIPOPTREF
579	LDDICTS		#F402	dict_serial	F402	LDDICTS	s - s' s''	26	Loads (parses) a (Slice-represented) dictionary s' from Slice s, and returns the remainder of s as s''.	0xF4, 0x02	Expand
									This is a “split function'' for all HashmapE(n,X) dictionary types.
580	PLDDICTS		#F403	dict_serial	F403	PLDDICTS	s - s'	26	Preloads a (Slice-represented) dictionary s' from Slice s.	0xF4, 0x03	Expand
									Approximately equivalent to LDDICTS DROP.
581	LDDICT		#F404	dict_serial	F404	LDDICT	s - D s'	26	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.	0xF4, 0x04	Expand
						LDOPTREF
582	PLDDICT		#F405	dict_serial	F405	PLDDICT	s - D	26	Preloads a dictionary D from Slice s.	0xF4, 0x05	Expand
						PLDOPTREF			Approximately equivalent to LDDICT DROP.
583	LDDICTQ		#F406	dict_serial	F406	LDDICTQ	s - D s' -1 or s 0	26	A quiet version of LDDICT.	0xF4, 0x06	Expand
584	PLDDICTQ		#F407	dict_serial	F407	PLDDICTQ	s - D -1 or 0	26	A quiet version of PLDDICT.	0xF4, 0x07	Expand
585	DICTGET		#F40A	dict_get	F40A	DICTGET	k D n - x -1 or 0		Looks up key k (represented by a Slice, the first 0 <= n <= 1023 data bits of which are used as a key) in dictionary D of type HashmapE(n,X) with n-bit keys.	0xF4, 0x0A	Expand
									On success, returns the value found as a Slice x.
586	DICTGETREF		#F40B	dict_get	F40B	DICTGETREF	k D n - c -1 or 0		Similar to DICTGET, but with a LDREF ENDS applied to x on success.	0xF4, 0x0B	Expand
									This operation is useful for dictionaries of type HashmapE(n,^Y).
587	DICTIGET		#F40C	dict_get	F40C	DICTIGET	i D n - x -1 or 0		Similar to DICTGET, but with a signed (big-endian) n-bit Integer i as a key. If i does not fit into n bits, returns 0. If i is a NaN, throws an integer overflow exception.	0xF4, 0x0C	Expand
588	DICTIGETREF		#F40D	dict_get	F40D	DICTIGETREF	i D n - c -1 or 0		Combines DICTIGET with DICTGETREF: it uses signed n-bit Integer i as a key and returns a Cell instead of a Slice on success.	0xF4, 0x0D	Expand
589	DICTUGET		#F40E	dict_get	F40E	DICTUGET	i D n - x -1 or 0		Similar to DICTIGET, but with unsigned (big-endian) n-bit Integer i used as a key.	0xF4, 0x0E	Expand
590	DICTUGETREF		#F40F	dict_get	F40F	DICTUGETREF	i D n - c -1 or 0		Similar to DICTIGETREF, but with an unsigned n-bit Integer key i.	0xF4, 0x0F	Expand
591	DICTSET		#F412	dict_set	F412	DICTSET	x k D n - D'		Sets the value associated with n-bit key k (represented by a Slice as in DICTGET) in dictionary D (also represented by a Slice) to value x (again a Slice), and returns the resulting dictionary as D'.	0xF4, 0x12	Expand
592	DICTSETREF		#F413	dict_set	F413	DICTSETREF	c k D n - D'		Similar to DICTSET, but with the value set to a reference to Cell c.	0xF4, 0x13	Expand
593	DICTISET		#F414	dict_set	F414	DICTISET	x i D n - D'		Similar to DICTSET, but with the key represented by a (big-endian) signed n-bit integer i. If i does not fit into n bits, a range check exception is generated.	0xF4, 0x14	Expand
594	DICTISETREF		#F415	dict_set	F415	DICTISETREF	c i D n - D'		Similar to DICTSETREF, but with the key a signed n-bit integer as in DICTISET.	0xF4, 0x15	Expand
595	DICTUSET		#F416	dict_set	F416	DICTUSET	x i D n - D'		Similar to DICTISET, but with i an unsigned n-bit integer.	0xF4, 0x16	Expand
596	DICTUSETREF		#F417	dict_set	F417	DICTUSETREF	c i D n - D'		Similar to DICTISETREF, but with i unsigned.	0xF4, 0x17	Expand
597	DICTSETGET		#F41A	dict_set	F41A	DICTSETGET	x k D n - D' y -1 or D' 0		Combines DICTSET with DICTGET: it sets the value corresponding to key k to x, but also returns the old value y associated with the key in question, if present.	0xF4, 0x1A	Expand
598	DICTSETGETREF		#F41B	dict_set	F41B	DICTSETGETREF	c k D n - D' c' -1 or D' 0		Combines DICTSETREF with DICTGETREF similarly to DICTSETGET.	0xF4, 0x1B	Expand
599	DICTISETGET		#F41C	dict_set	F41C	DICTISETGET	x i D n - D' y -1 or D' 0		DICTISETGET, but with i a signed n-bit integer.	0xF4, 0x1C	Expand
600	DICTISETGETREF		#F41D	dict_set	F41D	DICTISETGETREF	c i D n - D' c' -1 or D' 0		DICTISETGETREF, but with i a signed n-bit integer.	0xF4, 0x1D	Expand
601	DICTUSETGET		#F41E	dict_set	F41E	DICTUSETGET	x i D n - D' y -1 or D' 0		DICTISETGET, but with i an unsigned n-bit integer.	0xF4, 0x1E	Expand
602	DICTUSETGETREF		#F41F	dict_set	F41F	DICTUSETGETREF	c i D n - D' c' -1 or D' 0		DICTISETGETREF, but with i an unsigned n-bit integer.	0xF4, 0x1F	Expand
603	DICTREPLACE		#F422	dict_set	F422	DICTREPLACE	x k D n - D' -1 or D 0		A Replace operation, which is similar to DICTSET, but sets the value of key k in dictionary D to x only if the key k was already present in D.	0xF4, 0x22	Expand
604	DICTREPLACEREF		#F423	dict_set	F423	DICTREPLACEREF	c k D n - D' -1 or D 0		A Replace counterpart of DICTSETREF.	0xF4, 0x23	Expand
605	DICTIREPLACE		#F424	dict_set	F424	DICTIREPLACE	x i D n - D' -1 or D 0		DICTREPLACE, but with i a signed n-bit integer.	0xF4, 0x24	Expand
606	DICTIREPLACEREF		#F425	dict_set	F425	DICTIREPLACEREF	c i D n - D' -1 or D 0		DICTREPLACEREF, but with i a signed n-bit integer.	0xF4, 0x25	Expand
607	DICTUREPLACE		#F426	dict_set	F426	DICTUREPLACE	x i D n - D' -1 or D 0		DICTREPLACE, but with i an unsigned n-bit integer.	0xF4, 0x26	Expand
608	DICTUREPLACEREF		#F427	dict_set	F427	DICTUREPLACEREF	c i D n - D' -1 or D 0		DICTREPLACEREF, but with i an unsigned n-bit integer.	0xF4, 0x27	Expand
609	DICTREPLACEGET		#F42A	dict_set	F42A	DICTREPLACEGET	x k D n - D' y -1 or D 0		A Replace counterpart of DICTSETGET: on success, also returns the old value associated with the key in question.	0xF4, 0x2A	Expand
610	DICTREPLACEGETREF		#F42B	dict_set	F42B	DICTREPLACEGETREF	c k D n - D' c' -1 or D 0		A Replace counterpart of DICTSETGETREF.	0xF4, 0x2B	Expand
611	DICTIREPLACEGET		#F42C	dict_set	F42C	DICTIREPLACEGET	x i D n - D' y -1 or D 0		DICTREPLACEGET, but with i a signed n-bit integer.	0xF4, 0x2C	Expand
612	DICTIREPLACEGETREF		#F42D	dict_set	F42D	DICTIREPLACEGETREF	c i D n - D' c' -1 or D 0		DICTREPLACEGETREF, but with i a signed n-bit integer.	0xF4, 0x2D	Expand
613	DICTUREPLACEGET		#F42E	dict_set	F42E	DICTUREPLACEGET	x i D n - D' y -1 or D 0		DICTREPLACEGET, but with i an unsigned n-bit integer.	0xF4, 0x2E	Expand
614	DICTUREPLACEGETREF		#F42F	dict_set	F42F	DICTUREPLACEGETREF	c i D n - D' c' -1 or D 0		DICTREPLACEGETREF, but with i an unsigned n-bit integer.	0xF4, 0x2F	Expand
615	DICTADD		#F432	dict_set	F432	DICTADD	x k D n - D' -1 or D 0		An Add counterpart of DICTSET: sets the value associated with key k in dictionary D to x, but only if it is not already present in D.	0xF4, 0x32	Expand
616	DICTADDREF		#F433	dict_set	F433	DICTADDREF	c k D n - D' -1 or D 0		An Add counterpart of DICTSETREF.	0xF4, 0x33	Expand
617	DICTIADD		#F434	dict_set	F434	DICTIADD	x i D n - D' -1 or D 0		DICTADD, but with i a signed n-bit integer.	0xF4, 0x34	Expand
618	DICTIADDREF		#F435	dict_set	F435	DICTIADDREF	c i D n - D' -1 or D 0		DICTADDREF, but with i a signed n-bit integer.	0xF4, 0x35	Expand
619	DICTUADD		#F436	dict_set	F436	DICTUADD	x i D n - D' -1 or D 0		DICTADD, but with i an unsigned n-bit integer.	0xF4, 0x36	Expand
620	DICTUADDREF		#F437	dict_set	F437	DICTUADDREF	c i D n - D' -1 or D 0		DICTADDREF, but with i an unsigned n-bit integer.	0xF4, 0x37	Expand
621	DICTADDGET		#F43A	dict_set	F43A	DICTADDGET	x k D n - D' -1 or D y 0		An Add counterpart of DICTSETGET: sets the value associated with key k in dictionary D to x, but only if key k is not already present in D. Otherwise, just returns the old value y without changing the dictionary.	0xF4, 0x3A	Expand
622	DICTADDGETREF		#F43B	dict_set	F43B	DICTADDGETREF	c k D n - D' -1 or D c' 0		An Add counterpart of DICTSETGETREF.	0xF4, 0x3B	Expand
623	DICTIADDGET		#F43C	dict_set	F43C	DICTIADDGET	x i D n - D' -1 or D y 0		DICTADDGET, but with i a signed n-bit integer.	0xF4, 0x3C	Expand
624	DICTIADDGETREF		#F43D	dict_set	F43D	DICTIADDGETREF	c i D n - D' -1 or D c' 0		DICTADDGETREF, but with i a signed n-bit integer.	0xF4, 0x3D	Expand
625	DICTUADDGET		#F43E	dict_set	F43E	DICTUADDGET	x i D n - D' -1 or D y 0		DICTADDGET, but with i an unsigned n-bit integer.	0xF4, 0x3E	Expand
626	DICTUADDGETREF		#F43F	dict_set	F43F	DICTUADDGETREF	c i D n - D' -1 or D c' 0		DICTADDGETREF, but with i an unsigned n-bit integer.	0xF4, 0x3F	Expand
627	DICTSETB		#F441	dict_set_builder	F441	DICTSETB	b k D n - D'			0xF4, 0x41	Expand
628	DICTISETB		#F442	dict_set_builder	F442	DICTISETB	b i D n - D'			0xF4, 0x42	Expand
629	DICTUSETB		#F443	dict_set_builder	F443	DICTUSETB	b i D n - D'			0xF4, 0x43	Expand
630	DICTSETGETB		#F445	dict_set_builder	F445	DICTSETGETB	b k D n - D' y -1 or D' 0			0xF4, 0x44	Expand
631	DICTISETGETB		#F446	dict_set_builder	F446	DICTISETGETB	b i D n - D' y -1 or D' 0			0xF4, 0x46	Expand
632	DICTUSETGETB		#F447	dict_set_builder	F447	DICTUSETGETB	b i D n - D' y -1 or D' 0			0xF4, 0x47	Expand
633	DICTREPLACEB		#F449	dict_set_builder	F449	DICTREPLACEB	b k D n - D' -1 or D 0			0xF4, 0x49	Expand
634	DICTIREPLACEB		#F44A	dict_set_builder	F44A	DICTIREPLACEB	b i D n - D' -1 or D 0			0xF4, 0x4A	Expand
635	DICTUREPLACEB		#F44B	dict_set_builder	F44B	DICTUREPLACEB	b i D n - D' -1 or D 0			0xF4, 0x4B	Expand
636	DICTREPLACEGETB		#F44D	dict_set_builder	F44D	DICTREPLACEGETB	b k D n - D' y -1 or D 0			0xF4, 0x4D	Expand
637	DICTIREPLACEGETB		#F44E	dict_set_builder	F44E	DICTIREPLACEGETB	b i D n - D' y -1 or D 0			0xF4, 0x4E	Expand
638	DICTUREPLACEGETB		#F44F	dict_set_builder	F44F	DICTUREPLACEGETB	b i D n - D' y -1 or D 0			0xF4, 0x4F	Expand
639	DICTADDB		#F451	dict_set_builder	F451	DICTADDB	b k D n - D' -1 or D 0			0xF4, 0x51	Expand
640	DICTIADDB		#F452	dict_set_builder	F452	DICTIADDB	b i D n - D' -1 or D 0			0xF4, 0x52	Expand
641	DICTUADDB		#F453	dict_set_builder	F453	DICTUADDB	b i D n - D' -1 or D 0			0xF4, 0x53	Expand
642	DICTADDGETB		#F455	dict_set_builder	F455	DICTADDGETB	b k D n - D' -1 or D y 0			0xF4, 0x55	Expand
643	DICTIADDGETB		#F456	dict_set_builder	F456	DICTIADDGETB	b i D n - D' -1 or D y 0			0xF4, 0x56	Expand
644	DICTUADDGETB		#F457	dict_set_builder	F457	DICTUADDGETB	b i D n - D' -1 or D y 0			0xF4, 0x57	Expand
645	DICTDEL		#F459	dict_delete	F459	DICTDEL	k D n - D' -1 or D 0		Deletes n-bit key, represented by a Slice k, from dictionary D. If the key is present, returns the modified dictionary D' and the success flag -1. Otherwise, returns the original dictionary D and 0.	0xF4, 0x59	Expand
646	DICTIDEL		#F45A	dict_delete	F45A	DICTIDEL	i D n - D' ?		A version of DICTDEL with the key represented by a signed n-bit Integer i. If i does not fit into n bits, simply returns D 0 (“key not found, dictionary unmodified'').	0xF4, 0x5A	Expand
647	DICTUDEL		#F45B	dict_delete	F45B	DICTUDEL	i D n - D' ?		Similar to DICTIDEL, but with i an unsigned n-bit integer.	0xF4, 0x5B	Expand
648	DICTDELGET		#F462	dict_delete	F462	DICTDELGET	k D n - D' x -1 or D 0		Deletes n-bit key, represented by a Slice k, from dictionary D. If the key is present, returns the modified dictionary D', the original value x associated with the key k (represented by a Slice), and the success flag -1. Otherwise, returns the original dictionary D and 0.	0xF4, 0x62	Expand
649	DICTDELGETREF		#F463	dict_delete	F463	DICTDELGETREF	k D n - D' c -1 or D 0		Similar to DICTDELGET, but with LDREF ENDS applied to x on success, so that the value returned c is a Cell.	0xF4, 0x63	Expand
650	DICTIDELGET		#F464	dict_delete	F464	DICTIDELGET	i D n - D' x -1 or D 0		DICTDELGET, but with i a signed n-bit integer.	0xF4, 0x64	Expand
651	DICTIDELGETREF		#F465	dict_delete	F465	DICTIDELGETREF	i D n - D' c -1 or D 0		DICTDELGETREF, but with i a signed n-bit integer.	0xF4, 0x65	Expand
652	DICTUDELGET		#F466	dict_delete	F466	DICTUDELGET	i D n - D' x -1 or D 0		DICTDELGET, but with i an unsigned n-bit integer.	0xF4, 0x66	Expand
653	DICTUDELGETREF		#F467	dict_delete	F467	DICTUDELGETREF	i D n - D' c -1 or D 0		DICTDELGETREF, but with i an unsigned n-bit integer.	0xF4, 0x67	Expand
654	DICTGETOPTREF		#F469	dict_mayberef	F469	DICTGETOPTREF	k D n - c^?		A variant of DICTGETREF that returns Null instead of the value c^? if the key k is absent from dictionary D.	0xF4, 0x69	Expand
655	DICTIGETOPTREF		#F46A	dict_mayberef	F46A	DICTIGETOPTREF	i D n - c^?		DICTGETOPTREF, but with i a signed n-bit integer. If the key i is out of range, also returns Null.	0xF4, 0x6A	Expand
656	DICTUGETOPTREF		#F46B	dict_mayberef	F46B	DICTUGETOPTREF	i D n - c^?		DICTGETOPTREF, but with i an unsigned n-bit integer. If the key i is out of range, also returns Null.	0xF4, 0x6B	Expand
657	DICTSETGETOPTREF		#F46D	dict_mayberef	F46D	DICTSETGETOPTREF	c^? k D n - D' ~c^?		A variant of both DICTGETOPTREF and DICTSETGETREF that sets the value corresponding to key k in dictionary D to c^? (if c^? is Null, then the key is deleted instead), and returns the old value ~c^? (if the key k was absent before, returns Null instead).	0xF4, 0x6D	Expand
658	DICTISETGETOPTREF		#F46E	dict_mayberef	F46E	DICTISETGETOPTREF	c^? i D n - D' ~c^?		Similar to primitive DICTSETGETOPTREF, but using signed n-bit Integer i as a key. If i does not fit into n bits, throws a range checking exception.	0xF4, 0x6E	Expand
659	DICTUSETGETOPTREF		#F46F	dict_mayberef	F46F	DICTUSETGETOPTREF	c^? i D n - D' ~c^?		Similar to primitive DICTSETGETOPTREF, but using unsigned n-bit Integer i as a key.	0xF4, 0x6F	Expand
660	PFXDICTSET		#F470	dict_prefix	F470	PFXDICTSET	x k D n - D' -1 or D 0			0xF4, 0x70	Expand
661	PFXDICTREPLACE		#F471	dict_prefix	F471	PFXDICTREPLACE	x k D n - D' -1 or D 0			0xF4, 0x71	Expand
662	PFXDICTADD		#F472	dict_prefix	F472	PFXDICTADD	x k D n - D' -1 or D 0			0xF4, 0x72	Expand
663	PFXDICTDEL		#F473	dict_prefix	F473	PFXDICTDEL	k D n - D' -1 or D 0			0xF4, 0x73	Expand
664	DICTGETNEXT		#F474	dict_next	F474	DICTGETNEXT	k D n - x' k' -1 or 0		Computes the minimal key k' in dictionary D that is lexicographically greater than k, and returns k' (represented by a Slice) along with associated value x' (also represented by a Slice).	0xF4, 0x74	Expand
665	DICTGETNEXTEQ		#F475	dict_next	F475	DICTGETNEXTEQ	k D n - x' k' -1 or 0		Similar to DICTGETNEXT, but computes the minimal key k' that is lexicographically greater than or equal to k.	0xF4, 0x75	Expand
666	DICTGETPREV		#F476	dict_next	F476	DICTGETPREV	k D n - x' k' -1 or 0		Similar to DICTGETNEXT, but computes the maximal key k' lexicographically smaller than k.	0xF4, 0x76	Expand
667	DICTGETPREVEQ		#F477	dict_next	F477	DICTGETPREVEQ	k D n - x' k' -1 or 0		Similar to DICTGETPREV, but computes the maximal key k' lexicographically smaller than or equal to k.	0xF4, 0x77	Expand
668	DICTIGETNEXT		#F478	dict_next	F478	DICTIGETNEXT	i D n - x' i' -1 or 0		Similar to DICTGETNEXT, but interprets all keys in dictionary D as big-endian signed n-bit integers, and computes the minimal key i' that is larger than Integer i (which does not necessarily fit into n bits).	0xF4, 0x78	Expand
669	DICTIGETNEXTEQ		#F479	dict_next	F479	DICTIGETNEXTEQ	i D n - x' i' -1 or 0		Similar to DICTGETNEXTEQ, but interprets keys as signed n-bit integers.	0xF4, 0x79	Expand
670	DICTIGETPREV		#F47A	dict_next	F47A	DICTIGETPREV	i D n - x' i' -1 or 0		Similar to DICTGETPREV, but interprets keys as signed n-bit integers.	0xF4, 0x7A	Expand
671	DICTIGETPREVEQ		#F47B	dict_next	F47B	DICTIGETPREVEQ	i D n - x' i' -1 or 0		Similar to DICTGETPREVEQ, but interprets keys as signed n-bit integers.	0xF4, 0x7B	Expand
672	DICTUGETNEXT		#F47C	dict_next	F47C	DICTUGETNEXT	i D n - x' i' -1 or 0		Similar to DICTGETNEXT, but interprets all keys in dictionary D as big-endian unsigned n-bit integers, and computes the minimal key i' that is larger than Integer i (which does not necessarily fit into n bits, and is not necessarily non-negative).	0xF4, 0x7C	Expand
673	DICTUGETNEXTEQ		#F47D	dict_next	F47D	DICTUGETNEXTEQ	i D n - x' i' -1 or 0		Similar to DICTGETNEXTEQ, but interprets keys as unsigned n-bit integers.	0xF4, 0x7D	Expand
674	DICTUGETPREV		#F47E	dict_next	F47E	DICTUGETPREV	i D n - x' i' -1 or 0		Similar to DICTGETPREV, but interprets keys as unsigned n-bit integers.	0xF4, 0x7E	Expand
675	DICTUGETPREVEQ		#F47F	dict_next	F47F	DICTUGETPREVEQ	i D n - x' i' -1 or 0		Similar to DICTGETPREVEQ, but interprets keys a unsigned n-bit integers.	0xF4, 0x7F	Expand
676	DICTMIN		#F482	dict_min	F482	DICTMIN	D n - x k -1 or 0		Computes the minimal key k (represented by a Slice with n data bits) in dictionary D, and returns k along with the associated value x.	0xF4, 0x82	Expand
677	DICTMINREF		#F483	dict_min	F483	DICTMINREF	D n - c k -1 or 0		Similar to DICTMIN, but returns the only reference in the value as a Cell c.	0xF4, 0x83	Expand
678	DICTIMIN		#F484	dict_min	F484	DICTIMIN	D n - x i -1 or 0		Similar to DICTMIN, but computes the minimal key i under the assumption that all keys are big-endian signed n-bit integers. Notice that the key and value returned may differ from those computed by DICTMIN and DICTUMIN.	0xF4, 0x84	Expand
679	DICTIMINREF		#F485	dict_min	F485	DICTIMINREF	D n - c i -1 or 0		Similar to DICTIMIN, but returns the only reference in the value.	0xF4, 0x85	Expand
680	DICTUMIN		#F486	dict_min	F486	DICTUMIN	D n - x i -1 or 0		Similar to DICTMIN, but returns the key as an unsigned n-bit Integer i.	0xF4, 0x86	Expand
681	DICTUMINREF		#F487	dict_min	F487	DICTUMINREF	D n - c i -1 or 0		Similar to DICTUMIN, but returns the only reference in the value.	0xF4, 0x87	Expand
682	DICTMAX		#F48A	dict_min	F48A	DICTMAX	D n - x k -1 or 0		Computes the maximal key k (represented by a Slice with n data bits) in dictionary D, and returns k along with the associated value x.	0xF4, 0x8A	Expand
683	DICTMAXREF		#F48B	dict_min	F48B	DICTMAXREF	D n - c k -1 or 0		Similar to DICTMAX, but returns the only reference in the value.	0xF4, 0x8B	Expand
684	DICTIMAX		#F48C	dict_min	F48C	DICTIMAX	D n - x i -1 or 0		Similar to DICTMAX, but computes the maximal key i under the assumption that all keys are big-endian signed n-bit integers. Notice that the key and value returned may differ from those computed by DICTMAX and DICTUMAX.	0xF4, 0x8C	Expand
685	DICTIMAXREF		#F48D	dict_min	F48D	DICTIMAXREF	D n - c i -1 or 0		Similar to DICTIMAX, but returns the only reference in the value.	0xF4, 0x8D	Expand
686	DICTUMAX		#F48E	dict_min	F48E	DICTUMAX	D n - x i -1 or 0		Similar to DICTMAX, but returns the key as an unsigned n-bit Integer i.	0xF4, 0x8E	Expand
687	DICTUMAXREF		#F48F	dict_min	F48F	DICTUMAXREF	D n - c i -1 or 0		Similar to DICTUMAX, but returns the only reference in the value.	0xF4, 0x8F	Expand
688	DICTREMMIN		#F492	dict_min	F492	DICTREMMIN	D n - D' x k -1 or D 0		Computes the minimal key k (represented by a Slice with n data bits) in dictionary D, removes k from the dictionary, and returns k along with the associated value x and the modified dictionary D'.	0xF4, 0x92	Expand
689	DICTREMMINREF		#F493	dict_min	F493	DICTREMMINREF	D n - D' c k -1 or D 0		Similar to DICTREMMIN, but returns the only reference in the value as a Cell c.	0xF4, 0x93	Expand
690	DICTIREMMIN		#F494	dict_min	F494	DICTIREMMIN	D n - D' x i -1 or D 0		Similar to DICTREMMIN, but computes the minimal key i under the assumption that all keys are big-endian signed n-bit integers. Notice that the key and value returned may differ from those computed by DICTREMMIN and DICTUREMMIN.	0xF4, 0x94	Expand
691	DICTIREMMINREF		#F495	dict_min	F495	DICTIREMMINREF	D n - D' c i -1 or D 0		Similar to DICTIREMMIN, but returns the only reference in the value.	0xF4, 0x95	Expand
692	DICTUREMMIN		#F496	dict_min	F496	DICTUREMMIN	D n - D' x i -1 or D 0		Similar to DICTREMMIN, but returns the key as an unsigned n-bit Integer i.	0xF4, 0x96	Expand
693	DICTUREMMINREF		#F497	dict_min	F497	DICTUREMMINREF	D n - D' c i -1 or D 0		Similar to DICTUREMMIN, but returns the only reference in the value.	0xF4, 0x937	Expand
694	DICTREMMAX		#F49A	dict_min	F49A	DICTREMMAX	D n - D' x k -1 or D 0		Computes the maximal key k (represented by a Slice with n data bits) in dictionary D, removes k from the dictionary, and returns k along with the associated value x and the modified dictionary D'.	0xF4, 0x9A	Expand
695	DICTREMMAXREF		#F49B	dict_min	F49B	DICTREMMAXREF	D n - D' c k -1 or D 0		Similar to DICTREMMAX, but returns the only reference in the value as a Cell c.	0xF4, 0x9B	Expand
696	DICTIREMMAX		#F49C	dict_min	F49C	DICTIREMMAX	D n - D' x i -1 or D 0		Similar to DICTREMMAX, but computes the minimal key i under the assumption that all keys are big-endian signed n-bit integers. Notice that the key and value returned may differ from those computed by DICTREMMAX and DICTUREMMAX.	0xF4, 0x9C	Expand
697	DICTIREMMAXREF		#F49D	dict_min	F49D	DICTIREMMAXREF	D n - D' c i -1 or D 0		Similar to DICTIREMMAX, but returns the only reference in the value.	0xF4, 0x9D	Expand
698	DICTUREMMAX		#F49E	dict_min	F49E	DICTUREMMAX	D n - D' x i -1 or D 0		Similar to DICTREMMAX, but returns the key as an unsigned n-bit Integer i.	0xF4, 0x9E	Expand
699	DICTUREMMAXREF		#F49F	dict_min	F49F	DICTUREMMAXREF	D n - D' c i -1 or D 0		Similar to DICTUREMMAX, but returns the only reference in the value.	0xF4, 0x9F	Expand
700	DICTIGETJMP		#F4A0	dict_special	F4A0	DICTIGETJMP	i D n -		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.	0xF4, 0xA0	Expand
701	DICTUGETJMP		#F4A1	dict_special	F4A1	DICTUGETJMP	i D n -		Similar to DICTIGETJMP, but performs DICTUGET instead of DICTIGET.	0xF4, 0xA1	Expand
702	DICTIGETEXEC		#F4A2	dict_special	F4A2	DICTIGETEXEC	i D n -		Similar to DICTIGETJMP, but with EXECUTE instead of JMPX.	0xF4, 0xA2	Expand
703	DICTUGETEXEC		#F4A3	dict_special	F4A3	DICTUGETEXEC	i D n -		Similar to DICTUGETJMP, but with EXECUTE instead of JMPX.	0xF4, 0xA3	Expand
704	DICTPUSHCONST		#F4A6_ d:^Cell n:uint10	dict_special	F4A6_n	[ref][n] DICTPUSHCONST	- D n	34	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 = parse_const_u10] 0xF4, 0xA4 | (n >> 8) as u8, n as u8	Expand
705	PFXDICTGETQ		#F4A8	dict_special	F4A8	PFXDICTGETQ	s D n - s' x s'' -1 or s 0		Looks up the unique prefix of Slice s present in the prefix code dictionary represented by Cell^? D and 0 <= n <= 1023. If found, the prefix of s is returned as s', and the corresponding value (also a Slice) as x. The remainder of s is returned as a Slice s''. If no prefix of s is a key in prefix code dictionary D, returns the unchanged s and a zero flag to indicate failure.	0xF4, 0xA8	Expand
706	PFXDICTGET		#F4A9	dict_special	F4A9	PFXDICTGET	s D n - s' x s''		Similar to PFXDICTGET, but throws a cell deserialization failure exception on failure.	0xF4, 0xA9	Expand
707	PFXDICTGETJMP		#F4AA	dict_special	F4AA	PFXDICTGETJMP	s D n - s' s'' or s		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.	0xF4, 0xAA	Expand
708	PFXDICTGETEXEC		#F4AB	dict_special	F4AB	PFXDICTGETEXEC	s D n - s' s''		Similar to PFXDICTGETJMP, but EXECutes the continuation found instead of jumping to it. On failure, throws a cell deserialization exception.	0xF4, 0xAB	Expand
709	PFXDICTCONSTGETJMP		#F4AE_ d:^Cell n:uint10	dict_special	F4AE_n	[ref][n] PFXDICTCONSTGETJMP	s - s' s'' or s		Combines [n] DICTPUSHCONST for 0 <= n <= 1023 with PFXDICTGETJMP.	[n = parse_const_u10] 0xF4, 0xAC | (n >> 8) as u8, n as u8	Expand
						[ref][n] PFXDICTSWITCH
710	DICTIGETJMPZ		#F4BC	dict_special	F4BC	DICTIGETJMPZ	i D n - i or nothing		A variant of DICTIGETJMP that returns index i on failure.	0xF4, 0xBC	Expand
711	DICTUGETJMPZ		#F4BD	dict_special	F4BD	DICTUGETJMPZ	i D n - i or nothing		A variant of DICTUGETJMP that returns index i on failure.	0xF4, 0xBD	Expand
712	DICTIGETEXECZ		#F4BE	dict_special	F4BE	DICTIGETEXECZ	i D n - i or nothing		A variant of DICTIGETEXEC that returns index i on failure.	0xF4, 0xBE	Expand
713	DICTUGETEXECZ		#F4BF	dict_special	F4BF	DICTUGETEXECZ	i D n - i or nothing		A variant of DICTUGETEXEC that returns index i on failure.	0xF4, 0xBF	Expand
714	SUBDICTGET		#F4B1	dict_sub	F4B1	SUBDICTGET	k l D n - D'		Constructs a subdictionary consisting of all keys beginning with prefix k (represented by a Slice, the first 0 <= l <= n <= 1023 data bits of which are used as a key) of length l in dictionary D of type HashmapE(n,X) with n-bit keys. On success, returns the new subdictionary of the same type HashmapE(n,X) as a Slice D'.	0xF4, 0xB1	Expand
715	SUBDICTIGET		#F4B2	dict_sub	F4B2	SUBDICTIGET	x l D n - D'		Variant of SUBDICTGET with the prefix represented by a signed big-endian l-bit Integer x, where necessarily l <= 257.	0xF4, 0xB2	Expand
716	SUBDICTUGET		#F4B3	dict_sub	F4B3	SUBDICTUGET	x l D n - D'		Variant of SUBDICTGET with the prefix represented by an unsigned big-endian l-bit Integer x, where necessarily l <= 256.	0xF4, 0xB3	Expand
717	SUBDICTRPGET		#F4B5	dict_sub	F4B5	SUBDICTRPGET	k l D n - D'		Similar to SUBDICTGET, but removes the common prefix k from all keys of the new dictionary D', which becomes of type HashmapE(n-l,X).	0xF4, 0xB5	Expand
718	SUBDICTIRPGET		#F4B6	dict_sub	F4B6	SUBDICTIRPGET	x l D n - D'		Variant of SUBDICTRPGET with the prefix represented by a signed big-endian l-bit Integer x, where necessarily l <= 257.	0xF4, 0xB6	Expand
719	SUBDICTURPGET		#F4B7	dict_sub	F4B7	SUBDICTURPGET	x l D n - D'		Variant of SUBDICTRPGET with the prefix represented by an unsigned big-endian l-bit Integer x, where necessarily l <= 256.	0xF4, 0xB7	Expand
720	ACCEPT		#F800	app_gas	F800	ACCEPT	-	26	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.	0xF8, 0x00	Expand
									In other words, the current smart contract agrees to buy some gas to finish the current transaction. This action is required to process external messages, which bring no value (hence no gas) with themselves.
721	SETGASLIMIT		#F801	app_gas	F801	SETGASLIMIT	g -	26	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.	0xF8, 0x01	Expand
722	BUYGAS		#F802	app_gas	F802	BUYGAS	x -	26	Computes the amount of gas that can be bought for x nanograms, and sets g_l accordingly in the same way as SETGASLIMIT.	0xF8, 0x02	Expand
723	GRAMTOGAS		#F804	app_gas	F804	GRAMTOGAS	x - g		Computes the amount of gas that can be bought for x nanograms. If x is negative, returns 0. If g exceeds 2^63 - 1, it is replaced with this value.	0xF8, 0x04	Expand
724	GASTOGRAM		#F805	app_gas	F805	GASTOGRAM	g - x		Computes the price of g gas in nanograms.	0xF8, 0x05	Expand
725	COMMIT		#F80F	app_gas	F80F	COMMIT	-	26	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.	0xF8, 0x0F	Expand
726	RANDU256		#F810	app_rnd	F810	RANDU256	- x	26+|c7|+|c1_1|	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.	0xF8, 0x10	Expand
727	RAND		#F811	app_rnd	F811	RAND	y - z	26+|c7|+|c1_1|	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.	0xF8, 0x11	Expand
									Equivalent to RANDU256 256 MULRSHIFT.
728	SETRAND		#F814	app_rnd	F814	SETRAND	x -	26+|c7|+|c1_1|	Sets the random seed to unsigned 256-bit Integer x.	0xF8, 0x14	Expand
729	ADDRAND		#F815	app_rnd	F815	ADDRAND	x -	26	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.	0xF8, 0x15	Expand
						RANDOMIZE
730	GETPARAM		#F82 i:uint4	app_config	F82i	[i] GETPARAM	- x	26	Returns the i-th parameter from the Tuple provided at c7 for 0 <= i <= 15. Equivalent to c7 PUSHCTR FIRST [i] INDEX.	[c = parse_const_u4] 0xF8, 0x20 | c	Expand
									If one of these internal operations fails, throws an appropriate type checking or range checking exception.
731	NOW	GETPARAM	#F823	app_config	F823	NOW	- x	26	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.	0xF8, 0x23	Expand
									Equivalent to 3 GETPARAM.
732	BLOCKLT	GETPARAM	#F824	app_config	F824	BLOCKLT	- x	26	Returns the starting logical time of the current block.	0xF8, 0x24	Expand
									Equivalent to 4 GETPARAM.
733	LTIME	GETPARAM	#F825	app_config	F825	LTIME	- x	26	Returns the logical time of the current transaction.	0xF8, 0x25	Expand
									Equivalent to 5 GETPARAM.
734	RANDSEED	GETPARAM	#F826	app_config	F826	RANDSEED	- x	26	Returns the current random seed as an unsigned 256-bit Integer.	0xF8, 0x26	Expand
									Equivalent to 6 GETPARAM.
735	BALANCE	GETPARAM	#F827	app_config	F827	BALANCE	- t	26	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'').	0xF8, 0x27	Expand
									Equivalent to 7 GETPARAM.
									Note that RAW primitives such as SENDRAWMSG do not update this field.
736	MYADDR	GETPARAM	#F828	app_config	F828	MYADDR	- s	26	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.	0xF8, 0x28	Expand
									Equivalent to 8 GETPARAM.
737	CONFIGROOT	GETPARAM	#F829	app_config	F829	CONFIGROOT	- D	26	Returns the Maybe Cell D with the current global configuration dictionary. Equivalent to 9 GETPARAM .	0xF8, 0x29	Expand
738	MYCODE	GETPARAM	#F82A	app_config	F82A	MYCODE	- s	26	Returns the Cell with the current code of the smart contract. Smart contract has own code, the cell representation of which can be obtained by this instruction.	0xF8, 0x2A	Expand
									Equivalent to 10 GETPARAM
739	INITCODEHASH	GETPARAM	#F82B	app_config	F82B	INITCODEHASH	- x	26	Returns the integer represented 256 bit hash of code cell with which the contract was deployed.	0xF8, 0x2B	Expand
									Equivalent to 11 GETPARAM.
740	STORAGEFEE		#F82C	app_config	F82C	STORAGEFEE	- x	26	Returns the Integer with collected storage fee from account in this transaction.	0xF8, 0x2C	Expand
									Equivalent to 12 GETPARAM.
741	SEQNO		#F82D	app_config	F82D	SEQNO	- x	26	returns the Integer with current sequence number of collating block.	0xF8, 0x2D	Expand
									Equivalent to 13 GETPARAM.
742	CONFIGDICT		#F830	app_config	F830	CONFIGDICT	- D 32	26	Returns the global configuration dictionary along with its key length (32).	0xF8, 0x30	Expand
									Equivalent to CONFIGROOT 32 PUSHINT.
743	CONFIGPARAM		#F832	app_config	F832	CONFIGPARAM	i - c -1 or 0		Returns the value of the global configuration parameter with integer index i as a Cell c, and a flag to indicate success.	0xF8, 0x32	Expand
									Equivalent to CONFIGDICT DICTIGETREF.
744	CONFIGOPTPARAM		#F833	app_config	F833	CONFIGOPTPARAM	i - c^?		Returns the value of the global configuration parameter with integer index i as a Maybe Cell c^?.	0xF8, 0x33	Expand
									Equivalent to CONFIGDICT DICTIGETOPTREF.
745	GETGLOBVAR		#F840	app_global	F840	GETGLOBVAR	k - x	26	Returns the k-th global variable for 0 <= k < 255.	0xF8, 0x40	Expand
									Equivalent to c7 PUSHCTR SWAP INDEXVARQ.
746	GETGLOB		#F85_ k:(## 5) {1 <= k}	app_global	F85_k	[k] GETGLOB	- x	26	Returns the k-th global variable for 1 <= k <= 31.	[k = parse_const_u5] 0xF8, 0x40 | k	Expand
									Equivalent to c7 PUSHCTR [k] INDEXQ.
747	SETGLOBVAR		#F860	app_global	F860	SETGLOBVAR	x k -	26+|c7’|	Assigns x to the k-th global variable for 0 <= k < 255.	0xF8, 0x60	Expand
									Equivalent to c7 PUSHCTR ROTREV SETINDEXVARQ c7 POPCTR.
748	SETGLOB		#F87_ k:(## 5) {1 <= k}	app_global	F87_k	[k] SETGLOB	x -	26+|c7’|	Assigns x to the k-th global variable for 1 <= k <= 31.	[k = parse_const_u5] 0xF8, 0x60 | k	Expand
									Equivalent to c7 PUSHCTR SWAP k SETINDEXQ c7 POPCTR.
749	HASHCU		#F900	app_crypto	F900	HASHCU	c - x	26	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.	0xF9, 0x00	Expand
750	HASHSU		#F901	app_crypto	F901	HASHSU	s - x	526	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.	0xF9, 0x01	Expand
751	SHA256U		#F902	app_crypto	F902	SHA256U	s - x	26	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.	0xF9, 0x02	Expand
752	CHKSIGNU		#F910	app_crypto	F910	CHKSIGNU	h s k - ?	26	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).	0xF9, 0x10	Expand
									The signature s must be a Slice containing at least 512 data bits; only the first 512 bits are used. The result is -1 if the signature is valid, 0 otherwise.
									Notice that CHKSIGNU is equivalent to ROT NEWC 256 STU ENDC ROTREV CHKSIGNS, i.e., to CHKSIGNS with the first argument d set to 256-bit Slice containing h. Therefore, if h is computed as the hash of some data, these data are hashed twice, the second hashing occurring inside CHKSIGNS.
753	CHKSIGNS		#F911	app_crypto	F911	CHKSIGNS	d s k - ?	26	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.	0xF9, 0x11	Expand
754	CDATASIZEQ		#F940	app_misc	F940	CDATASIZEQ	c n - x y z -1 or 0		Recursively computes the count of distinct cells x, data bits y, and cell references z in the dag rooted at Cell c, effectively returning the total storage used by this dag taking into account the identification of equal cells. The values of x, y, and z are computed by a depth-first traversal of this dag, with a hash table of visited cell hashes used to prevent visits of already-visited cells. The total count of visited cells x cannot exceed non-negative Integer n; otherwise the computation is aborted before visiting the (n+1)-st cell and a zero is returned to indicate failure. If c is Null, returns x=y=z=0.	0xF9, 0x40	Expand
755	CDATASIZE		#F941	app_misc	F941	CDATASIZE	c n - x y z		A non-quiet version of CDATASIZEQ that throws a cell overflow exception (8) on failure.	0xF9, 0x41	Expand
756	SDATASIZEQ		#F942	app_misc	F942	SDATASIZEQ	s n - x y z -1 or 0		Similar to CDATASIZEQ, but accepting a Slice s instead of a Cell. The returned value of x does not take into account the cell that contains the slice s itself; however, the data bits and the cell references of s are accounted for in y and z.	0xF9, 0x42	Expand
757	SDATASIZE		#F943	app_misc	F943	SDATASIZE	s n - x y z		A non-quiet version of SDATASIZEQ that throws a cell overflow exception (8) on failure.	0xF9, 0x43	Expand
758	FIND_BY_INIT_CODE_HASH		#F944	app_misc	F944	FIND_BY_INIT_CODE_HASH	s - t		Returns the list of accounts with initial code hash specified in 256 bit of Slice s.	0xF9, 0x44	Expand
759	FIND_BY_CODE_HASH		#F945	app_misc	F945	FIND_BY_CODE_HASH	s - t		Returns the list of accounts with code hash specified in 256 bit of Slice s.	0xF9, 0x45	Expand
760	FIND_BY_DATA_HASH		#F946	app_misc	F946	FIND_BY_DATA_HASH	s - t		Returns the list of accounts with data hash specified in 256 bit of Slice s.	0xF9, 0x46	Expand
761	TRYELECT		#F950	app_misc	F950	TRYELECT	D - c c' D' x x'		Executes try_elect method for accounts got by config param 30. D is the input Hashmap with credits, c - contains serialized validator set, c' is the HashmapE with frozen stakes, D' is the HashmapE with credits, x is the integer with total stake, x' is the integer with total weight.		Expand
762	LDGRAMS		#FA00	app_currency	FA00	LDGRAMS	s - x s'	26	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.	0xFA, 0x00	Expand
						LDVARUINT16			The net effect is approximately equivalent to 4 LDU SWAP 3 LSHIFT# LDUX.
763	LDVARINT16		#FA01	app_currency	FA01	LDVARINT16	s - x s'	26	Similar to LDVARUINT16, but loads a signed Integer x.	0xFA, 0x01	Expand
									Approximately equivalent to 4 LDU SWAP 3 LSHIFT# LDIX.
764	STGRAMS		#FA02	app_currency	FA02	STGRAMS	b x - b'	26	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.	0xFA, 0x02	Expand
						STVARUINT16
765	STVARINT16		#FA03	app_currency	FA03	STVARINT16	b x - b'	26	Similar to STVARUINT16, but serializes a signed Integer x in the range -2^119...2^119-1.	0xFA, 0x03	Expand
766	LDVARUINT32		#FA04	app_currency	FA04	LDVARUINT32	s - x s'		Loads (deserializes) a VarUInteger 32 from CellSlices, and returns the deserialized value as an Integer 0 <= x<2^248. The expected serialization of x consists of a 5-bit unsigned big-endian integer l, followed by an 8l-bit unsigned big-endian representation of x. The net effect is approximately equivalent to LDU 5; SWAP; SHIFT 3; LDUX.	0xFA, 0x04	Expand
767	LDVARINT32		#FA05	app_currency	FA05	LDVARINT32	s - x s'		Deserializes a VarInteger 32 from CellSlices, and returns the deserialized value as an Integer-2^247 <= x<2^247.	0xFA, 0x05	Expand
768	STVARUINT32		#FA06	app_currency	FA06	STVARUINT32	b x - b'	26	Serializes an Integer 0<=x<2^248 as a VarUInteger 32.	0xFA, 0x06	Expand
769	STVARINT32		#FA07	app_currency	FA07	STVARINT32	b x - b'	26	serializes an Integer -2^247<=x<2^{247} as a VarInteger 32.	0xFA, 0x07	Expand
770	LDMSGADDR		#FA40	app_addr	FA40	LDMSGADDR	s - s' s''	26	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.	0xFA, 0x40	Expand
771	LDMSGADDRQ		#FA41	app_addr	FA41	LDMSGADDRQ	s - s' s'' -1 or s 0	26	A quiet version of LDMSGADDR: on success, pushes an extra -1; on failure, pushes the original s and a zero.	0xFA, 0x41	Expand
772	PARSEMSGADDR		#FA42	app_addr	FA42	PARSEMSGADDR	s - t	26	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.	0xFA, 0x42	Expand
773	PARSEMSGADDRQ		#FA43	app_addr	FA43	PARSEMSGADDRQ	s - t -1 or 0	26	A quiet version of PARSEMSGADDR: returns a zero on error instead of throwing an exception.	0xFA, 0x43	Expand
774	REWRITESTDADDR		#FA44	app_addr	FA44	REWRITESTDADDR	s - x y	26	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.	0xFA, 0x44	Expand
775	REWRITESTDADDRQ		#FA45	app_addr	FA45	REWRITESTDADDRQ	s - x y -1 or 0	26	A quiet version of primitive REWRITESTDADDR.	0xFA, 0x45	Expand
776	REWRITEVARADDR		#FA46	app_addr	FA46	REWRITEVARADDR	s - x s'	26	A variant of REWRITESTDADDR that returns the (rewritten) address as a Slice s, even if it is not exactly 256 bit long (represented by a msg_addr_var).	0xFA, 0x46	Expand
777	REWRITEVARADDRQ		#FA47	app_addr	FA47	REWRITEVARADDRQ	s - x s' -1 or 0	26	A quiet version of primitive REWRITEVARADDR.	0xFA, 0x47	Expand
778	SENDRAWMSG		#FB00	app_actions	FB00	SENDRAWMSG	c x -	526	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.	0xFB, 0x00	Expand
779	RAWRESERVE		#FB02	app_actions	FB02	RAWRESERVE	x y -	526	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.	0xFB, 0x02	Expand
780	RAWRESERVEX		#FB03	app_actions	FB03	RAWRESERVEX	x D y -	526	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.	0xFB, 0x03	Expand
781	SETCODE		#FB04	app_actions	FB04	SETCODE	c -	526	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.	0xFB, 0x04	Expand
782	SETLIBCODE		#FB06	app_actions	FB06	SETLIBCODE	c x -	526	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.	0xFB, 0x06	Expand
783	CHANGELIB		#FB07	app_actions	FB07	CHANGELIB	h x -	526	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.	0xFB, 0x07	Expand
784	COPYLEFT		#FB0A	app_actions	FB0A	COPYLEFT	s x -	526	Where s - is slice of 256-bit AccountId and x - is type of license. Add license payment to code creator. The license payment calculates from compute _phase_fees taking the appropriate percentage. If summary payment is less than license _payment_threshold, then value saves in unsplit_shard_state of masterblock. If summary payment in unsplit_shard_state is more than license_payment_threshold then node sends internal message to account address in masterchain, specified in slice s. The instruction return an error on contracts in masterchain.	0xFB, 0x0A	Expand
785	DEBUG		#FE nn:(#<= 239)	debug	FEnn	{nn} DEBUG	-	26	0 <= nn < 240	[z = parse_const_u8_240] 0xFE, z	Expand
786	DEBUGSTR		#FEF n:(## 4) ssss:((n 8 + 8) Bit)	debug	FEFnssss	{string} DEBUGSTR	-	26	0 <= n < 16. Length of ssss is n+1 bytes.	[z = parse_const_u8_setcp] 0xFF, z	Expand
						{string} {x} DEBUGSTRI			{string} is a string literal.
									DEBUGSTR: ssss is the given string.
									DEBUGSTRI: ssss is one-byte integer 0 <= x <= 255 followed by the given string.
787	DUMPSTK	DEBUG	#FE00	debug	FE00	DUMPSTK	-	26	Dumps the stack (at most the top 255 values) and shows the total stack depth.	0xFE, 0x00	Expand
788	DUMPSTKTOP		#FE0 n:(## 4)	debug	FE0n	{n} DUMPSTKTOP	-	26	1<=n<15, dumps the top n values from the stack, starting from the deepest of them. If there are d<n values available, dumps only d values.	[z = parse_const_u4_1_14] 0xFE, z	Expand
789	HEXDUMP		#FE10	debug	FE10	HEXDUMP	-	26	Dumps s0 in hexadecimal form, be it a Slice or an Integer.	0xFE, 0x10	Expand
790	HEXPRINT		#FE11	debug	FE11	HEXPRINT	-	26	Similar to HEXDUMP, except the hexadecimal representation of s0 is not immediately output, but rather concatenated to an output text buffer.	0xFE, 0x11	Expand
791	BINDUMP		#FE12	debug	FE12	BINDUMP	-	26	Dumps s0 in binary form, similarly to HEXDUMP.	0xFE, 0x12	Expand
792	BINPRINT		#FE13	debug	FE13	BINPRINT	-	26	Outputs the binary representation of s0 to a text buffer.	0xFE, 0x13	Expand
793	STRDUMP		#FE14	debug	FE14	STRDUMP	-	26	Dumps the Slice at s0 as an UTF-8 string.	0xFE, 0x14	Expand
794	STRPRINT		#FE15	debug	FE15	STRPRINT	-	26	Similar to STRDUMP, but outputs the string into a text buffer (without carriage return).	0xFE, 0x15	Expand
795	DEBUGOFF		#FE1E	debug	FE1E	DEBUGOFF	-	26	Disables all debug output until it is re-enabled by a DEBUGON. More precisely, this primitive increases an internal counter, which disables all debug operations (except DEBUGOFF and DEBUGON) when strictly positive.	0xFE, 0x1E	Expand
796	DEBUGON		#FE1F	debug	FE1F	DEBUGON	-	26	Enables debug output (in a debug version of TVM).	0xFE, 0x1F	Expand
797	DUMP	DEBUG	#FE2 i:uint4	debug	FE2i	s[i] DUMP	-	26	Dumps s[i].	[z = parse_const_u4_14] 0xFE, 0x20 | z	Expand
798	PRINT		#FE3 n:uint4	debug	FE3i	s[n] PRINT	-	26	0<=n<15, concatenates the text representation of s(n) (without any leading or trailing spaces or carriage returns) to a text buffer which will be output before the output of any other debug operation.	[z = parse_const_u4_14] 0xFE, 0x30 | z	Expand
799	DUMPTOSFMT		#FEF n:(## 4) ssss:((n 8 + 8) Bit)	debug	FEFnssss	[ssss]DUMPTOSFMT	-	26	Dumps s0 formatted according to the (n+1)-byte string ssss. This string might contain (a prefix of) the name of a TL-B type supported by the debugger. If the string begins with a zero byte, simply outputs it (without the first byte) into the debug log. If the string begins with a byte equal to one, concatenates it to a buffer, which will be output before the output of any other debug operation (effectively outputs a string without a carriage return).		Expand
800	LOGSTR		#FEF n:(## 4) 00 ssss:((n 8 + 8) Bit)	debug	FEFn00ssss	[ssss]LOGSTR	-	26	String ssss is n bytes long.		Expand
801	LOGFLUSH		#FEF000	debug	FEF000	LOGFLUSH	-	26	Flushes all pending debug output from the buffer into the debug log.	0xFE, 0xF0, 0x00	Expand
802	PRINTSTR		#FEF n:(## 4) 01 ssss:((n 8 + 8) Bit)	debug	FEFn01ssss	[ssss]PRINTSTR	-	26	String ssss is n bytes long.		Expand
803	SETCP			codepage	FFnn	[nn] SETCP	-	26	Selects TVM codepage 0 <= nn < 240. If the codepage is not supported, throws an invalid opcode exception.	[z = parse_const_u8_setcp] 0xFF, z	Expand
804	SETCP0	SETCP	#FF nn:(#<= 239)	codepage	FF00	SETCP0	-	26	Selects TVM (test) codepage zero as described in this document.	0xFF, 0x00	Expand
805	SETCP_SPECIAL		#FFF z:(## 4) {1 <= z}	codepage	FFFz	[z-16] SETCP	-	26	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.		Expand
806	SETCPX		#FFF0	codepage	FFF0	SETCPX	c -	26	Selects codepage c with -2^15 <= c < 2^15 passed in the top of the stack.	0xFF, 0xF0	Expand