
SYNTAX: 'DEG'
NOMENCLATURE: degrees mode
PURPOSE: sets the angle mode for the trigonometric functions
  to degrees.
SPECIFICATION: no effect on stack contents.
  the angle mode will show "Degrees".




SYNTAX: 'DSE rr' or 'DSE IND rr'
NOMENCLATURE: decrement and skip if equal to zero
PURPOSE: subtracts 1 from the selected register and then tests
  the register content to see if it equals zero.  This is a
  conditional 1-step jump instruction.  See also 'ISG'.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: the selected register is decremented by 1.  If
  the result is nonzero the program continues its normal
  execution.  If the result is 0 the first program line
  following the DSE line is skipped and the program continues
  executing with the second instruction following the DSE
  program line.  For normal looping and branching purposes the
  line following a DSE instruction is usually (but not always)
  a GTO instruction.
  'DSE rr' specifies the register designated directly by rr.
  'DSE IND rr' specifies the selected register number by
  taking the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES: 'DSE 02'
         'DSE 25'
         'DSE X'
         'DSE IND 20'
         'DSE IND T'





                                                                       page 44


SYNTAX: 'ENTER^'
NOMENCLATURE: enter
PURPOSE: pushes numbers up in the stack by copying X in Y and
  disabling stacklift.
CAUTION: this instruction leaves "Overwrite X" on and has no
  effect on LASTX.  The T-register contents are lost off the
  top of the stack.
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    Z     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Y     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    X     |
                   +---------+           +----------+
                X: |    X    |        X: |    X     |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    L     |
                   +---------+           +----------+

                                        "Overwrite X"



SYNTAX: 'E^X'
NOMENCLATURE: e to the Xth power.
PURPOSE: computes the natural (base e=2.7182818)
  anti-logarithm of X.
CAUTION: if X is too large, overflow may result
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |    e^X   |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    X     |
                   +---------+           +----------+





                                                                       page 45


SYNTAX: 'FC? ff' or 'FC? IND rr' or
       'FC?C ff' or 'FC?C IND rr'
NOMENCLATURE: flag clear test or flag clear test and clear.
PURPOSE: this tests whether or not a selected flag is clear.
  This is a conditional 1-step jump instruction which has an
  option to leave the flag in a cleared state after the test.
RESTRICTION: the specified flag must be in the range 0-9.
SPECIFICATION: the selected flag is tested to see if it is
  clear.  Flags take on the values 0 and 1 and when a flag is
  in state 0 we say it is clear.  When a flag is in state 1 we
  say it is set.  If the letter C immediately follows the ?
  then, after the flag is tested the flag will be set to 0
  (cleared).  As a result of this test the program counter
  is incremented by either 1 or 2.  If the specified flag
  was 0 (clear) then the program counter is incremented by 1
  and the program will continue its normal execution with the
  program line immediately following the flag test.  If the
  specified flag was 1 (set) then the program counter is
  incremented by 2 and the program will skip over the first
  line following the flag test and will continue with the
  second line after the flag test line.
  'FC? ff' and 'FC?C ff' specify the flag designated by ff
  directly.
  'FC? IND rr' and 'FC?C IND rr' calculate the selected flag by
  taking the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 0-9 or a 'NONEXISTENT' error message will
  result.
EXAMPLES: 'FC? 09'
         'FC? 01'
         'FC?C IND Z'
         'FC? IND X'
         'FC?C IND 37'



SYNTAX: 'FRC'
NOMENCLATURE: fractional part.
PURPOSE: calculates the fractional part of a number by dropping
  any digits to the left of the decimal point and keeping all
  digits to the right of the decimal point.
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |  FRC(X)  |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    X     |
                   +---------+           +----------+


                                                                       page 46


SYNTAX: 'FS? ff' or 'FS? IND rr' or
       'FS?C ff' or 'FS?C IND rr'
