37.5. The instruction set

37.5.1. Instructions for constants
37.5.2. Instructions for lexical variables
37.5.3. Instructions for dynamic variables
37.5.4. Instructions for stack operations
37.5.5. Instructions for control flow, jumps
37.5.6. Instructions for lexical environment, creation of closures
37.5.7. Instructions for function calls
37.5.8. Instructions for optional and keyword parameters
37.5.9. Instructions for multiple values
37.5.10. Instructions for BLOCK and RETURN-FROM
37.5.11. Instructions for TAGBODY and GO
37.5.12. Instructions for CATCH and THROW
37.5.13. Instructions for UNWIND-PROTECT
37.5.14. Instructions for HANDLER-BIND
37.5.15. Instructions for some inlined functions
37.5.16. Combined instructions
37.5.17. Shortcut instructions

37.5.1. Instructions for constants

mnemonicdescriptionsemantics
(NIL)Load NIL into values.value1 := NIL, mv_count := 1
(PUSH-NIL n)Push n NILs into the STACK.n times do: *--STACK := NIL, Invalidate values.
(T)Load T into values.value1 := T, mv_count := 1
(CONST n)Load the function's nth constant into values.value1 := consts[n], mv_count := 1

37.5.2. Instructions for lexical variables

mnemonicdescriptionsemantics
(LOAD n)Load a directly accessible local variable into values.value1 := *(STACK+n), mv_count := 1
(LOADI k1 k2 n)Load an indirectly accessible local variable into values.k := k1 + jmpbufsize * k2, value1 := *(*(SP+k)+ n), mv_count := 1
(LOADC n m)Load a closed-up variable, defined in the same function and directly accessible, into values.value1 := SVREF(*(STACK+n),1+m), mv_count := 1
(LOADV k m)Load a closed-up variable, defined in an outer function, into values.v := venv-const, m times do: v := SVREF(v,0), value1 := SVREF(v,m), mv_count := 1
(LOADIC k1 k2 n m)Load a closed-up variable, defined in the same function and indirectly accessible, into values.k := k1 + jmpbufsize * k2, value1 := SVREF(*(*(SP+k)+n),1+m), mv_count := 1
(STORE n)Store values into a directly accessible local variable.*(STACK+n) := value1, mv_count := 1
(STOREI k1 k2 n)Store values into an indirectly accessible local variable.k := k1 + jmpbufsize * k2, *(*(SP+k)+ n) := value1, mv_count := 1
(STOREC n m)Store values into a closed-up variable, defined in the same function and directly accessible.SVREF(*(STACK+n),1+m) := value1, mv_count := 1
(STOREV k m)Store values into a closed-up variable, defined in an outer function.v := venv-const, m times do: v := SVREF(v,0), SVREF(v,m) := value1, mv_count := 1
(STOREIC k1 k2 n m)Store values into a closed-up variable, defined in the same function and indirectly accessible.k := k1 + jmpbufsize * k2, SVREF(*(*(SP+k)+n),1+m) := value1, mv_count := 1

37.5.3. Instructions for dynamic variables

mnemonicdescriptionsemantics
(GETVALUE n)Load a symbol's value into values.value1 := symbol-value(consts[n]), mv_count := 1
(SETVALUE n)Store values into a symbol's value.symbol-value(consts[n]) := value1, mv_count := 1
(BIND n)Bind a symbol dynamically.Bind the value of the symbol consts[n] to value1, implicitly STACK -= 3, Invalidate values.
(UNBIND1)Dissolve one binding frame.Unbind the binding frame STACK is pointing to, implicitly STACK += 3
(UNBIND n)Dissolve n binding frames.n times do: Unbind the binding frame STACK is pointing to, thereby incrementing STACK Thus, STACK += 1+2*n
(PROGV)Bind a set of symbols dynamically to a set of values.symbols := *STACK++, *--SP := STACK, build a single binding frame binding the symbols in symbols to the values in value1, Invalidate values.

37.5.4. Instructions for stack operations

mnemonicdescriptionsemantics
(PUSH)Push one object onto the STACK.*--STACK := value1, Invalidate values.
(POP)Pop one object from the STACK, into values.value1 := *STACK++, mv_count := 1
(SKIP n)Restore a previous STACK pointer. Remove n objects from the STACK.STACK := STACK + n
(SKIPI k1 k2 n)Restore a previous STACK pointer. Remove an unknown number of objects from the STACK.k := k1 + jmpbufsize * k2, STACK := *(SP+k), SP := SP+k+1, STACK := STACK + n
(SKIPSP k1 k2)Restore a previous SP pointer.k := k1 + jmpbufsize * k2, SP := SP+k