NOMENCLATURE: flag set test or flag set test and clear.
PURPOSE: this tests whether or not a selected flag is set.
  This is a conditional 1-step jump instruction which has an
  option to leave the flag in a cleared state after the test.
RESTRICTION: the specified flag must be in the range 0-9.
SPECIFICATION: the selected flag is tested to see if it is
  set.  Flags take on the values 0 and 1 and when a flag is
  in state 0 we say it is clear.  When a flag is in state 1 we
  say it is set.  If the letter C immediately follows the ?
  then, after the flag is tested the flag will be set to 0
  (cleared).  As a result of this test the program counter
  is incremented by either 1 or 2.  If the specified flag
  was 1 (set) then the program counter is incremented by 1
  and the program will continue its normal execution with the
  program line immediately following the flag test.  If the
  specified flag was 0 (clear) then the program counter is
  incremented by 2 and the program will skip over the first
  line following the flag test and will continue with the
  second line after the flag test line.
  'FS? ff' and 'FS?C ff' specify the flag designated by ff
  directly.
  'FS? IND rr' and 'FS?C IND rr' calculate the selected flag by
  taking the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 0-9 or a 'NONEXISTENT' error message will
  result.
EXAMPLES: 'FS? 09'
         'FS? 01'
         'FS?C IND Z'
         'FS? IND X'
         'FS?C IND 37'



SYNTAX: 'GTO nn' or 'GTO IND rr'
NOMENCLATURE: go to a numeric label
PURPOSE: transfers program execution to the specified numeric
  label.
RESTRICTIONS: the specified label must be an existing numeric
  label in the range 00-99.
SPECIFICATION: no effect on stack content.  The next statement
  executed will be the first statement following the numeric
  label.
  'GTO nn' specifies the label by referring to nn directly
  'GTO IND rr' calculates the label number by taking the
  integer part of the absolute value of the number contained
  in the register named by rr.  This selector must be in the
  range 00-99.  The numeric label must also exist in the
  current program or a 'NONEXISTENT' error message will
  result.
EXAMPLES: 'GTO 01'
         'GTO IND Z'
         'GTO 12'
         'GTO IND 35'

                                                                       page 47


SYNTAX: 'INT'
NOMENCLATURE: integer part.
PURPOSE: calculates the integer part of a number by dropping
  all digits to the right of the decimal point.
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |  INT(X)  |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    X     |
                   +---------+           +----------+




SYNTAX: 'ISG rr' or 'ISG IND rr'
NOMENCLATURE: increment and skip if equal to zero
PURPOSE: adds 1 to the selected register and then tests
  the register content to see if it equals zero.  This is a
  conditional 1-step jump instruction.  See also 'DSE'.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: the selected register is incremented by 1.  If
  the result is nonzero the program continues its normal
  execution.  If the result is 0 the first program line
  following the ISG line is skipped and the program continues
  executing with the second instruction following the ISG
  program line.  For normal looping and branching purposes the
  line following an ISG instruction is usually (but not
  always) a GTO instruction.
  'ISG rr' specifies the register designated directly by rr.
  'ISG IND rr' specifies the selected register number by
  taking the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES: 'ISG 02'
         'ISG 25'
         'ISG X'
         'ISG IND 20'
         'ISG IND T'


                                                                       page 48


SYNTAX: 'LASTX'
NOMENCLATURE: recall last X.
PURPOSE: retrieves the number stored in the L stack register.
SPECIFICATION: this command is equivalent to RCL L.
  There are two different cases depending on the state of
  the "Overwrite X" message.
                           before:               after:
                         +---------+           +----------+
                      T: |    T    |        T: |    T     |
                         +---------+           +----------+
                      Z: |    Z    |        Z: |    Z     |
"Overwrite X" on          +---------+           +----------+
                      Y: |    Y    |        Y: |    Y     |
                         +---------+           +----------+
                      X: |    X    |        X: |    L     |
                         +---------+           +----------+

                         +---------+           +----------+
                      L: |    L    |        L: |    L     |
                         +---------+           +----------+

                ---------------------------------------------

                         +---------+           +----------+
                      T: |    T    |        T: |    Z     |
                         +---------+           +----------+
                      Z: |    Z    |        Z: |    Y     |
"Overwrite X" off         +---------+           +----------+
                      Y: |    Y    |        Y: |    X     |
                         +---------+           +----------+
                      X: |    X    |        X: |    L     |
                         +---------+           +----------+

                         +---------+           +----------+
                      L: |    L    |        L: |    L     |
                         +---------+           +----------+



                                                                       page 49


SYNTAX: 'LBL textstring' or 'LBL nn'
NOMENCLATURE: text label or numeric label
PURPOSE: two distinct kinds of labels are described.
  A text label is used as the first line in a program to name
  the program.  Other text label lines in a program may be
  used as comments.
  A numeric label is used to designate a branch step that
  would be the destination of a GTO or XEQ instruction.
RESTRICTION: A text label may contain up to 12 characters.
  A numeric label must be in the range 00-99.
SPECIFICATION: both kinds of labels execute similar to a NOP.
  Program execution simply falls through the label.
EXAMPLES:  'LBL MYPROGRM'
          'LBL LOOP1'
          'LBL 02'
          'LBL 25'
          'LBL STARTHERE'
          'LBL COMMENT'
          'LBL 10'




SYNTAX: 'LN'
NOMENCLATURE: natural logarithm.
PURPOSE: calculates the natural logarithm (base e=2.7182818) of
  a number.
RESTRICTION: X must be strictly positive.  X>0.
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |   LN(X)  |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    X     |
                   +---------+           +----------+


                                                                       page 50


SYNTAX: 'LOG'
NOMENCLATURE: common logarithm.
PURPOSE: calculates the common logarithm (base 10) of a number.
RESTRICTION: X must be strictly positive.  X>0.
SPECIFICATION:       before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |  LOG(X)  |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |    X     |
                   +---------+           +----------+




SYNTAX: 'Lccss?' or 'LccRnn?' or 'Lcc0?'
NOMENCLATURE: LASTX comparison
PURPOSE: this is a conditional comparison instruction which
  compares the L-register with any other register.  This is a
  conditional 1-step jump instruction.
RESTRICTION:  ss can only be one of X, Y, Z, T, but not L.
SPECIFICATION: The L-register is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'L<R02?'
         'L=X?'
         'L>=Z?'
         'L<=R25?'
         'L<>R98?'
         'L>T?'
         'L<0?'
         'L=0?'



                                                                       page 51


SYNTAX: 'NOP'
NOMENCLATURE: no operation
PURPOSE: performs no operation.  Sometimes used as a "filler"
  instruction or a dummy place holder.
SPECIFICATION: no effect on the stack registers.  This program
  line performs no operation.





SYNTAX: 'PI'
NOMENCLATURE: number pi (=3.1415926536)
PURPOSE: enters the constant 3.1415926536 into the stack.
SPECIFICATION: this is identical to the line which enters the
  numeric constant 3.1415926536.  There are two cases
  depending on the state of "Overwrite X".

                       before:               after:
                      +---------+           +--------------+
                   T: |    T    |        T: |      T       |
                      +---------+           +--------------+
                   Z: |    Z    |        Z: |      Z       |
                      +---------+           +--------------+
"Overwrite X" on    Y: |    Y    |        Y: |      Y       |
                      +---------+           +--------------+
                   X: |    X    |        X: | 3.1415926536 |
                      +---------+           +--------------+

                      +---------+           +--------------+
                   L: |    L    |        L: |      L       |
                      +---------+           +--------------+

               ---------------------------------------------

                      +---------+           +--------------+
                   T: |    T    |        T: |      Z       |
                      +---------+           +--------------+
                   Z: |    Z    |        Z: |      Y       |
                      +---------+           +--------------+