37.5.5. Instructions for control flow, jumps

mnemonicdescriptionsemantics
(SKIP&RET n)Clean up the STACK, and return from the function.STACK := STACK+n, return from the function, returning values.
(SKIP&RETGF n)Clean up the STACK, and return from the generic function.If bit 3 is set in the function's flags, then STACK := STACK+n, mv_count := 1, and return from the function. Otherwise: if the current function has no &REST argument, then STACK := STACK+n-numreq, apply value1 to the numreq arguments still on the STACK, and return from the function. Else STACK := STACK+n-numreq-1, apply value1 to the numreq arguments and the &REST argument, all still on the STACK, and return from the function.
(JMP label)Jump to label.PC := label.
(JMPIF label)Jump to label, if value1 is true.If value1 is not NIL, PC := label.
(JMPIFNOT label)Jump to label, if value1 is false.If value1 is NIL, PC := label.
(JMPIF1 label)Jump to label and forget secondary values, if value1 is true.If value1 is not NIL, mv_count := 1, PC := label.
(JMPIFNOT1 label)Jump to label and forget secondary values, if value1 is false.If value1 is NIL, mv_count := 1, PC := label.
(JMPIFATOM label)Jump to label, if value1 is not a cons.If value1 is not a cons, PC := label. Invalidate values.
(JMPIFCONSP label)Jump to label, if value1 is a cons.If value1 is a cons, PC := label. Invalidate values.
(JMPIFEQ label)Jump to label, if value1 is EQ to the top-of-stack.If eq(value1,*STACK++), PC := label. Invalidate values.
(JMPIFNOTEQ label)Jump to label, if value1 is not EQ to the top-of-stack.If not eq(value1,*STACK++), PC := label. Invalidate values.
(JMPIFEQTO n label)Jump to label, if the top-of-stack is EQ to a constant.If eq(*STACK++,consts[n]), PC := label. Invalidate values.
(JMPIFNOTEQTO n label)Jump to label, if the top-of-stack is not EQ to a constant.If not eq(*STACK++,consts[n]), PC := label. Invalidate values.
(JMPHASH n label)Table-driven jump, depending on value1.Lookup value1 in the hash table consts[n]. (The hash table's test is either EQ or EQL.) If found, the hash table value is a signed FIXNUM, jump to it: PC := PC + value. Else jump to label. Invalidate values.
(JMPHASHV n label)Table-driven jump, depending on value1, inside a generic function.Lookup value1 in the hash table SVREF(consts[0],n). (The hash table's test is either EQ or EQL.) If found, the hash table value is a signed FIXNUM, jump to it: PC := PC + value. Else jump to label. Invalidate values.
(JSR label)Subroutine call.*--STACK := function. Then start interpreting the bytecode at label, with values undefined. When a (RET) is encountered, program execution is resumed at the instruction after (JSR label).
(JMPTAIL m n label)Tail subroutine call.n >= m. The STACK frame of size n is reduced to size m: {*(STACK+n-m), ..., *(STACK+n-1)} := {*STACK, ..., *(STACK+m-1)}. STACK += n-m. *--STACK := function. Then jump to label, with values undefined.

37.5.6. Instructions for lexical environment, creation of closures

mnemonicdescriptionsemantics
(VENV)Load the venv-const into values.value1 := consts[0], mv_count := 1.
(MAKE-VECTOR1&PUSH n)Create a SIMPLE-VECTOR used for closed-up variables.v := new SIMPLE-VECTOR of size n+1. SVREF(v,0) := value1. *--STACK := v. Invalidate values.
(COPY-CLOSURE m n)Create a closure by copying the prototype and filling in the lexical environment.f := copy-function(consts[m]). For i=0,..,n-1: f_consts[i] := *(STACK+n-1-i). STACK += n. value1 := f, mv_count := 1

37.5.7. Instructions for function calls

mnemonicdescriptionsemantics
(CALL k n)Calls a constant function with k arguments.The function consts[n] is called with the arguments *(STACK+k-1), ..., *(STACK+0). STACK += k. The returned values go into values.
(CALL0 n)Calls a constant function with 0 arguments.The function consts[n] is called with 0 arguments. The returned values go into values.
(CALL1 n)Calls a constant function with 1 argument.The function consts[n] is called with one argument *STACK. STACK += 1. The returned values go into values.
(CALL2 n)Calls a constant function with 2 arguments.The function consts[n] is called with two arguments *(STACK+1) and *(STACK+0). STACK += 2. The returned values go into values.
(CALLS1 b)Calls a system function with no &REST.Calls the system function FUNTAB[b]. The right number of arguments is already on the STACK (including #<UNBOUND>s in place of absent &OPTIONAL or &KEY parameters). The arguments are removed from the STACK. The returned values go into values.
(CALLS2 b)Calls a system function with no &REST.Calls the system function FUNTAB[256+b]. The right number of arguments is already on the STACK (including #<UNBOUND>s in place of absent &OPTIONAL or &KEY parameters). The arguments are removed from the STACK. The returned values go into values.
(CALLSR m b)Calls a system function with &REST.Calls the system function FUNTABR[b]. The minimum number of arguments is already on the STACK, and m additional arguments as well. The arguments are removed from the STACK. The returned values go into values.
(CALLC)Calls a computed compiled function with no &KEYs.Calls the compiled function value1. The right number of arguments is already on the STACK (including #<UNBOUND>s in place of absent &OPTIONAL parameters). The arguments are removed from the STACK. The returned values go into values.
(CALLCKEY)Calls a computed compiled function with &KEYs.Calls the compiled function value1. The right number of arguments is already on the STACK (including #<UNBOUND>s in place of absent &OPTIONAL or &KEY parameters). The arguments are removed from the STACK. The returned values go into values.
(FUNCALL n)Calls a computed function.Calls the function *(STACK+n) with the arguments *(STACK+n-1), ..., *(STACK+0). STACK += n+1. The returned values go into values.
(APPLY n)Calls a computed function with an unknown number of arguments.Calls the function *(STACK+n) with the arguments *(STACK+n-1), ..., *(STACK+0) and a list of additional arguments value1. STACK += n+1. The returned values go into values.

37.5.8. Instructions for optional and keyword parameters

mnemonicdescriptionsemantics
(PUSH-UNBOUND n)Push n #<UNBOUND>s into the STACK.n times do: *--STACK := #<UNBOUND>. Invalidate values.
(UNLIST n m)Destructure a proper LIST.0 ≤ mn. n times do: *--STACK := CAR(value1), value1 := CDR(value1). During the last m iterations, the list value1 may already have reached its end; in this case, *--STACK := #<UNBOUND>. At the end, value1 must be NIL. Invalidate values.
(UNLIST* n m)Destructure a proper or dotted LIST.0 ≤ mn, n > 0. n times do: *--STACK := CAR(value1), value1 := CDR(value1). During the last m iterations, the list value1 may already have reached its end; in this case, *--STACK := #<UNBOUND>. At the end, after n CDRs, *--STACK := value1. Invalidate values.
(JMPIFBOUNDP n label)Jump to label, if a local variable is not unbound.If *(STACK+n) is not #<UNBOUND>, value1 := *(STACK+n), mv_count := 1, PC := label. Else: Invalidate values..
(BOUNDP n)Load T or NIL into values, depending on whether a local variable is bound.If *(STACK+n) is not #<UNBOUND>, value1 := T, mv_count := 1. Else: value1 := NIL, mv_count := 1.
(UNBOUND->NIL n)If a local variable is unbound, assign a default value NIL to it.If *(STACK+n) is #<UNBOUND>, *(STACK+n) := NIL.

37.5.9. Instructions for multiple values

mnemonicdescriptionsemantics
(VALUES0)Load no values into values.value1 := NIL, mv_count := 0
(VALUES1)Forget secondary values.mv_count := 1
(STACK-TO-MV n)Pop the first n objects from STACK into values.Load values(*(STACK+n-1),...,*(STACK+0)) into values. STACK += n.
(MV-TO-STACK)Save values on STACK.Push the mv_count values onto the STACK (in order: value1 comes first). STACK -= mv_count. Invalidate values.
(NV-TO-STACK n)Save n values on STACK.Push the first n values onto the STACK (in order: value1 comes first). STACK -= n. Invalidate values.
(MV-TO-LIST)Convert multiple values into a list.value1 := list of values, mv_count := 1
(LIST-TO-MV)Convert a LIST into multiple values.Call the function VALUES-LIST with value1 as argument. The returned values go into values.
(MVCALLP)Start a MULTIPLE-VALUE-CALL invocation.*--SP := STACK. *--STACK := value1.
(MVCALL)Finish a MULTIPLE-VALUE-CALL invocation.newSTACK := *SP++. Call the function *(newSTACK-1), passing it *(newSTACK-2), ..., *(STACK+0) as arguments. STACK := newSTACK. The returned values go into values.

37.5.10. Instructions for BLOCK and RETURN-FROM

mnemonicdescriptionsemantics
(BLOCK-OPEN n label)Create a BLOCK frame.Create a BLOCK frame, STACK -= 3, SP -= 2+jmpbufsize. The topmost (third) object in the block frame is CONS(consts[n],frame-pointer) (its block-cons). Upon a RETURN-FROM to this frame, execution will continue at label. Invalidate values..
(BLOCK-CLOSE)Dissolve a BLOCK frame.Dissolve the BLOCK frame at STACK, STACK += 3, SP += 2+jmpbufsize. Mark the block-cons as invalid.
(RETURN-FROM n)Leave a BLOCK whose block-cons is given.block-cons := consts[n]. If CDR(block-cons) = #<DISABLED>, an ERROR is SIGNALed. Else CDR(block-cons) is a frame-pointer. Unwind the stack up to this frame, pass it values.
(RETURN-FROM-I k1 k2 n)Leave a BLOCK whose block-cons is indirectly accessible.k := k1 + jmpbufsize * k2, block-cons := *(*(SP+k)+n). If CDR(block-cons) = #<DISABLED>, an ERROR is SIGNALed. Else CDR(block-cons) is a frame-pointer. Unwind the stack up to this frame, pass it values.

37.5.11. Instructions for TAGBODY and GO

mnemonicdescriptionsemantics
(TAGBODY-OPEN m label1 ... labeln)Create a TAGBODY frame.Fetch consts[m], this is a SIMPLE-VECTOR with n elements, then decode n label operands. Create a TAGBODY frame, STACK -= 3+n, SP -= 1+jmpbufsize. The third object in the TAGBODY frame is CONS(consts[m],frame-pointer) (the tagbody-cons) Upon a GO to tag label of this frame, execution will continue at labell. Invalidate values.
(TAGBODY-CLOSE-NIL)Dissolve a TAGBODY frame, and load NIL into values.Dissolve the TAGBODY frame at STACK, STACK += 3+m, SP += 1+jmpbufsize. Mark the tagbody-cons as invalid. value1 := NIL, mv_count := 1.
(TAGBODY-CLOSE)Dissolve a TAGBODY frame.Dissolve the TAGBODY frame at STACK, STACK += 3+m, SP += 1+jmpbufsize. Mark the tagbody-cons as invalid.
(GO n label)Jump into a TAGBODY whose tagbody-cons is given.tagbody-cons := consts[n]. If CDR(tagbody-cons) = #<DISABLED>, an ERROR is SIGNALed. Else CDR(tagbody-cons) is a frame-pointer. Unwind the stack up to this frame, pass it the number label.
(GO-I k1 k2 n label)Jump into a TAGBODY whose tagbody-cons is indirectly accessible.k := k1 + jmpbufsize * k2, tagbody-cons := *(*(SP+k)+n). If CDR(tagbody-cons) = #<DISABLED>, an ERROR is SIGNALed. Else CDR(tagbody-cons) is a frame-pointer. Unwind the stack up to this frame, pass it the number label.

37.5.12. Instructions for CATCH and THROW

mnemonicdescriptionsemantics
(CATCH-OPEN label)Create a CATCH frame.Create a CATCH frame, with value1 as tag. STACK -= 3, SP -= 2+jmpbufsize. Upon a THROW to this tag execution continues at label.
(CATCH-CLOSE)Dissolve a CATCH frame.Dissolve the CATCH frame at STACK. STACK += 3, SP += 2+jmpbufsize.
(THROW)Non-local exit to a CATCH frame.tag := *STACK++. Search the innermost CATCH frame with tag tag on the STACK, unwind the stack up to it, pass it values.

37.5.13. Instructions for UNWIND-PROTECT

mnemonicdescriptionsemantics
(UNWIND-PROTECT-OPEN label)Create an UNWIND-PROTECT frame.Create an UNWIND-PROTECT frame. STACK -= 2, SP -= 2+jmpbufsize. When the stack will be unwound by a non-local exit, values will be saved on STACK, and execution will be transferred to label.
(UNWIND-PROTECT-NORMAL-EXIT)Dissolve an UNWIND-PROTECT frame, and start the cleanup code.Dissolve the UNWIND-PROTECT frame at STACK. STACK += 2, SP += 2+jmpbufsize. *--SP := 0, *--SP := 0, *--SP := STACK. Save the values on the STACK, STACK -= mv_count.
(UNWIND-PROTECT-CLOSE)Terminate the cleanup code.newSTACK := *SP++. Load values(*(newSTACK-1), ..., *(STACK+0)) into values. STACK := newSTACK. SPword1 := *SP++, SPword2 := *SP++. Continue depending on SPword1 and SPword2. If both are 0, simply continue execution. If SPword2 is 0 but SPword1 is nonzero, interpret it as a label and jump to it.
(UNWIND-PROTECT-CLEANUP)Dissolve an UNWIND-PROTECT frame, and execute the cleanup code like a subroutine call.Dissolve the UNWIND-PROTECT frame at STACK, get label out of the frame. STACK += 2, SP += 2+jmpbufsize. *--SP := 0, *--SP := PC, *--SP := STACK. Save the values on the STACK, STACK -= mv_count. PC := label.

37.5.14. Instructions for HANDLER-BIND

mnemonicdescriptionsemantics
(HANDLER-OPEN n)Create a handler frame.Create a handler frame, using consts[n] which contains the CONDITION types, the corresponding labels and the current SP depth (= function entry SP - current SP).
(HANDLER-BEGIN&PUSH)Start a handler.Restore the same SP state as after the HANDLER-OPEN. value1 := the CONDITION that was passed to the handler, mv_count := 1. *--STACK := value1.

37.5.15. Instructions for some inlined functions

mnemonicdescriptionsemantics
(NOT)Inlined call to NOT.value1 := not(value1), mv_count := 1.
(EQ)Inlined call to EQ.value1 := eq(*STACK++,value1), mv_count := 1.
(CAR)Inlined call to CAR.value1 := CAR(value1), mv_count := 1.
(CDR)Inlined call to CDR.value1 := CDR(value1), mv_count := 1.
(CONS)Inlined call to CONS.value1 := cons(*STACK++,value1), mv_count := 1.
(SYMBOL-FUNCTION)Inlined call to SYMBOL-FUNCTION.value1 := SYMBOL-FUNCTION(value1), mv_count := 1.
(SVREF)Inlined call to SVREF.value1 := SVREF(*STACK++,value1), mv_count := 1.
(SVSET)Inlined call to (SETF SVREF.arg1 := *(STACK+1), arg2 := *(STACK+0), STACK += 2. SVREF(arg2,value1) := arg1. value1 := arg1, mv_count := 1.
(LIST n)Inlined call to LIST.value1 := LIST(*(STACK+n-1),...,*(STACK+0)), mv_count := 1, STACK += n.
(LIST* n)Inlined call to LIST*.value1 := LIST*(*(STACK+n-1),..., *(STACK+0),value1), mv_count := 1, STACK += n.

37.5.16. Combined instructions

The most frequent short sequences of instructions have an equivalent combined instruction. They are only present for space and speed optimization. The only exception is FUNCALL&SKIP&RETGF, which is needed for generic functions.

mnemonicequivalent
(NIL&PUSH)(NIL) (PUSH)
(T&PUSH)(T) (PUSH)
(CONST&PUSH n)(CONST n) (PUSH)
(LOAD&PUSH n)(LOAD n) (PUSH)
(LOADI&PUSH k1 k2 n)(LOADI k1 k2 n) (PUSH)
(LOADC&PUSH n m)(LOADC n m) (PUSH)
(LOADV&PUSH k m)(LOADV k m) (PUSH)
(POP&STORE n)(POP) (STORE n)
(GETVALUE&PUSH n)(GETVALUE n) (PUSH)
(JSR&PUSH label)(JSR label) (PUSH)
(COPY-CLOSURE&PUSH m n)(COPY-CLOSURE m n) (PUSH)
(CALL&PUSH k n)(CALL k n) (PUSH)
(CALL1&PUSH n)(CALL1 n) (PUSH)
(CALL2&PUSH n)(CALL2 n) (PUSH)
(CALLS1&PUSH b)(CALLS1 b) (PUSH)
(CALLS2&PUSH b)(CALLS2 b) (PUSH)
(CALLSR&PUSH m n)(CALLSR m n) (PUSH)
(CALLC&PUSH)(CALLC) (PUSH)
(CALLCKEY&PUSH)(CALLCKEY) (PUSH)
(FUNCALL&PUSH n)(FUNCALL n) (PUSH)
(APPLY&PUSH n)(APPLY n) (PUSH)
(CAR&PUSH)(CAR) (PUSH)
(CDR&PUSH)(CDR) (PUSH)
(CONS&PUSH)(CONS) (PUSH)
(LIST&PUSH n)(LIST n) (PUSH)
(LIST*&PUSH n)(LIST* n) (PUSH)
(NIL&STORE n)(NIL) (STORE n)
(T&STORE n)(T) (STORE n)
(LOAD&STOREC k n m)(LOAD k) (STOREC n m)
(CALLS1&STORE b k)(CALLS1 b) (STORE k)
(CALLS2&STORE b k)(CALLS2 b) (STORE k)
(CALLSR&STORE m n k)(CALLSR m n) (STORE k)
(LOAD&CDR&STORE n)(LOAD n) (CDR) (STORE n)
(LOAD&CONS&STORE n)(LOAD n+1) (CONS) (STORE n)
(LOAD&INC&STORE n)(LOAD n) (CALL1 #'1+) (STORE n)
(LOAD&DEC&STORE n)(LOAD n) (CALL1 #'1-) (STORE n)
(LOAD&CAR&STORE m n)(LOAD m) (CAR) (STORE n)
(CALL1&JMPIF n label)(CALL1 n) (JMPIF label)
(CALL1&JMPIFNOT n label)(CALL1 n) (JMPIFNOT label)
(CALL2&JMPIF n label)(CALL2 n) (JMPIF label)
(CALL2&JMPIFNOT n label)(CALL2 n) (JMPIFNOT label)
(CALLS1&JMPIF b label)(CALLS1 b) (JMPIF label)
(CALLS1&JMPIFNOT b label)(CALLS1 b) (JMPIFNOT label)
(CALLS2&JMPIF b label)(CALLS2 b) (JMPIF label)
(CALLS2&JMPIFNOT b label)(CALLS2 b) (JMPIFNOT label)
(CALLSR&JMPIF m n label)(CALLSR m n) (JMPIF label)
(CALLSR&JMPIFNOT m n label)(CALLSR m n) (JMPIFNOT label)
(LOAD&JMPIF n label)(LOAD n) (JMPIF label)
(LOAD&JMPIFNOT n label)(LOAD n) (JMPIFNOT label)
(LOAD&CAR&PUSH n)(LOAD n) (CAR) (PUSH)
(LOAD&CDR&PUSH n)(LOAD n) (CDR) (PUSH)
(LOAD&INC&PUSH n)(LOAD n) (CALL1 #'1+) (PUSH)
(LOAD&DEC&PUSH n)(LOAD n) (CALL1 #'1-) (PUSH)
(CONST&SYMBOL-FUNCTION n)(CONST n) (SYMBOL-FUNCTION)
(CONST&SYMBOL-FUNCTION&PUSH n)(CONST n) (SYMBOL-FUNCTION) (PUSH)
(CONST&SYMBOL-FUNCTION&STORE n k)(CONST n) (SYMBOL-FUNCTION) (STORE k)
(APPLY&SKIP&RET n k)(APPLY n) (SKIP&RET k)
(FUNCALL&SKIP&RETGF n k)(FUNCALL n) (SKIP&RETGF k)

37.5.17. Shortcut instructions

There are special one-byte instructions (without explicit operands) for the following frequent instructions:

mnemonicoperand range
(LOAD n)0 ≤ n < 15
(LOAD&PUSH n)0 ≤ n < 25
(CONST n)0 ≤ n < 21
(CONST&PUSH n)0 ≤ n < 30
(STORE n)0 ≤ n < 8

These notes document CLISP version 2.49+Last modified: 2016-09-05