"Overwrite X" off   Y: |    Y    |        Y: |      X       |
                      +---------+           +--------------+
                   X: |    X    |        X: | 3.1415926536 |
                      +---------+           +--------------+

                      +---------+           +--------------+
                   L: |    L    |        L: |      L       |
                      +---------+           +--------------+



                                                                       page 52


SYNTAX: 'QR'
NOMENCLATURE: quotient-remainder
PURPOSE: this function is a simultaneous modulo and quotient
  function, useful for table/matrix element breakdown.
RESTRICTION: X must be nonzero.  X<>0.
SPECIFICATION: The quotient Q and remainder R are calculated
  from the X and Y stack values as follows:
        Q = INT(Y/X)
        R = Y - Q*X
  Although Y and X would normally both be positive integers
  the only restriction is that X be nonzero.
                     before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Q    |
                   +---------+           +---------+
                X: |    X    |        X: |    R    |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+



SYNTAX: 'RAD'
NOMENCLATURE: radians mode
PURPOSE: sets the angle mode to radians for all the standard
  trigonometric functions.
SPECIFICATION: no effect on stack contents.  The angle mode
  will show "Radians".



                                                                       page 53


SYNTAX: 'RCL rr' or  'RCL IND rr'
NOMENCLATURE: recall a register.
PURPOSE: places a copy of the specified register on the
  operational stack.
RESTRICTIONS: in the IND case the specified register must be in
  the range from R00-R99.
SPECIFICATION: there are two cases depending on the state of
  "Overwrite X".  If "Overwrite X" is on then the stack is
  altered only by the recalled number being deposited in X.
  If "Overwrite X" is off then the recalled number is still
  deposited in X but the Y, Z, and T registers will contain
  X, Y, and Z respectively.  (see the numeric constant entry
  on page 38.)
  'RCL rr' specifies the register designated directly by rr.
  'RCL IND rr' specifies the selected register number by
  taking the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a "NONEXISTENT" error message will
  result.
EXAMPLES:  'RCL 02'
          'RCL IND 16'
          'RCL IND T'
          'RCL 37'
          'RCL Z'




SYNTAX: 'RDN'
NOMENCLATURE: roll down (the stack)
PURPOSE: cyclically rotates the T, Z, and Y stack registers
  down and rotates the X-register up.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    X    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    T    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Z    |
                   +---------+           +---------+
                X: |    X    |        X: |    Y    |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    L    |
                   +---------+           +---------+



                                                                       page 54


SYNTAX: 'Rnnccss?' or 'RnnccRmm?' or 'Rnncc0?'
NOMENCLATURE: register nn comparison
PURPOSE: this is a conditional comparison instruction which
  compares register Rnn with any other register.  This is a
  conditional 1-step jump instruction.
SPECIFICATION: The register Rnn is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'R25<R02?'
         'R13=X?'
         'R45>=Z?'
         'R50<=R25?'
         'R01<>R98?'
         'R17>T?'
         'R10=0?'
         'R26>=0?'



SYNTAX: 'RTN'
NOMENCLATURE: return (from a subroutine)
PURPOSE: this function designates the normal conclusion of a
  subroutine (called by 'XEQ') by popping the subroutine
  return address off the subroutine return stack.
SPECIFICATION: no effect on the stack registers.  The
  subroutine return stack is a LIFO stack capable of holding
  up to 10 subroutine return addresses.  If the subroutine
  return stack is empty when a 'RTN' instruction is
  executed then the program will halt as if a 'STOP'
  instruction were encountered.  Otherwise the program pointer
  is changed to the first line following the last 'XEQ'
  instruction and program execution will continue with that
  line.




                                                                       page 55


SYNTAX: 'R^'
NOMENCLATURE: roll up (the stack)
PURPOSE: cyclically rotates the Z, Y, and X stack registers up
  rotates the T-register down.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    Z    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Y    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    X    |
                   +---------+           +---------+
                X: |    X    |        X: |    T    |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    L    |
                   +---------+           +---------+




SYNTAX: 'SF ff' or  'SF IND rr'
NOMENCLATURE: set flag
PURPOSE: sets a specified flag to 1.
RESTRICTION: the flag selected must be in the range from 0-9.
SPECIFICATION: no effect on stack contents.  Flags take on the
  values 0 and 1 only and when a flag is in state 0 we say it
  is clear.  When a flag is in state 1 we say it is set.
  'SF ff' sets the flag designated directly by ff.
  'SF IND rr' calculates the selected flag number by taking
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 0-9 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'SF 01'
          'SF 08'
          'SF IND 25'
          'SF IND Z'




                                                                       page 56


SYNTAX: 'SIGN'
NOMENCLATURE: sign
PURPOSE: this is a signum function which returns the sign of a
  number.
SPECIFICATION:               -1  if X<0
               SIGN(X)  =    0  if X=0
                            +1  if X>0

                     before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Y    |
                   +---------+           +---------+
                X: |    X    |        X: | SIGN(X) |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+




SYNTAX: 'SIN'
NOMENCLATURE: sine (trigonometric)
PURPOSE: computes the sine of an angle.
CAUTION: the angle is assumed to be in either degrees or
  radians, depending on the angle mode setting.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Y    |
                   +---------+           +---------+
                X: |    X    |        X: |  SIN(X) |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+



                                                                       page 57


SYNTAX: 'SQRT'
NOMENCLATURE: square root
PURPOSE: computes the square root of a number.
RESTRICTIONS: X cannot be negative.
SPECIFICATION:        before:               after:
                   +---------+           +----------+
                T: |    T    |        T: |    T     |
                   +---------+           +----------+
                Z: |    Z    |        Z: |    Z     |
                   +---------+           +----------+
                Y: |    Y    |        Y: |    Y     |
                   +---------+           +----------+
                X: |    X    |        X: |  SQRT(X) |
                   +---------+           +----------+

                   +---------+           +----------+
                L: |    L    |        L: |     X    |
                   +---------+           +----------+




SYNTAX: 'ST* rr'  or  'ST* IND rr'
NOMENCLATURE: store times a register
PURPOSE: multiplies the number in a specified register by the
  number in the X-register.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: no effect on the stack contents.  The only
  change is that the number in the selected register will be
  multiplied by the number in the X-register.  The number in
  the X-register remains in the X-register.
  'ST* rr' specifies the register designated directly by rr.
  'ST* IND rr' specifies the selected register by calculating
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'ST* 01'
          'ST* 25'
          'ST* IND 23'
          'ST* IND Z'
          'ST* Y'


                                                                       page 58


SYNTAX: 'ST+ rr'  or  'ST+ IND rr'
NOMENCLATURE: store plus a register
PURPOSE: adds the number in the X-register to the number in a
  specified register.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: no effect on the stack contents.  The only
  change is that the number in the selected register will be
  changed by adding the number in the X-register.  The number
  in the X-register remains in the X-register.
  'ST+ rr' specifies the register designated directly by rr.
  'ST+ IND rr' specifies the selected register by calculating
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'ST+ 01'
          'ST+ 25'
          'ST+ IND 23'
          'ST+ IND Z'
          'ST+ Y'




SYNTAX: 'ST- rr'  or  'ST- IND rr'
NOMENCLATURE: store minus a register
PURPOSE: subtracts the X-register number from the number in a
  specified register.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: no effect on the stack contents.  The only
  change is that the number in the selected register will be
  decremented by the number in the X-register.  The number in
  the X-register remains in the X-register.
  'ST- rr' specifies the register designated directly by rr.
  'ST- IND rr' specifies the selected register by calculating
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'ST- 01'
          'ST- 25'
          'ST- IND 23'
          'ST- IND Z'
          'ST- Y'


                                                                       page 59


SYNTAX: 'ST/ rr'  or  'ST/ IND rr'
NOMENCLATURE: store divide a register
PURPOSE: divides the number in a specified register by the
  number in the X-register.
RESTRICTION: X must be nonzero.  X<>0.  In the IND case the
  final designated register must be in the range 00-99.
SPECIFICATION: no effect on the stack contents.  The only
  change is that the number in the selected register will be
  divided by the number in the X-register.  The number in
  the X-register remains in the X-register.
  'ST/ rr' specifies the register designated directly by rr.
  'ST/ IND rr' specifies the selected register by calculating
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'ST/ 01'
          'ST/ 25'
          'ST/ IND 23'
          'ST/ IND Z'
          'ST/ Y'




SYNTAX: 'STO rr'  or  'STO IND rr'
NOMENCLATURE: store
PURPOSE: stores a copy of the X-register in a specified memory.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: no effect on the stack contents.  The number in
  the X-register is stored in the designated register.  The
  number in the X-register remains in the X-register.
  'STO rr' specifies the register designated directly by rr.
  'STO IND rr' specifies the selected register by calculating
  the integer part of the absolute value of the number
  contained in the register named by rr.  This selector must
  be in the range 00-99 or a 'NONEXISTENT' error message will
  result.
EXAMPLES:  'STO 02'
          'STO IND 16'
          'STO IND T'
          'STO 37'
          'STO Z'




                                                                       page 60


SYNTAX: 'STOP'
NOMENCLATURE: stop
PURPOSE: halts execution of a running program.
SPECIFICATION: no effect on stack contents.  When a running
  program executes this instruction the program will
  immediately halt and you will be returned to the Manual Mode
  where the program counter will show the line number of the
  'STOP' instruction.  This instruction has no use in Manual
  Mode since it is a Program Mode function.





SYNTAX: 'TAN'
NOMENCLATURE: tangent (trigonometric)
PURPOSE: computes the tangent of an angle.
CAUTION: the angle is assumed to be in either degrees or
  radians, depending on the angle mode setting.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Y    |
                   +---------+           +---------+
                X: |    X    |        X: |  TAN(X) |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+



                                                                       page 61


SYNTAX: 'Tccss?' or 'TccRnn?' or 'Tcc0?'
NOMENCLATURE: T-register comparison
PURPOSE: this is a conditional comparison instruction which
  compares the T-register with any other register.  This is a
  conditional 1-step jump instruction.
RESTRICTION:  ss can only be one of X, Y, Z, L, but not T.
SPECIFICATION: The T-register is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'T<R02?'
         'T=X?'
         'T>=Z?'
         'T<=R25?'
         'T<>R98?'
         'T>L?'
         'T=0?'




SYNTAX: 'X<>Y'
NOMENCLATURE: X exchange Y
PURPOSE: exchanges the contents of the X and Y registers.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    X    |
                   +---------+           +---------+
                X: |    X    |        X: |    Y    |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    L    |
                   +---------+           +---------+



                                                                       page 62


SYNTAX: 'X<> rr'  or  'X<> IND rr'
NOMENCLATURE: X exchange any register
PURPOSE: exchanges the content of the X-register with any other
  register.
RESTRICTION: in the IND case the final designated register must
  be in the range 00-99.
SPECIFICATION: the numbers in the X-register and the specified
  register will be exchanged.  Note that 'X<>Y' is a similar
  function but the syntax differs from 'X<> Y'.
  'X<> rr' specifies the register designated directly by rr.
  'X<> IND rr' specifies the selected register by taking the
  integer part of the absolute value of the number contained
  in the register named by rr.  This selector must be in the
  range 00-99 or a "NONEXISTENT" error message will result.
EXAMPLES: 'X<> T'
         'X<> 12'
         'X<> IND Z'
         'X<> IND 43'




SYNTAX: 'XEQ nn'  or  'XEQ IND rr'
NOMENCLATURE: execute (a subroutine)
PURPOSE: executes a subroutine.
CAUTION: there is a limit of 10 levels of subroutine returns.
  You can execute any number of subroutine calls, however,
  only the last 10 return addresses will be saved.
RESTRICTIONS: the specified label number must refer to an
  existing numeric label in the range 00-99.
SPECIFICATION: no effect on the stack content.  When an 'XEQ'
  statement is encountered a program branch will occur that is
  similar to a 'GTO' statement.  The next statement executed
  will be the first statement following the numeric label.
  Before that program branch occurs however, the line number
  of the next statement following the 'XEQ' statement is saved
  and displayed on the subroutine return stack.  Program
  execution will then continue normally until a 'RTN'
  instruction is encountered.  See also 'RTN'.  If the
  corresponding numeric label does not exist then a
  'NONEXISTENT' error message will result.
EXAMPLES: 'XEQ 02'
         'XEQ 26'
         'XEQ IND Z'
         'XEQ IND 42'



                                                                       page 63


SYNTAX: 'X^2'
NOMENCLATURE: X squared
PURPOSE: squares a number.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    Z    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Y    |
                   +---------+           +---------+
                X: |    X    |        X: |   X^2   |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+




SYNTAX: 'Xccss?' or 'XccRnn?'  or  'Xcc0?'
NOMENCLATURE: X-register comparison
PURPOSE: this is a conditional comparison instruction which
  compares the X-register with any other register.  This is a
  conditional 1-step jump instruction.
RESTRICTION:  ss can only be one of Y, Z, T, L, but not X.
SPECIFICATION: The X-register is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'X<R02?'
         'X=0?'
         'X=R00?'
         'X>=Z?'
         'X<=R25?'
         'X<>R98?'
         'X>L?'
         'X<=0?'
         'X<>0?'

                                                                       page 64


SYNTAX: Y^X
NOMENCLATURE: Y to the X (power)
PURPOSE: raise one number to the power of another
RESTRICTION: if X is an integer there is no restriction on Y.
  If X is not an integer Y must be positive.
SPECIFICATION:        before:               after:
                   +---------+           +---------+
                T: |    T    |        T: |    T    |
                   +---------+           +---------+
                Z: |    Z    |        Z: |    T    |
                   +---------+           +---------+
                Y: |    Y    |        Y: |    Z    |
                   +---------+           +---------+
                X: |    X    |        X: |   Y^X   |
                   +---------+           +---------+

                   +---------+           +---------+
                L: |    L    |        L: |    X    |
                   +---------+           +---------+




SYNTAX: 'Yccss?' or 'YccRnn?' or 'Ycc0?'
NOMENCLATURE: Y-register comparison
PURPOSE: this is a conditional comparison instruction which
  compares the Y-register with any other register.  This is a
  conditional 1-step jump instruction.
RESTRICTION:  ss can only be one of X, Z, T, L, but not Y.
SPECIFICATION: The Y-register is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'Y<R02?'
         'Y=X?'
         'Y>=Z?'
         'Y<=R25?'
         'Y<>R98?'
         'Y>L?'
         'Y>=0?'
         'Y<0?'


                                                                       page 65


SYNTAX: 'Zccss?' or 'ZccRnn?' or 'Zcc0?'
NOMENCLATURE: Z-register comparison
PURPOSE: this is a conditional comparison instruction which
  compares the Z-register with any other register.  This is a
  conditional 1-step jump instruction.
RESTRICTION:  ss can only be one of X, Y, T, L, but not Z.
SPECIFICATION: The Z-register is compared with an explicitly
  specified register or with 0 and if the condition is true
  then program execution continues normally with the next step
  following the comparison instruction.  If the condition is
  false the program skips the first instruction immediately
  following the comparison instruction and resumes execution
  with the second program line following the comparison
  instruction.
EXAMPLES: 'Z<R02?'
         'Z=X?'
         'Z>=T?'
         'Z<=R25?'
         'Z<>R98?'
         'Z>L?'
         'Z>=0?'
         'Z<0?'

                                                                       page 66

