Provided by: sc_7.16-3_amd64 bug

NAME

       sc - spreadsheet calculator

SYNOPSIS

       sc [-a] [-c] [-e] [-m] [-n] [-o] [-q] [-r] [-v] [-x] [-C] [-R] [-P range[/address] | /address] [-W range]
       [file...]

DESCRIPTION

       The spreadsheet calculator sc is based on rectangular tables much like  a  financial  spreadsheet.   When
       invoked,  it  first  looks  for a file in the user's home directory called .scrc and if found, reads that
       file into memory.  If that file contains the command ``set scrc'', sc looks for a file  called  .scrc  in
       the  current  directory, and if found, reads that file into memory, too.  Next, it reads the options from
       the command line, and finally, it reads in the file or files specified on the command line  and  presents
       the  data  in  a  table  organized as rows and columns of cells.  If invoked without a file argument, the
       table is initially empty, unless it is running in a pipeline, in which case it will read  its  data  from
       the  standard  input.  If more than one file is specified, all files except the first one will be merged.
       The default filename for saving a file with the Put command will be the same as the first file specified,
       and the other files will be treated as macros.  If you want to use advanced macros from the command line,
       the ``|'' must be quoted to prevent it from being expanded by the shell.

       Options begin with -.  However, an argument of a single - will be interpreted to  mean  that  spreadsheet
       data  will be taken from the standard input.  This is useful for including sc in a pipeline if the system
       supports pipes.  However, if standard input is not a terminal, the -  is  only  necessary  if  there  are
       multiple  files and standard input is not the last to be read, since standard input is automatically read
       in after all other files in such cases if it is not specified  explicitly,  or  if  there  are  no  other
       filenames  on  the  command  line.   If  sc  is  included  in  a pipeline, and a filename of ``-'' is not
       specified, the standard input will be merged in after all of the other named files have been processed.

       The first argument not beginning with a -, or a single - by itself, and any subsequent arguments will all
       be  interpreted  as  filenames  (a filename of - meaning standard input as noted above).  In addition, an
       argument of -- may be used to signify that all subsequent arguments should be treated as  filenames  even
       if they begin with a -, but unlike -, -- won't be treated as a filename itself.

       Each  cell  may  have  associated with it a numeric value, a label string, and/or an expression (formula)
       which evaluates to a numeric value or label string, often based on other cell values.

       For an online tutorial, type the command:

              sc /usr/share/doc/sc/tutorial.sc

       To print a quick reference card, type the command:

              scqref | [your_printer_commmand]

OPTIONS

       -a     Do not run the autorun macro, if one is specified in the file.

       -c     Start the program with the recalculation being done in column order.

       -e     Start the program with round-to-even (banker's rounding) enabled.

       -m     Start the program with automatic recalculation disabled.  The  spreadsheet  will  be  recalculated
              only when the ``@'' command is used.

       -n     Start the program in quick numeric entry mode (see below).

       -o     Start the program with automatic optimization of expressions enabled.

       -q     Quit  after  loading  all files, but before becoming interactive.  This is useful in shell scripts
              for getting information from a file, for example, or using  sc  as  a  non-interactive  calculator
              using the eval command.

       -r     Start the program with the recalculation being done in row order (default option).

       -v     When piping data out using the -P option (below), change all expressions to values.  The -v option
              must precede the -P option to have an effect.  If the -P option is used more than once, there must
              be a separate -v option for each instance of the -P option.

       -x     Cause the Get and Put commands (see below) to encrypt and decrypt data files.

       -C     Start the program with automatic newline action set to increment the column (see below).

       -P range[/address]
       -P /address
              Pipe a range to standard output.  The output is similar to that of the Put command (below), except
              that only cell data and formatting information for cells in the range are output, without  all  of
              the  colors,  range  definitions, column formatting, etc.  The optional /address is used to adjust
              all addresses in the range to a new starting point.  This is useful for copying data from one file
              to  another,  especially when used in conjunction with the -v option (above), using something like
              merge "|sc -v -Prange/address filename" (note the pipe symbol).  This option may be used more than
              once  to specify multiple ranges.  Note, however, that the -v option must precede the -P option on
              the command line, and there must be a separate -v option for each instance of the -P option.   Any
              instance of -P not preceded by its own -v option will output unevaluated expressions.

              A  range  of  ``%''  may be used to refer to the entire spreadsheet.  If the range is left out, as
              shown in the second form above, sc will be started interactively in navigate mode, allowing you to
              navigate  the spreadsheet and highlight the range you want to output.  Pressing ESC, ^G, or q will
              terminate without outputting any data.

       -R     Start the program with automatic newline action set to increment the row (see below).

       -W     Pipe a range to standard output.  The output is identical to that of the  Write  command  (below).
              This  option  may be used more than once to specify multiple ranges.  A range of ``%'' may be used
              to refer to the entire spreadsheet.

       All of these options can be changed with the ^T and S commands (see below) while sc is running.   Options
       specified when sc is invoked override options saved in the data file.

   Personal Initialization File
       When  sc  first starts, it looks for a file in the user's home directory called .scrc and if found, loads
       it into memory.  The format of this file is the same as any other sc file, but  should  be  reserved  for
       setting  certain  defaults.  Any options set which have equivalent command line options may be overridden
       by the command line.  If that file contains the command ``set scrc'', sc will then look for a file called
       .scrc  in  the current directory, and if found, load that file into memory, too (this is analogous to the
       ``set exrc'' command used by vi/ex).  These ``dotfiles'' may be created  by  any  text  editor.   Several
       commands exist specifically for setting default file name extensions in the .scrc file, although they may
       also be used from macros, ordinary spreadsheet files, or from within sc at the command line.   They  will
       not,  however, be saved along with the file.  The extensions should be quoted, and should not include the
       preceding `.' (e.g., scext "sc" will add the extension .sc ).  These commands are:

       scext  This is the default extension for normal sc files (those created with the Put command).   If  this
              command  is  not used, all sc files will be saved without an extension, and any existing extension
              will not be removed.  Setting this option causes all sc files  to  be  saved  with  the  specified
              extension  added, unless it is already present.  If the file name already has an extension of .sc,
              it will first be removed.  Any other extension will not be removed.

       ascext This is the default extension for plain text files created with the Write command.  The file  name
              will  first  be  checked  to  see  if  it  already has an extension of either .sc or the extension
              specified with scext above, and if either one exists, it will first be removed before  adding  the
              new extension.  If this option is not set, a default of .asc will be used.

       tbl0ext
              This  is  the  default  extension  for  files created with the Tbl command if tblstyle is set to 0
              (default).  The file name will first be checked to see if it already has an  extension  of  either
              .sc  or  the  extension  specified  with  scext  above, and if either one exists, it will first be
              removed before adding the new extension.  If this option is not set, a default  of  .cln  will  be
              used.

       tblext This  is  the  default extension for files created with the Tbl command if tblstyle is set to tbl.
              The file name will first be checked to see if it already has an extension of  either  .sc  or  the
              extension  specified  with  scext above, and if either one exists, it will first be removed before
              adding the new extension.  If this option is not set, a default of .tbl will be used.

       latexext
              This is the default extension for files created with the Tbl command if tblstyle is set to  latex.
              The  file  name  will  first be checked to see if it already has an extension of either .sc or the
              extension specified with scext above, and if either one exists, it will first  be  removed  before
              adding the new extension.  If this option is not set, a default of .lat will be used.

       slatexext
              This is the default extension for files created with the Tbl command if tblstyle is set to slatex.
              The file name will first be checked to see if it already has an extension of  either  .sc  or  the
              extension  specified  with  scext above, and if either one exists, it will first be removed before
              adding the new extension.  If this option is not set, a default of .stx will be used.

       texext This is the default extension for files created with the Tbl command if tblstyle is  set  to  tex.
              The  file  name  will  first be checked to see if it already has an extension of either .sc or the
              extension specified with scext above, and if either one exists, it will first  be  removed  before
              adding the new extension.  If this option is not set, a default of .tex will be used.

   General Information
       The  screen  is  divided  into  four  regions.  The top line is for entering commands and displaying cell
       values.  The second line is for messages from sc.  The third line and the first  four  columns  show  the
       column  and row numbers, from which are derived cell addresses, e.g.  A0 for the cell in column A, row 0.
       Note that column names are case-insensitive: you can enter A0 or a0.

       The rest of the screen forms a window looking at a portion of the table.  The  total  number  of  display
       rows and columns available, hence the number of table rows and columns displayed, is set by curses(3) and
       may be overridden by setting the LINES and COLUMNS environment variables, respectively.

       The screen has two cursors: a cell cursor, indicated by either a highlighted  cell  or  a  ``<''  on  the
       screen, and a character cursor, indicated by the terminal's hardware cursor.

       If  a  cell's  numeric  value is wider than the column width (see the f command), the cell is filled with
       asterisks.  If a cell's label string is wider than the column width, it is truncated at the start of  the
       next non-blank cell in the row, if any.

       Cursor control commands and row and column commands can be prefixed by a numeric argument which indicates
       how many times the command is to be executed.  You can type ^U before a repeat  count  if  quick  numeric
       entry mode is enabled.

   Changing Options

       ^To    Toggle options.  This command allows you to switch the state of one option selected by o.  A small
              menu lists the choices for o when you type ^T.  Unless otherwise noted, the options  selected  are
              saved  when  the  data  and  formulas are saved so that you will have the same setup next time you
              enter the spreadsheet.

              a      Automatic Recalculation.  When set, each  change  in  the  spreadsheet  causes  the  entire
                     spreadsheet  be  recalculated.   Normally  this  is  not  noticeable,  but  for  very large
                     spreadsheets, it may be faster  to  clear  automatic  recalculation  mode  and  update  the
                     spreadsheet via explicit ``@'' commands.  Default is automatic recalculation on.

              b      Braille  enhancement  mode.   See  the  braille  section  under the Set command below for a
                     complete description of how to use this mode.  This option is not saved when saving a file,
                     to allow blind and sighted users to easily share files.  It is intended for use in a user's
                     .scrc file.

              c      Current cell highlighting.   If  enabled,  the  current  cell  is  highlighted  (using  the
                     terminal's  standout mode, if available) and the cell pointer ``<'' is turned off.  This is
                     enabled by default.

              e      External function execution.  When disabled, external functions (see @ext() below) are  not
                     called.   This  saves a lot of time at each screen update.  External functions are disabled
                     by default.  If disabled, and external functions are used anywhere, a  warning  is  printed
                     each  time  the  screen is updated, and the result of @ext() is the value from the previous
                     call, if any, or a null string.

              i      Automatic insertion of rows/columns.  If this is enabled and craction is set  to  move  the
                     cell  cursor either down or to the right after entering data into a cell, and the last cell
                     in a row/column in the scrolling portion of a framed range was  just  filled,  causing  the
                     cell  cursor  to  move  outside  of  this  range,  a  new column/row will be inserted, thus
                     enlarging the range and allowing you to continue entering data into the row/column  without
                     overwriting  the  frame  (which  may contain expressions of some sort, such as totals).  If
                     autowrap is also enabled, it will take precedence,  and  a  new  row/column  will  only  be
                     inserted  after  entering data in the very last cell (bottom right corner) of the scrolling
                     range.  The default is no automatic insertion.

              w      Automatic wrap to next row/column.  If this is enabled and craction is set to move the cell
                     cursor  either down or to the right after entering data into a cell, and the last cell in a
                     row/column in the scrolling portion of a framed range was just  filled,  causing  the  cell
                     cursor  to  move  outside of this range, the cell cursor will move to the first cell in the
                     next row/column in this range.  If this would also take the cursor  out  of  the  scrolling
                     portion of the range, the cursor will remain in last edited cell instead, unless autoinsert
                     is also enabled, in which case a new row/column will be added so that the cursor can  wrap.
                     The default is no autowrap.

              l      Autolabeling.  If enabled, using the define command (rd) causes a label to be automatically
                     generated in the cell to the left of the defined cell.  This is only done if  the  cell  to
                     the left is empty.  Default is enabled.

              n      Quick  numeric  entry.   If  enabled, a typed digit is assumed to be the start of a numeric
                     value for the current cell, not a repeat count, unless preceded by ^U.  Also, the  `+'  and
                     `-'  keys  will  enter  insert mode and append a `+' or `-' to the existing contents of the
                     cell, allowing the user to easily add to or subtract from the current numeric  contents  of
                     the  cell.   The cursor controls (^P, ^N, or any of the arrow keys) in this mode will end a
                     numeric entry if the entry was started by pressing `+', `-', or a  digit.   Switching  from
                     insert  mode  to  edit  mode  will  cause  the  cursor  controls  to revert to their normal
                     functions.

              o      Automatic optimization of expressions.  If this is enabled, expressions which evaluate to a
                     constant are automatically optimized upon entry.  For example, if you enter @pow(2,32) into
                     a cell, the value 4294967296 will be stored in that cell, whereas if optimization is turned
                     off,  the  calculated  value will be displayed, but the actual expression will be stored in
                     the cell instead.  This allows you to edit the expression instead of  re-entering  it  from
                     scratch when you just want to make a minor change.  Default is automatic optimization off.

              t      Top  line  display.  If enabled, the name and value of the current cell is displayed on the
                     top line.  If there is an associated label string, the first character of the string  value
                     is  ``|''  for  a  centered  string, ``<'' for a leftstring or ``>'' for a rightstring (see
                     below), followed by "string" for a constant string or {expr} for a  string  expression.   A
                     constant  string may be preceeded with a backslash (`\').  In this case the constant string
                     will be used as a ``wheel'' to fill a column, e.g. "\-" for a line in a column, and "\Yeh "
                     for  "Yeh Yeh Ye".   If the cell has a numeric value, it follows as [value], which may be a
                     constant or expression.

              $      Dollar prescale.  If enabled, all numeric constants (not expressions) which you  enter  are
                     multipled  by  0.01 so you don't have to keep typing the decimal point if you enter lots of
                     dollar figures.

              r      Newline action.  This is a 3-way toggle which determines  which  direction  to  move  after
                     pressing the RETURN key to enter data into a cell.  It has the same effect as using the set
                     (S) command to set the value of  craction.   After  selecting  this  option,  you  will  be
                     prompted for the direction you want to move.  Valid directions are down (craction=1) and to
                     the right (craction=2).  Pressing j, ^N, or the cursor-down key will cause  the  cursor  to
                     move  down  a cell each time you press the RETURN key and pressing l, the cursor-right key,
                     or the space bar will cause the cursor to move one cell to the right.  Pressing the  RETURN
                     key at the prompt selects no action (craction=0, which means that the cursor will remain in
                     the current cell).  No action is the default unless sc is started with either the -R or  -C
                     option.   This  option  is  ignored if the cell into which data is being entered is not the
                     current cell.

              s      Enable/disable color slop.  If a cell's label string is wider than  the  column  width,  it
                     will  slop  over  into  the next cell to the right if that cell is empty.  However, if that
                     cell is in a different color  range  than  the  first,  this  slopover  will  be  disabled,
                     regardless of whether the colors assigned to the two ranges are different or not.  If cslop
                     is enabled, strings may slop over even if the next cell is  in  a  different  color  range,
                     carrying  their  color with them, which may cause a ragged boundary between the ranges, but
                     may allow the strings to be seen in their entirety.  Cslop is disabled by default.

              x      Encryption.  See the -x option.

              z      Set newline action limits.  This option sets limits to the  newline  action  option  above.
                     When  this  option is invoked, the row and column of the current cell are remembered.  If a
                     later newline action would take the current cell to the right  of  the  remembered  column,
                     then  the  current cell is instead moved to the first column of the next row.  If a newline
                     action would take the current cell below the remembered  row,  then  the  current  cell  is
                     instead moved to the top row of the next column.

              C      Color.   This option enables color, and must be set before any other color options, such as
                     colorneg (color negative numbers) or colorerr (color  cells  with  errors),  will  have  an
                     effect.  On a slow connection, turning off color can noticeably speed up screen updates.

              E      Color  cells  with errors.  Setting this option will cause all cells with expressions which
                     evaluate to ERROR or INVALID to be set to color 3.  Color must be enabled for  this  option
                     to take effect.

              N      Color  negative  numbers.   When  this option is set, all cells containing negative numbers
                     will have their color number incremented by one.  Cells with color 8  will  cycle  back  to
                     color 1.  Color must be enabled for this option to take effect.

              The  quick  numeric entry, newline action and set newline action limits options can be combined to
              allow very quick entry of large amounts of data.  If all the data to be entered is in a single row
              or  column  then setting the quick numeric entry and the appropriate newline action will allow the
              numbers to be entered without any explicit commands to  position  the  current  cell  or  enter  a
              number.

              If  the  data  entry  involves  several  entries in each row for many rows, then setting the quick
              numeric entry option, setting the newline action to move right after each entry  and  setting  the
              newline  action  limits  on the last column on which data should be entered will allow the data to
              entered quickly.  An alternative to setting newline action limits is  to  enclose  the  range  for
              entry in a frame (see "Framed Ranges" below), and setting the autowrap option.  Setting autoinsert
              will insert new rows as needed if the frame includes data at the bottom.   If  necessary,  columns
              which  do  not need data to be entered can be hidden with the z command.  Similar arrangements can
              be made for entering several rows of data in each column.

       S      Set options.  This command allows you to set various options.  A small menu lists the options that
              cannot be changed through ^T above.

              byrows/bycols
                     Specify  the  order  cell evaluation when updating.  These options also affect the order in
                     which cells are filled (see rf) and whether a row or column is cleared by an x command.

              iterations=n
                     Set the maximum number of recalculations before the screen is displayed again.   Iterations
                     is set to 10 by default.

              tblstyle=s
                     Control the output of the T command.  s can be: 0 (default) to give colon delimited fields,
                     with no tbl control lines; tbl to give colon delimited fields, with tbl(1)  control  lines;
                     latex  to  give  a  LaTeX tabular environment; slatex to give a SLaTeX (Scandinavian LaTeX)
                     tabular environment; tex  to  give  a  TeX  simple  tabbed  alignment  with  ampersands  as
                     delimiters; and frame to give a tblstyle output for FrameMaker.

              pagesize=n
                     Set the page size for the PageUp, PageDown, J, and K commands.  If set to 0, the default is
                     to move up or down half the number of rows displayed on the screen, or if the current  cell
                     is  in  a  framed  range, half the number of displayed rows in the scrolling region of that
                     range.

              Other Set options are normally used only in sc data files since they  are  available  through  ^T.
              You can also use them interactively.

              autocalc/!autocalc
                     Set/clear auto recalculation mode.

              autoinsert/!autoinsert
                     Set/clear automatic insertion mode.

              autowrap/!autowrap
                     Set/clear autowrap mode.

              optimize/!optimize
                     Set/clear auto optimize mode.

              numeric/!numeric
                     Set/clear numeric mode.

              prescale/!prescale
                     Set/clear numeric prescale mode.

              extfun/!extfun
                     Enable/disable external functions.

              toprow/!toprow
                     Set/clear top row display mode.

              rndtoeven/!rndtoeven
                     Default:  *.5 will be rounded up to the next integer; doing a 'set rndtoeven' will cause it
                     to be rounded to the closest even number instead (aka  banker's  rounding).   Round-to-even
                     has  advantages over the default rounding for some applications.  For example, if X+Y is an
                     integer, then X+Y = rnd(X)+rnd(Y) with round-to-even, but not always  with  the  defaulting
                     rounding  method.   This  could  be  an advantage, for example, when trying to split an odd
                     amount of money evenly between two people (it would determine who gets  the  extra  penny).
                     Note:  rndtoeven  only  effects  the  @rnd and @round functions.  It has no effect on how a
                     number is rounded to fit the display format of a cell.

              craction=n
                     Set the newline action.  n can be: 0 (default) to give no action; 1 to move down after each
                     entry; or 2 to move right after each entry.

              rowlimit=n
                     Set  the remembered limit for the maximum row below which the current cell will be moved to
                     the top of the next column if the newline action is set to move the current cell  down.   n
                     can be -1 (default) to disable this facility.

              collimit=n
                     Set the remembered limit for the maximum column to the right of which the current cell will
                     be moved to the left of the next row if the newline action is set to move the current  cell
                     right.  n can be -1 (default) to disable this facility.

              color/!color
                     Enable  color.   This  option  must be set for any other color options, such as colorneg or
                     colorerr, to take effect.  On a slow connection, turning off color can noticeably speed  up
                     screen updates.

              colorneg/!colorneg
                     Color  negative  numbers.   When  this option is set, all cells containing negative numbers
                     will have their color number increased by one.  Cells with color 8 will cycle back to color
                     1.  Color must be enabled for this option to take effect.

              colorerr/!colorerr
                     Color  cells  with errors.  Setting this option will cause all cells with expressions which
                     evaluate to ERROR or INVALID to be set to color 3.  Color must be enabled for  this  option
                     to take effect.

              cslop/!cslop
                     Enable  color  slop.  If a cell's label string is wider than the column width, it will slop
                     over into the next cell to the right if that cell is empty.  However, if that cell is in  a
                     different  color  range  than  the  first,  this  slop over will be disabled, regardless of
                     whether the colors assigned to the two ranges are different or not.  If cslop  is  enabled,
                     strings  may  slop over even if the next cell is in a different color range, carrying their
                     color with them, which may cause a ragged boundary between the ranges, but  may  allow  the
                     strings to be seen in their entirety.  Cslop is disabled by default.

              The  following Set options are considered personal preferences, or are terminal dependent, and are
              therefore not saved when saving a file, but are instead intended for use in a user's .scrc file.

              braille/!braille
                     Set/clear braille enhancement mode.  When braille  enhancement  mode  is  set,  the  cursor
                     behaves  in a manner that makes the use of sc much easier when using a braille display.  In
                     spite of its name, this mode also works well with screen readers such as SpeakUp,  and  can
                     even  be  used  by  sighted users to make cutting and pasting using the screen program much
                     easier.

                     There are actually two different braille modes.  When the braille  option  is  set,  the  C
                     command, which is normally used to set colors, will instead change from one braille mode to
                     the other.  If it is desired to set/change colors so you can share files  with  others  not
                     using  a  braille  display, braille mode will have to be switched off temporarily, and then
                     switched back on after the color operation is done.

                     When the braille option is set, the default braille  mode  will  cause  the  cursor  to  be
                     positioned  at  the  left  edge  of the current cell, while the alternate braille mode will
                     cause the cursor to be placed at  the  beginning  of  the  top  line,  which  will  contain
                     information  such  as the current cell address, contents of the cell, and column formatting
                     information.  The column names will also be moved to the  left  edge  of  their  respective
                     columns in order to remain aligned with the cursor as it moves up and down the column.

                     In  either mode, the cursor will be placed in the top line when editing a line, except when
                     switching to navigate mode, in which case the cursor will be placed in either  the  current
                     cell  (default  braille  mode)  or the second line, where the cell address or default range
                     will be displayed (alternate braille mode).

                     Whenever a message is displayed on the second line, such as an error message or prompt  for
                     further information, both modes will cause the cursor to be placed at the beginning of that
                     message.  After this message goes away, the cursor will revert to its former behavior.  The
                     easiest  way  to  make this message go away without effecting anything, except in the cases
                     where it is asking the user for more information, is to press CC, which effectively changes
                     modes twice, with a net effect of leaving sc in the original mode.

              locale/!locale
                     If  locale  support  is  compiled  into sc, this option will cause certain locale-dependent
                     behaviors, such as the display of numbers and the determination of word boundaries for some
                     operations  in  edit  mode.   Note  that if this option is set and the environment variable
                     LC_ALL is unrecognized, unset, or set to  either  ``POSIX''  or  ``C'',  commas  in  format
                     commands will be ignored.

              cellcur/!cellcur
                     Set/clear  current  cell  highlighting  mode.   This  option is included here because it is
                     likely to be terminal dependent and/or a user preference, and therefore is not  saved  when
                     saving a file.

              scrc   It  tells  sc to also read the file .scrc in the current directory when starting.  Settings
                     in this file will override those in $HOME/.scrc but may themselves be overridden by command
                     line  options.   Setting this could be a potential security risk, since starting sc with an
                     unknown .scrc could potentially execute arbitrary commands.  This  risk  is  probably  very
                     slight,  since  a  spreadsheet  program  is not likely to be run in just any directory, and
                     should never be run as root.

   Cursor Control Commands

       ^A     Go to cell A0 (same as HOME).

       ^P     Move the cell cursor up to the previous row.

       ^N     Move the cell cursor down to the next row.

       ^H     Move the cell cursor backward one column.

       SPACE  Move the cell cursor forward one column.  When in navigate mode, if a range is highlighted, insert
              the  highlighted  range  into  the  command line, followed by a space, while remaining in navigate
              mode.  This is useful when entering copy, move, or frame commands, for example, which accept  more
              than one range argument.

       h, j, k, l
              These  are  alternate,  vi-compatible cell cursor controls (left, down, up, right).  Space is just
              like l (right).

       H, J, K, L
              These move the cursor by half pages (left, down, up, right).   If  pagesize  is  nonzero,  up/down
              paging will be by pagesize rows, instead.

       ^F, ^B Same as J and K above.

       PAGE-DOWN PAGE-UP
              Same as J and K above.

       TAB    If  the  character  cursor is on the top line, TAB tries to complete a range name if the character
              immediately preceding it is alphanumeric or  ``_'',  and  starts  a  range  if  not  (see  below).
              Otherwise, move the cell cursor forward one column.

       HOME   Go to cell A0.

       END    Same as ^E (see below).

       Arrow Keys
              The  terminal's arrow keys provide another alternate set of cell cursor controls if they exist and
              are supported in the appropriate termcap entry.  Some terminals have  arrow  keys  which  conflict
              with  other  control  key codes.  For example, a terminal might send ^H when the back arrow key is
              pressed.  In these cases, the conflicting  arrow  key  performs  the  same  function  as  the  key
              combination it mimics.

       ^      Move the cell cursor up to row 0 of the current column.

       #      Move the cell cursor down to the last valid row of the current column.

       0      Move  the cell cursor backward to column A of the current row.  This command must be prefixed with
              ^U if quick numeric entry mode is enabled.

       $      Move the cell cursor forward to the last valid column of the current row.

       b      Scan the cursor backward (left and up) to the previous valid cell.

       w      Scan the cursor forward (right and down) to the next valid cell.

       g      Go to a cell.  sc prompts for a cell's name, a regular  expression  surrounded  by  quotes,  or  a
              number.   If  a cell's name such as ae122 or the name of a defined range is given, the cell cursor
              goes directly to that cell.  If a quoted regular expression such as  "  Tax  Table  "  or  "  ^Jan
              [0-9]*$  "  is  given, sc searches for a cell containing a string matching the regular expression.
              See regex(3) or ed(1) for more details on the form of regular expressions.

              You can also search formatted numbers or expressions using regular expressions  by  preceding  the
              opening  quotes  of  the  regular  expression with a ``#'' (for formatted numbers) or a ``%'' (for
              expressions).  These are handy for searching for dates within a specified  range  or  cells  which
              reference  a  given  cell,  for  example, although they are somewhat slower than searching through
              ordinary strings, since all numbers must be formatted or expressions decompiled on the fly  during
              the search.

              If  a  number  is  given,  sc  will search for a cell containing that number.  Searches for either
              strings or numbers proceed forward from the current cell, wrapping back to a0 at the  end  of  the
              table, and terminate at the current cell if the string or number is not found.  You may also go to
              a cell with an ERROR (divide by zero, etc. in this cell) or INVALID (references a cell  containing
              an ERROR).  g error will take you to the next ERROR, while g invalid take you to the next INVALID.
              The last g command is saved, and can be re-issued by entering g<return>.  You can also repeat  the
              last search by pressing n.

              An optional second argument is available whose meaning depends on whether you're doing a search or
              jumping to a specific cell.  When doing a search, the second argument specifies a range to search.
              When  jumping  to a specific cell, the second argument specifies which cell should be in the upper
              lefthand corner of the screen, if possible, which allows you  to  position  the  destination  cell
              where you want it on the screen.

       ^Ed    Go  to  end  of  range.   Follow  ^E by a direction indicator such as ^P or j.  If the cell cursor
              starts on a non-blank cell, it goes in the indicated direction until the last  non-blank  adjacent
              cell.   If  the  cell  cursor starts on a blank cell, it goes in the indicated direction until the
              first non-blank cell.  This command is useful  when  specifying  ranges  of  adjacent  cells  (see
              below), especially when the range is bigger than the visible window.

              If  ^E is pressed twice in succession, or if it is pressed after another ^E or a ^Y, it will cause
              the screen to scroll up without moving the cell cursor, unless the cell cursor is already  at  the
              top of the screen, in which case, it will remain at the top of the visible screen.

       ^Y     Causes the screen to scroll down without moving the cell cursor, unless the cell cursor is already
              at the bottom of the screen, in which case, it will remain at the bottom of the visible screen.

       mx     Mark the current cell.  sc will prompt for a lowercase letter to be  used  as  a  mark  specifier.
              Marked cells may be used as the source for the c (copy a marked cell) command, or as the target of
              a ` or ' (go to marked cell) command.  In addition to cells marked with lowercase letters, sc also
              automatically  marks  the  last  nine  cells  that  have been edited with the numbers 1-9, and the
              current cell being edited with the number 0.  When not editing a cell, marks 0 and 1 usually refer
              to  the  same  cell,  unless the last edit was begun in one cell, but the cell address was changed
              before pressing the RETURN key, or the last edit was aborted prematurely.

       `x     Jump to a previously marked cell.  If the target cell is currently on the screen, sc  will  simply
              jump  to the target cell, making it current.  Otherwise, sc will attempt to center the cell on the
              screen, if possible.  As a special case, following the ` with another ` will  return  you  to  the
              cell you were in before the last g, ', `, *, or ^E (or END key) was used to jump to another cell.

       'x     Jump to a previously marked cell.  ' works just like ` , except that ' will attempt to restore the
              marked cell to the same position on the screen as when it was marked.  It does this by remembering
              which  cell  was  in  the  upper  left hand corner of the screen at the time the mark was set, and
              restoring that cell to its original position.  As a special case, following the ' with  another  '
              will return you to the cell you were in before the last g, ', `, *, or ^E (or END key) was used to
              jump to another cell, and will also try to position that cell on the screen in the  same  position
              as when you left it.

       z<RETURN>
              Move  the current row to the top of the screen.  If the current row is in a framed range, move the
              current row to the top of the scrolling region.

       z.     Move the current row to the center of the screen.

       z|     Move the current column to the center of the screen.

       zc     Center the current cell both horizontally and vertically.

   Cell Entry and Editing Commands
       Cells can contain both a numeric value and a string  value.   Either  value  can  be  the  result  of  an
       expression,  but  not  both  at  once,  i.e.  each  cell can have only one expression associated with it.
       Entering a valid numeric expression alters the cell's previous numeric value, if any,  and  replaces  the
       cell's  previous  string  expression, if any, leaving only the previously computed constant label string.
       Likewise, entering a valid string expression alters the cell's the previous label  string,  if  any,  and
       replaces  the  cell's  previous numeric expression, if any, leaving only the previously computed constant
       numeric value.

       =      Enter a numeric constant or expression into the current cell.  sc prompts for  the  expression  on
              the top line.  The usual way to enter a number into a cell is to type ``='', then enter the number
              in response to the prompt on the top line.  The quick numeric entry option, enabled through the -n
              option  or  ^T  command, shows the prompt when you enter the first digit of a number (you can skip
              typing ``='').  If you want to begin entering an expression in the current cell, but you  want  to
              start  out  in navigate mode (e.g. to enter cell addresses, or sums of ranges using ``@sum''), use
              the ``+'' command instead (see below).

       <      Enter a label string into the current cell to be flushed left against the left edge of the cell.

       \      Enter a label string into the current cell to be centered in the column.

       >      Enter a label string into the current cell to be flushed right against the right edge of the cell.

       {      Left justify the string in the current cell.

       |      Center the string in the current cell.

       }      Right justify the string in the current cell.

       F      Enter a format string into the current cell.  This format string overrides the precision specified
              with  the  f  command unless & is present in the fractional part of the format string (see below).
              The format only applies to numeric values.   There  are  two  types  of  format  strings  allowed:
              standard  numeric  and  date.   (Note: these format strings may also be used with the f command to
              create user-defined format types.)  The following characters can  be  used  to  build  a  standard
              numeric format string:

              #      Digit placeholder.  If the number has fewer digits on either side of the decimal point than
                     there are `#' characters in the format, the extra `#' characters are ignored.   The  number
                     is  rounded  to  the  number of digit placeholders as there are to the right of the decimal
                     point.  If there are more digits in the number than there are  digit  placeholders  on  the
                     left side of the decimal point, then those digits are displayed.

              0      Digit  placeholder.  Same as for `#' except that the number is padded with zeroes on either
                     side of the decimal point.  The number of zeroes used  in  padding  is  determined  by  the
                     number of digit placeholders after the `0' for digits on the left side of the decimal point
                     and by the number of digit placeholders before the `0' for digits on the right side of  the
                     decimal point.

              .      Decimal  point.   Determines  how many digits are placed on the right and left sides of the
                     decimal point in the number.  If locale is set, the decimal point for  the  user's  current
                     locale  will be used when formatting a number.  Note that numbers smaller than 1 will begin
                     with a decimal point if the left side of the  decimal  point  contains  only  a  `#'  digit
                     placeholder.  Use a `0' placeholder to get a leading zero in decimal formats.

              %      Percentage.  For each `%' character in the format, the actual number gets multiplied by 100
                     (only for purposes of formatting -- the original number is left  unmodified)  and  the  `%'
                     character is placed in the same position as it is in the format.

              ,      Thousands  separator.   The presence of a `,' in the format (multiple commas are treated as
                     one) will cause the number to be formatted with a `,' separating each set of  three  digits
                     in  the  integer  part  of  the  number  with numbering beginning from the right end of the
                     integer.  If locale is set, the thousands separator for the user's current locale  will  be
                     used  in place of the comma.  If the environment variable LC_ALL is unset, unrecognized, or
                     is set to ``POSIX'' or ``C'',  any commas in the format string will be ignored.

              &      Precision.  When this character is present in the fractional part  of  the  number,  it  is
                     equivalent  to  a  number  of  0's  equal  to  the precision specified in the column format
                     command.  For example, if the precision is 3, `&' is equivalent to `000'.

              \      Quote.  This character causes the next character to be inserted into the  formatted  string
                     directly with no special interpretation.

              E- E+ e- e+
                     Scientific  format.  Causes the number to be formatted in scientific notation.  The case of
                     the `E' or `e' given is preserved.  If the format uses a `+', then the sign is always given
                     for  the  exponent  value.   If the format uses a `-', then the sign is only given when the
                     exponent value is negative.  Note that if there is no digit placeholder following  the  `+'
                     or  `-',  then  that part of the formatted number is left out.  In general, there should be
                     one or more digit placeholders after the `+' or `-'.

              ;      Format selector.  Use this character to separate the format into two distinct formats.  The
                     format  to  the  left  of  the  `;'  character  will be used if the number given is zero or
                     positive.  The format to the right of the `;' character is used  if  the  number  given  is
                     negative.

              Some  example  formats  are  integer  (``0''  or  ``#''),  fixed (``0.00''), percentage (``0%'' or
              ``0.00%''), scientific (``0.00E+00''), and currency (``$#,0.00;($#,0.00)'').

              Date format strings are identified by the presence of a ^D in the first  postition.   If  this  is
              present,  the remainder of the string is passed to the strftime() function, and therefore uses the
              same conversion specifiers as strftime().  For more information on conversion specifiers for  date
              format strings, see the man page for strftime(3).

       Strings  you  enter must start with ".  You can leave off the trailing " and sc will add it for you.  You
       can also enter a string expression by backspacing over the opening " in the prompt.

       e      Edit the value associated with the current cell.  This is  identical  to  ``=''  except  that  the
              command  line  starts out containing the old numeric value or expression associated with the cell.
              The editing in this mode is vi-like.

              ^H     Move back a character

              ^V, v  Enter navigate mode.  This mode allows you to navigate  the  spreadsheet  while  editing  a
                     command.   When  in  navigate mode, v will insert the numeric value of the current cell, if
                     any, into the command line, instead, while ^V will return to the previous  mode  (like  the
                     ESCAPE key).

              ^W     Insert  the  expression  attached  to  the current cell into the command line.  If there is
                     none, the result is ``?''.  This only works while in navigate mode.

              ^A     In navigate mode, go to cell A0.  When not in navigate mode, jump to the beginning  of  the
                     line instead.

              ^E     Jump to the end of the line.  Unlike ``$'' (below), this can also be used from insert mode.

              TAB    If  the  character  immediately preceding the cursor is alphanumeric or ``_'', TAB tries to
                     find a match in the list of range names, and if one is found, the name will be completed on
                     the command line.  If there are multiple matches, pressing TAB repeatedly without any other
                     intervening keys will cycle through all of the valid matches.  If the character immediately
                     preceding  the  cursor  is  not alphanumeric or ``_'', TAB defines a range of cells via the
                     cursor control commands or the arrow keys.   Pressing  TAB  automatically  switches  sc  to
                     navigate  mode  if  you  haven't  already  done  so  using the ^V command, and the range is
                     highlighted, starting at the cell where you typed TAB, and continuing through  the  current
                     cell.   Pressing  TAB  again  causes  the highlighted range to be inserted into the command
                     line, the highlighting to be turned off, and the previous mode to  be  restored.   This  is
                     most useful for defining ranges to functions such as @sum().  Pressing ``)'' acts just like
                     typing the TAB key the second time and adds the closing ``)''.  Note that when you  give  a
                     range command, if the first argument to the command is a range, you don't need to press the
                     first TAB to begin defining a range starting with the current cell.

              :      Synonym for TAB, when in navigate mode.

              ` '    In navigate mode, go to marked cell.

              *      In navigate mode, go to note linked to current cell.

              +      Forward through history (same as j)

              -      Backward through history (same as k)

              ESC    Done editing

              CR     Save.  When in navigate mode, insert the name of the current cell  (the  one  at  the  cell
                     cursor)  into  the  command  line.  This is useful when entering expressions which refer to
                     other cells in the table.

              $      Goto last column

              %      Goto matching parenthesis

              .      Insert current dot buffer.  When in navigate mode, this is a synonym for : or TAB.

              ;      Repeat the last f, F, t, or T command.

              ,      Repeat the last f, F, t, or T command, but in the reverse direction.

              ~      Change the case of the character under the cursor.

              /      Search backwards for a string in the history
                     ESC  edit the string you typed
                     CR   search
                     ^H   backspace

              ?      Search forward for a string in the history (see ``/'' above)

              0      Goto column 0

              B      Move back a word.  Like b, except words are space delimited only.

              C      Change to end of line (delete first, then enter insert mode)

              D      Delete to end of line

              F      Find the next char typed, moving backwards in the line

              G      Go to the end of history, i.e., to the line being currently entered

              I      Insert at column 0; ESC revert back to edit mode

              N      Repeat the last search in the opposite direction

              P      Insert the most recently deleted text before the cursor

              R      Replace mode; ESC revert back to edit mode

              T      Goto a char, moving backwards in the line

              W      Forward a word.  Like w, except words are space delimited only.

              X      Delete the char to the left

              a      Append after cursor; ESC revert back to edit mode

              b      Move back a word

              c      Change mode; ESC revert back to edit mode.  In navigate  mode,  insert  color  range  which
                     includes the current cell.

              d      Delete ...
                     0    delete to beginning of line
                     $    delete to end of line
                     b    back word
                     e    delete to end of word
                     f    forward (right)
                     h    back char
                     l    forward
                     t    delete forward up to a given char (next char typed)
                     w    delete next word forward

              e      Forward to next end-of-word

              f      Find  the  next  char typed.  In navigate mode, insert the outer frame range which includes
                     the current cell.

              g      In navigate mode, allows you to `goto' a cell or range, just like the regular goto command.
                     Ignored in edit, insert or replace modes.

              h      Move left a char

              i      Insert before cursor; ESC revert back to edit mode

              j      Forward through history (same as +)

              k      Backward through history (same as -)

              l      Move right a char

              n      Repeat the last search (find the next match)

              o      When  highlighting a range in navigate mode, move to the opposite corner of the highlighted
                     range.

              p      Insert the most recently deleted text after the cursor

              q      Stop editing

              r      Replace char.  In navigate mode, insert the inner frame range which  includes  the  current
                     cell.

              s      Delete current char and enter insert mode (stands for substitute)

              t      Goto a char

              u      Undo

              w      Forward a word

              x      Delete the current char (moving to the right)

              y      Copies to the delete buffer without deleting.  Use like d (above).

       E      Edit  the  string  associated  with the current cell.  This is identical to ``<'', ``\'', or ``>''
              except that the command line starts out containing the old string value or  expression  associated
              with the cell.  SEE e ABOVE.

       To enter and edit a cell's number part, use the ``='', ``+'', and e commands.  To enter and edit a cell's
       string part, use the ``<'', ``\'', ``>'', and E commands.  See the sections below on numeric  and  string
       expressions for more information.

       Note  that  the  descriptions of the ``+'' and ``-'' commands below may seem very confusing at first, but
       once they're understood, they can facilitate the rapid entry of expressions which add and subtract  large
       numbers  of  cells  and  sums  of  ranges  of  cells, so read them over carefully several times until you
       understand them.

       "      Specify a named buffer for the next yank/delete/pull command.  Buffers are  named  with  a  single
              character.   Buffers  ``a'' through ``z'' are general purpose buffers, buffers ``1'' through ``9''
              hold the last nine deletions, with buffer ``1'' being the most recent, and buffer ``0'' holds  the
              last cell or range yanked.  Buffer ``"'' is the default buffer, which holds the last cell or range
              that was deleted or yanked.

       x      Clear the current cell.  Deletes the  numeric  value,  label  string,  and/or  numeric  or  string
              expression.  You can prefix this command with a count of the number of cells on the current row to
              clear.  The current column is used if column recalculation order is set.  Cells cleared with  this
              command may be recalled with any of the pull commands (see below).

       mx     Mark  the  current  cell.   sc  will prompt for a lowercase letter to be used as a mark specifier.
              Marked cells may be used as the source for the copy command, or as the target of a ` or '  (go  to
              marked cell) command.

       cx     Copy  a  marked  cell  to  the current cell, adjusting row and column references in its numeric or
              string expression, if any.  sc will prompt for the name of the cell to be copied, which may  be  a
              lowercase letter specified previously with the m command, a digit 1-9 to reference one of the last
              nine edited cells (0 will reference the last cell in  which  an  edit  was  begun,  regardless  of
              whether  the  edit  was  completed  or  not), or ``.''  to reference the current cell, which, as a
              special case, is to be used as a source rather than a destination, and is  to  be  copied  into  a
              range  which  includes the current cell.  When ``.''  is specified, the current cell is set as the
              default source range for the range copy (rc) command, and then the copy command  is  entered  into
              the command line and sc switches to navigate mode.  Moving the cell cursor will then highlight the
              destination range.  After the desired range is highlighted, press RETURN to execute the copy.

       +      If not in numeric mode, add the current numeric argument (default 1) to the value of  the  current
              cell.   The  current  value of the cell must not be an expression.  In numeric mode, + switches to
              insert mode and appends a ``+'' to the current expression or value, if any, which makes it easy to
              add to existing data.

              In  navigate mode, + inserts the current cell address into the line, followed by another +, and sc
              remains in navigate mode, unless a range is highlighted.   If  a  range  is  highlighted  and  the
              character  immediately preceding the cursor is a ``+'' or ``-'', or the cursor is at the beginning
              of an empty ``let'' expression, the string ``@sum('' will be inserted, followed by the highlighted
              range,  followed by ``)+''.  If a range is highlighted and the character immediately preceding the
              cursor is not a ``+'' or ``-'', and the cursor is  not  at  the  beginning  of  an  empty  ``let''
              expression, the highlighted range will be inserted, followed by  ``)+''.

       -      If  not  in  numeric mode, subtract the current numeric argument (default 1) from the value of the
              current cell.  The current value of the cell must not  be  an  expression.   In  numeric  mode,  -
              switches  to  insert  mode  and  appends a ``-'' to the current expression or value, if any, which
              makes it easy to subtract from existing data.

              In navigate mode, - inserts the current cell address into the line, followed by another -, and  sc
              remains  in  navigate  mode,  unless  a  range  is highlighted.  If a range if highlighted and the
              character immediately preceding the cursor is a ``+'' or ``-'', or the cursor is at the  beginning
              of an empty ``let'' expression, the string ``@sum('' will be inserted, followed by the highlighted
              range, followed by ``)-''.  If a range is highlighted and the character immediately preceding  the
              cursor  is  not  a  ``+''  or  ``-'',  and  the cursor is not at the beginning of an empty ``let''
              expression, the highlighted range will be inserted, followed by  ``)-''.

       RETURN If you are not editing a cell (top line is empty), pressing RETURN will make sc enter insert mode.
              At this point you may type any valid command or press ESC once to edit.

   File Commands

       G      Get  a  new  database  from  a file.  If encryption is enabled, the file is decrypted before it is
              loaded into the spreadsheet.

       P      Put the current database into a file.  If encryption is enabled, the file is encrypted  before  it
              is saved.

       ZZ     Save  the current database into a file if it has been modified, and then quit.  This is like the P
              command followed by the q command, except that the  default  filename  will  be  used  instead  of
              prompting you for one, and the file will only be saved if it was modified.  If there is no default
              filename, an error message will be displayed, and no action taken.

       W      Write a listing of the current database into a file in a form that matches its appearance  on  the
              screen.  This differs from the Put command in that its files are intended to be reloaded with Get,
              while Write produces a file for people to look at.  Hidden rows or columns are not shown when  the
              data is printed.

       T      Write  a listing of the current database to a file, but include delimiters suitable for processing
              by the tbl, LaTeX, or TeX table processors.  The delimiters are controlled by the tblstyle option.
              See  Set  above.  The delimiters are a colon (:) for style 0 or tbl and an ampersand (&) for style
              latex or tex.

       With the Put, Write, and Table commands, the optional range argument writes a subset of  the  spreadsheet
       to the output file.

       With  the  Write  and  Table  commands,  if  you  try  to write to the last file used with the Get or Put
       commands, or the file specified on the command line when sc was invoked, you are asked  to  confirm  that
       the (potentially) dangerous operation is really what you want.

       The  three output commands, Put, Write, and Table, can pipe their (unencrypted only) output to a program.
       To use this feature, enter ``| program'' to the prompt asking for a filename.  For example,  to  redirect
       the output of the Write command to the printer, you might enter ``| lpr -p''.

       M      Merge  the database from the named file into the current database.  Values and expressions defined
              in the named file are read into the  current  spreadsheet  overwriting  the  existing  entries  at
              matching cell locations.

       R      Run  macros.   There  are  two  different kinds of macros that can be used with sc: simple macros,
              which are stored in plain text files, and advanced macros, which are executable files,  and  which
              can be written in the language of your choice.  Advanced macros are only available on systems that
              support pipes.

              Simple macros are interpreted by sc's internal parser, and use the same  commands  used  to  enter
              data  and  perform  other  operations (the single key commands are shortcuts which switch to input
              mode after first entering the beginning of the full command for you).  These  are  also  the  same
              commands found in sc files created with the Put command.  Since sc files are saved as ASCII files,
              it is possible to use them as primitive macro  definition  files.   The  Run  command  makes  this
              easier.  It's like the Merge command, but prints a saved path name as the start of the filename to
              merge in.  The string to use is set with the  Define  command.   To  write  macros,  you  must  be
              familiar with the file format written by the Put command.

              Advanced  macros  use  executable  files  that are started by sc as a child process with stdin and
              stdout redirected back to sc for bidirectional communication.  Special commands are available  for
              requesting  information  such as cell contents, formatting information, or the current location of
              the cell cursor.  Commands are written to stdout, and responses  are  read  from  stdin.   To  use
              advanced  macros,  the  filename  must  be preceded by a | (the pipe symbol), and the file must be
              executable.  If the pathname set with the Define command begins with a |, all files in  that  path
              will  be  executed  as  advanced macros.  It is also possible to include a filename as part of the
              path when using advanced macros, which allows you to put multiple macros in a single file, and use
              the  Run  command to add command line arguments or options to determine which macro should be run.
              Advanced macros are relatively new, and documentation is  still  incomplete.   This  feature  will
              probably be enhanced in future releases.

       A      Specify a macro to be automatically run whenever the current sheet is reloaded from a file.

       D      Define a path for the Run command to use (see above).

       All  file  operations  take  a  filename as the first argument to the prompt on the top line.  The prompt
       supplies a " to aid in typing in the filename.  The filename can also be obtained  from  a  cell's  label
       string  or string expression.  In this case, delete the leading " with the backspace key and enter a cell
       name such as a22 instead.  If the resulting  string  starts  with  ``|'',  the  rest  of  the  string  is
       interpreted as a UNIX command, as above.

   Row and Column Commands
       These  are  two-letter  commands  which  can be used on either rows or columns.  The exceptions are the f
       command, which only works on columns, and therefore doesn't require a second letter, and  the  p  command
       which,  in  addition  to  operating on rows or columns, has several other options for merging the data in
       directly, without opening up a new row or column.  There are also a few special cases where pressing  the
       same letter twice will affect only the current cell instead of a row or column (except for ZZ, which is a
       special case all its own).

       In all of the remaining cases, the second letter of the command will be  either  r  or  c,  depending  on
       whether  the operation should be performed on rows or columns, respectively (additional options for the p
       command and the double letter cases are listed below).  A small menu lists the  choices  for  the  second
       letter when you type the first letter of one of these commands.

       Alternatively,  you  may  define a range of rows or columns by moving the cell cursor, either a cell at a
       time, or by pages (roughly 1/2 screen, unless the pagesize option has been set), but this only works  for
       the d, y, and Z commands.  Vertical cursor movement will begin highlighting rows, and horizontal movement
       will highlight columns.  Pressing the RETURN key will then perform the chosen operation on the  specified
       rows/columns.

       Commands  which  copy  cells also modify the row and column references in affected cell expressions.  The
       references may be frozen by using the @fixed operator or using the $ character in the  reference  to  the
       cell  (see below).  Commands which create new rows or columns will include all newly created cells in the
       same ranges (named, framed, color, or those used in expressions) as their counterparts in the current row
       or column.  This can sometimes be a significant factor when deciding whether to use ir/ic or or/oc.

       ir, ic Insert a new row (column) by moving the row (column) containing the cell cursor, and all following
              rows (columns), down (right) one row (column).  The new row (column)  is  empty.   Inserting  rows
              while  the  cell cursor is in a framed range will only effect rows in that range, leaving all rows
              to the left and right untouched.

       or, oc Open a new row (column).  These commands work like the ir and ic commands, except that the new row
              (column) will be inserted after the current row (column) instead of before it.

       ar, ac Append  a new row (column) immediately following the current row (column).  It is initialized as a
              copy of the current one.  Appending rows while the cell cursor is in  a  framed  range  will  only
              effect rows in that range, leaving all rows to the left and right untouched.

       dr, dc, dd
              Delete  the  current  row  (column).   dd  deletes the current cell (i.e., it is a synonym for x).
              Deleting rows while the cell cursor is in a framed range will only  effect  rows  in  that  range,
              leaving all rows to the left and right untouched.

       yr, yc, yy
              Yank  a  copy of the current row (column) into the delete buffer without actually deleting it.  yy
              yanks the current cell (similar to x, but without actually deleting the  contents  of  the  cell).
              Yanking  rows  while  the  cell cursor is in a framed range will only copy the portion of each row
              contained in that range, while ignoring everything outside the range.

       pr, pc, pp, pm, px, pt, pC, p.
              Pull deleted rows/columns/cells back into the spreadsheet.  The last set of cells that was deleted
              or  yanked  is  put  back into the spreadsheet at the current location.  pr inserts enough rows to
              hold the data.  pc inserts enough columns to hold the data.  pp (paste) does not  insert  rows  or
              columns; it overwrites the cells beginning at the current cell cursor location.  pm (merge) merges
              the cells in at the current cell cursor location, but does not erase the destination  range  first
              like  pp.  The difference between pp and pm is similar to the difference between the Get and Merge
              commands.  pf (format) works like pm except that only cell formatting information  is  merged  in,
              leaving  the  actual data untouched.  This makes it easy to copy cell formats from one part of the
              spreadsheet to another, such as when expanding an existing spreadsheet file.  px (exchange) copies
              the  contents  of  the delete buffer into the range beginning at the current cell cursor location,
              while simultaneously copying the contents of this range back into the delete buffer, replacing its
              current  contents.   pt  (transpose)  overwrites  the  cells  beginning at the current cell cursor
              location like pp, but transposes rows for columns and vice versa.  pC (copy) works like pp, except
              that  all cell references are adjusted in the same way that they are for the copy command.  p.  is
              the same as pC, except that it switches to navigate mode and allows you to define the  destination
              range  to  be used.  This works like the copy command in that if the source range (the contents of
              the delete buffer) is a single row, column, or cell, multiple copies may be made.

       vr, vc, vv
              Remove expressions from the affected rows (columns), leaving only the values  which  were  in  the
              cells  before  the command was executed.  When used in a framed range, vr only affects the portion
              of the the row inside the range, leaving the rest of the  row  unchanged.   vv  only  affects  the
              contents of the current cell.

       Zr, Zc, ZZ
              Hide (``zap'') the current row (column).  This keeps a row (column) from being displayed but keeps
              it in the data base.  The status of the rows and columns is saved with the  data  base  so  hidden
              rows and columns will still be hidden when you reload the spreadsheet.  Hidden rows or columns are
              not printed by the W command.  The ZZ command is a special  case.   It  does  not  hide  anything.
              Instead,  the  file  will  be  saved,  if  modified,  and  sc will exit.  See ZZ above, under File
              Commands.

       sr, sc Show hidden rows (columns).  Enter a range of rows (columns) to be revealed.  The default  is  the
              first range of rows (columns) currently hidden.  This command ignores the repeat count, if any.

       f      Set  the  output  format  to  be  used for printing the numeric values in each cell in the current
              column.  This command has only a column version (no second letter).  You  may  change  the  column
              width  by  pressing the h, <, or cursor left key to reduce it, or the l, >, or cursor right key to
              increase it.  Likewise, you may change the precision (the  number  of  digits  to  follow  decimal
              points)  by  pressing  the j, -, or cursor down key to reduce it, or the k, +, or cursor up key to
              increase it.  You may also change the format type for the column by pressing any digit.  If the  f
              command is preceded by a numeric argument, that argument will determine how many columns should be
              changed, beginning with the current column, and in the case of incrementing  or  decrementing  the
              width  or  precision  of  the  columns, each column will be incremented or decremented separately,
              regardless of its initial values.  Several formatting operations may be performed in sequence.  To
              leave the formatting command, simply press ESC, ^G, q, or RETURN .

              Alternatively,  you  may press SPACE to get the format command in the top line and enter all three
              values directly.  In order, these are: the total width in characters of the column, the precision,
              and  the  format  type.   Format  types  are  0  for fixed point, 1 for scientific notation, 2 for
              engineering notation, 3 for dates with a two digit year, and 4 for dates with a four  digit  year.
              Values  are  rounded off to the least significant digit displayed.  The total column width affects
              displays of strings as well as numbers.  A preceding count can be used to  affect  more  than  one
              column.

              You can also create your own format types by pressing = after the f command, followed by any digit
              (see the F command above under Cell Entry and Editing Commands for a description of how to build a
              format  string).   Format  numbers  0  through  4  will supersede the built-in format types, while
              numbers 5 through 9 will supplement them.  User defined format types may be used in the  same  way
              as the built-in types.  For example, the command

                     format 5 = "#,0.& ;(#,0.&)"

              will  define  a  currency  format  which  may  then be assigned to column C, for example, with the
              command

                     format C 10 2 5

       @myrow, @mycol
              Are functions that return the row or column of  the  current  cell  respectively.   ex:  The  cell
              directly above a cell in the D column could then be accessed by @nval("d",@myrow-1).  NOTE: @myrow
              and @mycol can't be used in specifying ranges.

       @lastrow, @lastcol
              These return the last row and column of the spreadsheet, respectively.  They are useful for macros
              designed to default to the whole spreadsheet.

   Range Commands
       Range  operations  affect  a  rectangular  region on the screen defined by the upper left and lower right
       cells in the region.  All of the commands in this class begin  with  ``r'';  the  second  letter  of  the
       command  indicates  which  command.   A  small menu lists the choices for the second letter when you type
       ``r''.  sc prompts for needed parameters for each command.  Phrases surrounded by square brackets in  the
       prompt are informational only and may be erased with the backspace key.

       Prompts requesting variable names may be satisfied with either an explicit variable name, such as A10, or
       with a variable name previously defined in a rd command (see below).  Range name prompts  require  either
       an explicit range such as A10:B20, or a range name previously defined with a rd command.  A default range
       shown in the second line is used if you omit the range from the command or press the TAB key (see below).
       The  default  range  can  be changed by moving the cell cursor via the control commands (^P or ^N) or the
       arrow keys.  The cells in the default range are highlighted  (using  the  terminal's  standout  mode,  if
       available).

       rx     Clear  a  range.   Cells  cleared with this command will be saved in the delete buffer, and may be
              recalled with any of the pull commands.

       ry     Yank a range.  Like rx, cells yanked with this command will be saved in the delete buffer, and may
              be  recalled  with  any  of the pull commands.  This command differs from rx, however, in that the
              original cells will not be cleared.  Although this command may be used to copy a range  of  cells,
              it treats all references as fixed.  Use rc if you want references to be relative to the cell which
              contains them unless specified otherwise, either with the @fixed operator or using the $ character
              in the reference to the cell.

       rc     Copy  a  source  range to a destination range.  The source and destination may be different sizes.
              The result is always one or more full copies of the source.  Copying a row to a row yields a  row.
              Copying  a  column  to  a  column  yields  a  column.  Copying a range to anything yields a range.
              Copying a row to a column or a column to a row yields a range with as many copies of the source as
              there  are  cells  in  the  destination.   This command can be used to duplicate a cell through an
              arbitrary range by making the source a single cell range such as b20:b20.

              If the source range is omitted (second argument), the source range from the last copy command will
              be  used,  unless  a  range  is currently highlighted, in which case the highlighted range will be
              copied instead.  If both the source range and destination range are omitted, the current cell will
              be used as the destination, unless a range is currently highlighted, in which case the highlighted
              range will serve as the destination, and the source range from  the  last  copy  command  will  be
              copied into that destination.

       rm     Move  a  source  range  to  a  destination  range.  This differs from deleting a range with rx and
              pulling it back in with pm in that any expressions that reference a cell in the range to be  moved
              will reference the cell at its new address after the move.  Unlike the rc command, the destination
              of a move is a single cell, which will be the upper lefthand corner of the source range after  the
              move.

       rv     Values  only.  This command removes the expressions from a range of cells, leaving just the values
              of the expressions.

       rs     Sort a range.  The rows in the specified range will be sorted according to criteria given  in  the
              form  of  a  string  of characters.  This string, enclosed in double quotes, may comprise a single
              criterion or multiple criteria in decreasing order of precedence.  Each criterion has three parts,
              all  of  which  are mandatory.  The first part is a single character, which must be either + or -,
              which specifies whether the sort should be done in ascending or  descending  order,  respectively.
              The  second  part, which is also a single character, must be either # or $, and is used to specify
              whether the sort should be based on the numeric portion or the string  portion,  respectively,  of
              the  cells being used for the comparison.  The third part may be either one or two characters, and
              must be alphabetic (case insensitive), and specifies  the  column  to  be  used  when  making  the
              comparisons.   This  column  must  be  in  the  range being sorted.  Any number of criteria may be
              concatenated, and will be used in the order specified.  If no criteria are specified, the  default
              behavior  is  to  sort  in ascending order, first by string and then by number, using the leftmost
              column of the range being sorted.  This is equivalent to specifying the  sort  criteria  to  be  "
              +$a+#a  ",  where  both  a's  are  replaced  by the name of the leftmost column of the range being
              sorted.

       rf     Fill a range with constant values starting with a given value and increasing by a given increment.
              Each  row  is  filled  before moving on to the next row if row order recalculation is set.  Column
              order fills each column in the range before moving on to the next column.  The start and increment
              numbers  may be positive or negative.  To fill all cells with the same value, give an increment of
              zero.

       r{     Left justify all strings in the specified range.

       r}     Right justify all strings in the specified range.

       r|     Center all strings in the specified range.

       rd     Use this command to assign a symbolic name to a single cell or a rectangular range of cells on the
              screen.   The parameters are the name, surrounded by "", and either a single cell name such as A10
              or a range such as a1:b20.  Names defined in this fashion  are  used  by  the  program  in  future
              prompts, may be entered in response to prompts requesting a cell or range name, and are saved when
              the spreadsheet is saved  with  the  Put  command.   Names  defined  may  be  any  combination  of
              alphanumeric  characters  and `_' as long as the name isn't a valid cell address.  Thus, x, H2SO4,
              and 3rdDay are all valid names, but H2 is not.

       rl     Use this command to lock the current cell or a range of cells, i.e. make them immune to  any  type
              of editing.  A locked cell can't be changed in any way until it is unlocked.

       rU     This  command  is  the  opposite  of  the  rl  command and thus unlocks a locked cell and makes it
              editable.

       rS     This command shows  lists  of  the  currently  defined  range  names,  framed  ranges,  and  color
              definitions  and  ranges,  one after the other.  The output of this command will be piped to less.
              If the environment variable PAGER is set, its value is used in place of less.

       ru     Use this command to undefine a previously defined range name.

       rF     Use this command to assign a value format string (see the ``F'' cell entry command) to a range  of
              cells.

       rr     This  command is used for creating, modifying, and deleting framed ranges.  A framed range, is one
              which has a number of rows or columns specified at the top, bottom, left, and/or right (the frame)
              which must remain onscreen whenever the cell cursor is within that range.  In other words, a frame
              consists of an outer range and an inner range, where the inner range is allowed to  scroll  within
              the  outer  range.   Once  a frame is defined, the inner range may be resized, but the outer range
              remains fixed unless rows or columns are added or deleted within the range.

              When this command is invoked, you will be prompted for the type of frame-related action you  would
              like to perform.  You may select an option from the list by typing its first letter.

              The  options  are top, bottom, left, right, all, and unframe.  If you choose top, bottom, left, or
              right, you will be prompted for a range and number of rows/columns.  The range may be  omitted  if
              the  cell  cursor  is in a previously defined framed range, in which case that range's outer range
              will be used  instead.   The  number  of  rows/columns  will  set  or  adjust  the  width  of  the
              corresponding  side  of  the  frame.   If  all  of these widths are set to zero, the frame will be
              undefined (same as the unframe command).

              If you choose all, you will be prompted for an outer range and an inner range, in which  case  the
              inner  range  will  scroll  within  the  outer range, and any rows or columns outside of the inner
              range, but inside the outer range will be part of the ``frame'' that is to remain  onscreen.   The
              outer  range  may  be omitted if the cell cursor is in a previously defined framed range, in which
              case the previously defined outer range will be used.  However, if a single range is specified  on
              the  command  line,  while  another  range  wholly contained within this range is highlighted, the
              specified range will be used as the outer range, and the highlighted range will  be  used  as  the
              inner  range.   If  no range is specified on the command line, but a range is highlighted, and the
              highlighted range is wholly contained within a previously defined framed  range,  the  highlighted
              range  will be used as the inner range, and the previously defined outer range will be used as the
              outer range.

              If you choose unframe, you will be prompted for a range, and if the range is found in the list  of
              frames,  the  frame will be deleted, and the framing will no longer be active (the specified range
              must be the outer range of the previously defined frame to be deleted).  The range may be  omitted
              if  the cell cursor is in a previously defined framed range, in which case that range will be used
              by default.

              Framed ranges may not be nested or overlapping.  If you try to define a range  that  contains  any
              cells  in  common with a previously defined framed range, an error message will be issued, and the
              frame will not be created.

       rC     This command defines a color range, and specifies a foreground/background pair to be used for that
              range.  See "Color Commands" below for more information.

   Note Commands
       A  note is a cell or range of cells that can be jumped to quickly from another cell by creating a special
       link in that cell.  The note may contain text explaining the contents of the cell  containing  the  link,
       similar to a footnote, or it may simply be another part of the spreadsheet that is related to the cell in
       some way.  When you press the `n' key, you will get a short prompt asking you whether you want to add  or
       delete a note, or to ``show'' (by highlighting) which cells on the screen have attached notes.

       If  a  cell  with an attached note contains numeric data, it will be preceded with an ``*''.  If color is
       available and turned on, the ``*'' will be displayed with color  4.   Also,  the  note  address  will  be
       displayed  in  curly  braces  on  the  top  line,  preceded  by  an ``*'', when the cell is current (e.g.
       {*AC30:AE43} or {*note1} for a named range).  You may also use the *s (Note/Show)  command  to  highlight
       all cells on the current screen with attached notes.

       *a     Add  a  note.   This  will  bring  up  the addnote command in the top line, followed by the target
              address of the cell where you want the note added.  You must then enter the cell  or  range  where
              the  note  resides  to  add  the  note.   If  you  omit  the  note address or range, the currently
              highlighted range, if any, will be used.  Otherwise, the current cell will be used (you would,  of
              course,  want  to  move  away from the cell in which the addnote command was invoked in the latter
              case).

       *d     Delete a note.  If there is a note attached  to  the  current  cell,  the  link  will  be  removed
              (deleted).   The note itself will not be removed from the spreadsheet.  If it is no longer needed,
              it must be deleted in a separate step.

       *s     Show all notes on the current screen.  If there are any  cells  on  the  visible  portion  of  the
              spreadsheet  which  contain attached notes, they will be highlighted until the next screen change,
              no matter how minor.  Simply moving to a new cell will be enough to turn off the highlighting.

       **     Jump to a note.  If there is a note  attached  to  the  current  cell,  you  will  be  immediately
              transported to that cell.  You may return from the note to where you were by pressing ` twice.

   Color Commands
       Color  may  be enabled by setting the color option (``set color''), or by toggling it with ^TC (control-T
       followed by an uppercase C).  If color is  enabled,  you  may  define  up  to  eight  color  pairs,  each
       consisting  of  a  foreground  color  and  a background color.  Each of these colors may be defined by an
       expression which is evaluated at the  same  time  the  rest  of  the  spreadsheet  is  evaluated.   Color
       expressions  may  be  simple,  specifying  only a foreground color and a background color, or they may be
       arbitrarily complex, causing the colors to change based upon other data in the spreadsheet, for  example.
       Color  ranges  may  then be defined using the rC command, with a color number (1-8) assigned to the range
       (see below).

       Some of the color numbers may have special meaning under certain circumstances,  but  may  also  be  used
       explicitly  at  the same time.  For example, color 1 is the default color pair if color is enabled but no
       color has been defined for a given cell.  It is also the color used for the column and row labels and the
       top two lines of the display, which are used for prompts, input, error messages, etc.  Color 2, while not
       explicitly used for all negative numbers, will be used for negative numbers in cells which have no  other
       color  defined when colorneg is turned on (``set colorneg'' or ^TN).  This is because colorneg causes all
       cells with negative numbers to have their color number incremented by one (cycling back to color 1 if the
       cell  is  defined  as  using  color 8).  Color 3 is used for all cells with errors (ERROR or INVALID), if
       colorerr is set (``set colorerr'' or ^TE), regardless of which color they have been defined  to  use,  or
       whether  they  have  been  defined to use any color at all.  Color 4 is used to highlight the ``*'' which
       signifies that a cell has a note attached.

       If two color ranges are nested or overlapping, any cell that is common to both will  be  displayed  using
       the  color of the most recently defined color range.  You can list all color definitions and color ranges
       with the rS (show) command (see below).

       C      This command first prompts you for the color number you would like to define (or redefine).  After
              selecting  a number (1-8), you may enter an expression which defines the foreground and background
              colors.  If the chosen color has previously been defined, the old definition will be presented for
              editing.  The syntax of the color command is:

                     color number = expression

              where number is the number of the color pair you want to define, and expression is the definition.
              If the expression is missing, the specified color number will be unset  (it  will  revert  to  its
              default start-up colors).  Unlike setting it explicitly to its original value, this will not cause
              the expression to be written to the file when saved.  See below for an explanation of  the  format
              of a color expression.

       rC     This command defines a color range, and specifies a foreground/background pair to be used for that
              range.  Although this command also uses the color command, the syntax is different from that  used
              for defining a color pair.  This syntax is:

                     color range number

       rS     This  command  shows  lists  of  the  currently  defined  range  names,  framed  ranges, and color
              definitions and ranges, one after the other.  The output of this command will be  piped  to  less.
              If the environment variable PAGER is set, its value is used in place of less.

       Color expressions are exactly like any other numeric expression, and may contain any function or operator
       that is  valid  in  any  other  numeric  expression.   There  are,  however  special  functions  designed
       specifically for defining colors.  These functions are:

               @black
               @red
               @green
               @yellow
               @blue
               @magenta
               @cyan
               @white

       Although  these  function names are intended to reflect the color they produce, and use the same names as
       the curses colors, @yellow may appear as brown on many  displays,  especially  those  based  on  the  VGA
       standard.

       In  addition  to  special functions for specifying colors, there is also a special operator for combining
       two such colors into a single number which specifies both a foreground  and  a  background  color.   This
       operator is the semicolon (;).  For example, the command

              color 1 = @white;@green

       will  set  the foreground color to white and the background color to green for any cell or range of cells
       defined to use color 1, or which have no color defined.  If the semicolon operator is not used, and  only
       one  color  is  specified, that color will be used for the foreground, and the background will default to
       black.

       Although the above example is the easiest way to specify  foreground  and  background  colors,  and  will
       probably  meet most people's needs, sc allows much more power and flexibility, should the need arise, due
       to the fact that any color can be specified by an expression.  For example,

              color 5 = B23<E75?(@black;@cyan):(@white;@magenta)

       will cause all cells defined with color 5 to be displayed as black text  on  a  cyan  background  if  the
       numeric  value  in cell B23 is less than the numeric value in cell E75; otherwise, they will be displayed
       as white text on a magenta background.  If you prefer  to  have  the  foreground  and  background  colors
       dependent on different criteria, you could do something like this:

              color 5 = (B23<E75?@white:@cyan);(D5%2?@red:@blue)

       This will cause the text color for color 5 to be either white or cyan, depending on the numeric values in
       cells B23 and E75, as in the previous example, and the  background  color  to  be  either  red  or  blue,
       depending on whether the numeric value in cell D5 is odd or even.

       Note  that  although  a  color  expression  may  contain any function which is valid in any other numeric
       expression, the @myrow and @mycol functions  will  always  evaluate  to  0.   This  is  because  a  color
       expression is not tied to any particular cell, but is instead evaluated once, and the result used for all
       cells defined to use that color.

       Also note that if a color expression results in an error, the color will default to black text on a black
       background.  If color 1 results in an error, color will be disabled so that you can see the input line to
       correct the error, after which color will need to be reenabled manually.

       Default colors are in effect for all colors  until  defined  otherwise.   These  default  colors  are  as
       follows:

               color 1 = @white;@blue
               color 2 = @red;@blue
               color 3 = @white;@red
               color 4 = @black;@yellow
               color 5 = @black;@cyan
               color 6 = @red;@cyan
               color 7 = @white;@black
               color 8 = @red;@black

   Miscellaneous Commands

       Q
       q
       ^C     Exit  from  sc.  If you made any changes since the last Get or Put, sc asks about saving your data
              before exiting.

       ^G
       ESC    Abort entry of the current command.

       ?      Enter an interactive help facility.  Lets you look up brief summaries of the main features of  the
              program.   The  help  facility  is  structured  like  this  manual page so it is easy to find more
              information on a particular topic, although it may not be completely up-to-date.

       !      Shell escape.  sc prompts for a shell command to run.  End the command line with the  RETURN  key.
              If the environment variable SHELL is defined, that shell is run.  If not, /bin/sh is used.  Giving
              a null command line starts the shell in interactive mode.  A second  ``!''  repeats  the  previous
              command.

       ~      Abbreviations.  You may set abbreviations to speed up the entry of repetitive data.  Abbreviations
              work much like  abbreviations  in  vi,  except  that  when  defining  an  abbreviation,  both  the
              abbreviation  and  the expanded text must be contained within quotes, separated by a single space.
              If more than one space separates the abbreviation from the expanded text, it will be  included  as
              part of the expanded text.

              There are three types of abbreviations available in sc.  In the first type, all characters must be
              either alphanumeric or ``_''.  In the second type, the last  character  must  be  alphanumeric  or
              ``_'',  but  all  other  characters  must  not be alphanumeric or ``_''.  Neither type may contain
              spaces.  The third type of abbreviation is a single character, and must be alphanumeric or ``_''.

              When using abbreviations, the first type must be at the beginning of the line, or must be preceded
              by  any character which is not alphanumeric or ``_''.  The second type must be at the beginning of
              the line, or must be preceded either by an alphanumeric character,  ``_'',  or  a  space.   Single
              character abbreviations must be at the beginning of the line or preceded by a space.

              Abbreviations will be automatically expanded as soon as the space bar or return key is pressed, or
              when pressing the ESC key at the end of the abbreviation to switch to edit  mode.   You  can  also
              force  an  abbreviation to be expanded by following it with a ^], which won't be inserted into the
              line.  If you don't want an abbreviation to be expanded, you must either press ^V twice or  switch
              to  edit  mode  and  back  again somewhere within the abbreviation (pressing ^V twice also has the
              effect of switching to navigate mode and back again).

              If the string in the abbreviation command contains no spaces, the entire string will be looked  up
              in  the  list  of abbreviations, and if found, the definition will be displayed in the form of the
              original abbreviation command used to define it.  When looking up an abbreviation in this  manner,
              be  sure to disable abbreviation expansion, as described above, or the results may not be what you
              expect.

              If the string is empty, a list of all abbreviations and their corresponding expanded text will  be
              output to your pager.  Note that abbreviations are not saved with the file.  This allows each user
              to create his own file of abbreviations and either merge them in or include them in his own  .scrc
              file, rather than force all users who access a file to use the same list of abbreviations.

       ^L     Redraw the screen.

       ^R     Redraw  the screen with special highlighting of cells to be filled in.  This is useful for finding
              values you need to provide or update in a form with which you aren't familiar or of which you have
              forgotten the details.

              It's  also  useful for checking a form you are creating.  All cells which contain constant numeric
              values (not the result of a numeric expression) are highlighted temporarily, until the next screen
              change,  however  minor.   To avoid ambiguity, the current range (if any) and current cell are not
              highlighted.

       ^X     This command is similar to ^R, but highlights cells which have expressions.  It also displays  the
              expressions in the highlighted cells as left-flushed strings, instead of the numeric values and/or
              label strings of those cells.  This command makes it easier to check expressions,  at  least  when
              they  fit in their cells or the following cell(s) are blank so the expressions can slop over (like
              label strings).  In the latter case, the slop over is not cleared on the next  screen  update,  so
              you may want to type ^L after the ^X in order to clean up the screen.

       @      Recalculates the spreadsheet.

   Variable Names
       Normally,  a  variable  name is just the name of a cell, such as K20.  The value is the numeric or string
       value of the cell, according to context.

       When a cell's expression (formula) is copied  to  another  location  via  copy  or  range-copy,  variable
       references are by default offset by the amount the formula moved.  This allows the new formula to work on
       new data.  If cell references are not to change, you can either use the @fixed operator (see  below),  or
       one of the following variations on the cell name.

       K20    References cell K20; the reference changes when the formula is copied.

       $K$20  Always refers to cell K20; the reference stays fixed when the formula is copied.

       $K20   Keeps the column fixed at column K; the row is free to vary.

       K$20   Similarly, this fixes the row and allows the column to vary.

       These  conventions  also hold on defined ranges.  Range references vary when formulas containing them are
       copied.  If the range is defined with fixed variable references, the references do not change.

       @fixed To make a variable not change automatically when a cell moves, put the word @fixed in front of the
              reference, for example: B1 ∗ @fixed C3.

   Numeric Expressions
       Numeric  expressions  used with the ``='' and e commands have a fairly conventional syntax.  Terms may be
       constants, variable names, parenthesized expressions, and negated terms.  Ranges  may  be  operated  upon
       with  range  functions  such  as  sum  (@sum()) and average (@avg()).  Terms may be combined using binary
       operators.

       -e     Negation.

       e+e    Addition.

       e-e    Subtraction.

       ee    Multiplication.

       e/e    Division.

       e1%e2  e1 mod e2.

       e^e    Exponentiation.

       e<e
       e<=e
       e=e
       e!=e
       e>=e
       e>e    Relationals: true (1) if and only if the indicated relation holds,  else  false  (0).   Note  that
              ``<='', ``!='', and ``>='' are converted to their ``!()'' equivalents.

       ~e     Boolean operator NOT.

       e&e    Boolean operator AND.

       e|e    Boolean operator OR.

       @if(e,e,e)
       e?e:e  Conditional:  If  the first expression is true then the value of the second is returned, otherwise
              the value of the third.

       Operator precedence from highest to lowest is:

              -, ~, !
              ^
              ∗, /
              +, -
              <, <=, =, !=, >=, >
              &
              |
              ?:

   Built-in Range Functions
       These functions return numeric values.  The @sum, @prod, @avg, @count, @max, @min, and @stddev  functions
       may  take an optional second argument which is an expression that is to be evaluated for each cell in the
       specified range to determine which cells to include in the function.  Only  those  cells  for  which  the
       expression  evaluates  to  true (non-zero) will be used in calculating the value of the function.  Before
       evaluation for each cell, the expression is first converted as if it was being copied from  the  cell  in
       the  upper  left-hand  corner  of  the  range into the cell under consideration, with all cell references
       adjusted accordingly.  Because the parts of the expression that should remain fixed during the evaluation
       of  the function may not necessarily be the same as those which should remain fixed during an actual copy
       operation, the rules for adjusting cell references during a copy operation are  slightly  different  than
       normal.  In particular, these rules differ in two different ways.

       The first difference is that the @fixed operator is ignored during a copy operation unless it is enclosed
       in parentheses.  This is so that selected cells whose addresses should  remain  fixed  during  any  given
       evaluation  of  a  range function can be adjusted relative to the cell containing the range function when
       copied (the $ prefix is still honored for these cells when copying).  Enclosing the  @fixed  operator  in
       parentheses  will  have  the  opposite  effect.  That is, it will cause cell references to be fixed while
       copying, while allowing them to be adjusted when the function  is  being  evaluated,  subject  to  any  $
       prefixes  present.   Note that only the @fixed operator itself should be enclosed in parentheses for this
       to work properly.

       The second difference is that any references in the expression that refer to cells in the  range  in  the
       first argument of the range function will have any $ prefixes ignored, and the references will be treated
       instead as if they had the same $ prefixes as the left side of the range argument.  For example,  if  the
       left  side  of  the  range argument (the cell address on the left side of the colon) has a fixed row, but
       does not have a fixed column, any cell references that refer to cells in that  range  will  also  have  a
       fixed  row, but will not have a fixed column.  This is so that if the range reference moves when copying,
       references to any cells in that range will also move accordingly.

       Note that the test expression will be evaluated once for every  cell  in  the  range,  which  means  that
       excessive  use  of  these  functions with the optional test expression, or the use of overly complex test
       expressions or with very large ranges can greatly slow down the recalculation of a spreadsheet,  and  may
       require turning off autocalc for speed, and then manually recalculating with the @ command.

       @sum(r)
       @sum(r,e)         Sum all valid (nonblank) entries in the region whose two corners are defined by the two
                         variable names (e.g.  c5:e14)  or  the  range  name  specified.   The  optional  second
                         argument  is  an  expression which can be used to determine which cells in the range to
                         sum (see above).

       @prod(r)
       @prod(r,e)        Multiply together all valid (nonblank) entries in the specified region.   The  optional
                         second  argument  is  an  expression  which can be used to determine which cells in the
                         range to multiply (see above).

       @avg(r)
       @avg(r,e)         Average all valid (nonblank) entries in the  specified  region.   The  optional  second
                         argument  is  an  expression which can be used to determine which cells in the range to
                         average (see above).

       @count(r)
       @count(r,e)       Count all valid (nonblank) entries  in  the  specified  region.   The  optional  second
                         argument  is  an  expression which can be used to determine which cells in the range to
                         count (see above).

       @max(r)
       @max(r,e)         Return the maximum value in the specified region.  The optional second argument  is  an
                         expression  which  can  be used to exclude specific cells in the range when determining
                         this maximum value (see above).  See also the multi argument version of @max below.

       @min(r)
       @min(r,e)         Return the minimum value in the specified region.  The optional second argument  is  an
                         expression  which  can  be used to exclude specific cells in the range when determining
                         this minimum value (see above).  See also the multi argument version of @min below.

       @stddev(r)
       @stddev(r,e)      Return the sample standard deviation  of  the  cells  in  the  specified  region.   The
                         optional  second  argument is an expression which can be used to exclude specific cells
                         in the range when calculating the standard deviation (see above).

       @rows(r)          Return the number of rows in the specified range.

       @cols(r)          Return the number of columns in the specified range.

       @lookup(e,r)
       @lookup(r,e)
       @lookup(se,r)
       @lookup(r,se)     Evaluates the expression then searches through the range r for a matching  value.   The
                         range should be either a single row or a single column.  The expression can be either a
                         string expression or a numeric expression.  If it is a numeric expression, the range is
                         searched for the the last value less than or equal to e.  If the expression is a string
                         expression, the string portions of the cells in the range are  searched  for  an  exact
                         string  match.   The value returned is the numeric value from the next row and the same
                         column as the match, if the range was a single row, or the value from the  next  column
                         and the same row as the match if the range was a single column.

       @hlookup(e,r,n)
       @hlookup(r,e,n)
       @hlookup(se,r,n)
       @hlookup(r,se,n)  Evaluates  the  expression  then  searches  through  the first row in the range r for a
                         matching value.  The expression  can  be  either  a  string  expression  or  a  numeric
                         expression.   If it is a numeric expression, the row is searched for the the last value
                         less than or equal to e.  If the expression is a string expression, the string portions
                         of  the cells in the row are searched for an exact string match.  The value returned is
                         the numeric value from the same column n rows below the match.

       @vlookup(e,r,n)
       @vlookup(r,e,n)
       @vlookup(se,r,n)
       @vlookup(r,se,n)  Evaluates the expression then searches through the first column in the range  r  for  a
                         matching  value.   The  expression  can  be  either  a  string  expression or a numeric
                         expression.  If it is a numeric expression, the column is searched  for  the  the  last
                         value  less  than  or equal to e.  If the expression is a string expression, the string
                         portions of the cells in the column are searched for an exact string match.  The  value
                         returned is the numeric value from the same row n columns to the right of the match.

       @index(e1,r)
       @index(r,e1)
       @index(r,e1,e2)   Use  the  values  of expressions e1 and (optionally) e2 to index into the range r.  The
                         numeric value at that position is returned.  With two arguments, the  range  should  be
                         either  a  single  row  or a single column.  An expression with the value 1 selects the
                         first item in the range, 2 selects the second item, etc.   With  three  arguments,  the
                         range  must  come first, and the second and third arguments will then be interpreted as
                         row and column, respectively, for indexing into a two-dimensional table.

       @stindex(e1,r)
       @stindex(r,e1)
       @stindex(r,e1,e2) Use the values of expressions e1 and (optionally) e2 to index into the  range  r.   The
                         string  value  at  that  position is returned.  With two arguments, the range should be
                         either a single row or a single column.  An expression with the  value  1  selects  the
                         first  item  in  the  range, 2 selects the second item, etc.  With three arguments, the
                         range must come first, and the second and third arguments will then be  interpreted  as
                         row and column, respectively, for indexing into a two-dimensional table.

   Built-in Numeric Functions
       All  of  these  functions operate on floating point numbers (doubles) and return numeric values.  Most of
       them are standard system functions more fully described in math(3).   The  trig  functions  operate  with
       angles in radians.

       @sqrt(e)          Return the square root of e.

       @exp(e)           Return the exponential function of e.

       @ln(e)            Return the natural logarithm of e.

       @log(e)           Return the base 10 logarithm of e.

       @floor(e)         Return the largest integer not greater than e.

       @ceil(e)          Return the smallest integer not less than e.

       @rnd(e)           Round  e  to the nearest integer.  default: *.5 will be rounded up to the next integer;
                         doing a 'set rndtoeven' will cause it to be rounded to the closest even number  instead
                         (aka  banker's round).  Round-to-even has advantages over the default rounding for some
                         applications.  For example, if X+Y is an integer, then X+Y = rnd(X)+rnd(Y) with  round-
                         to-even,  but  not  always  with  the  defaulting  rounding  method.   This could be an
                         advantage, for example, when trying to split an odd amount of money evenly between  two
                         people (it would determine who gets the extra penny).

       @round(e,n)       Round  e  to  n  decimal  places.  n may be positive to round off the right side of the
                         decimal or negative to round off the left side.  See @rnd(e) above for rounding types.

       @abs(e)
       @fabs(e)          Return the absolute value of e.

       @pow(e1,e2)       Return e1 raised to the power of e2.

       @hypot(e1,e2)     Return sqrt(e1∗e1+e2∗e2), taking precautions against unwarranted overflows.

       @pi               A constant quite close to pi.

       @dtr(e)           Convert e in degrees to radians.

       @rtd(e)           Convert e in radians to degrees.

       @sin(e)
       @cos(e)
       @tan(e)           Return trigonometric functions of radian arguments.  The magnitude of the arguments are
                         not checked to assure meaningful results.

       @asin(e)          Return the arc sine of e in the range -pi/2 to pi/2.

       @acos(e)          Return the arc cosine of e in the range 0 to pi.

       @atan(e)          Return the arc tangent of e in the range -pi/2 to pi/2.

       @atan2(e1,e2)     Returns the arc tangent of e1/e2 in the range -pi to pi.

       @max(e1,e2,...)   Return  the  maximum  of the values of the expressions.  Two or more expressions may be
                         specified.  See also the range version of @max above.

       @min(e1,e2,...)   Return the minimum of the values of the expressions.  Two or more  expressions  may  be
                         specified.  See also the range version of @min above.

       @ston(se)         Convert string expression se to a numeric value.

       @eqs(se1,se2)     Return  1  if  string  expression  se1  has  the same value as string expression se2, 0
                         otherwise.

       @nval(se,e)       Return the numeric value of a  cell  selected  by  name.   String  expression  se  must
                         evaluate  to  a column name (``A''-``AE'') and e must evaluate to a row number (0-199).
                         If se or e is out of bounds, or the cell has no numeric value, the result  is  0.   You
                         can  use  this  for simple table lookups.  Be sure the table doesn't move unexpectedly!
                         See also @sval() below.

       @err              Force an error.  This will force the expression which  contains  it  to  result  in  an
                         error.

   String Expressions
       String  expressions  are  made  up of constant strings (characters surrounded by double quotation marks),
       variables (cell names, which refer to the cells's label strings or expressions),  and  string  functions.
       Note  that string expressions are only allowed when entering a cell's label string, not its numeric part.
       Also note that string expression results may be left or right flushed or centered, according to the  type
       of the cell's string label.

       #      Concatenate strings.  For example, the string expression

                   A0 # "zy dog"

              displays the string ``the lazy dog'' in the cell if the value of A0's string is ``the la''.

   Built-in String Functions

       @filename(e)      Return  the  current  default  filename, as specified when the file was first loaded or
                         created, or during the last save, with the Put command.  If e is  0,  only  the  actual
                         filename will be returned, with any path removed.  If non-zero, the full path specified
                         on the command line or in the last Get or Put command will be returned.   If  the  path
                         begins with ``~'', it will be expanded to the appropriate users home directory.

       @substr(se,e1,e2) Extract  and return from string expression se the substring indexed by character number
                         e1 through character number e2 (defaults to the size of se if beyond the  end  of  it).
                         If e1 is less than 1 or greater than e2, the result is the null string.  For example,

                              @substr ("Nice jacket", 4, 8)

                         returns the string ``e jac''.

       @fmt(se,e)        Convert a number to a string.  The argument se must be a valid printf(3) format string.
                         e is converted according to the standard rules.  For example, the expression

                              @fmt ("∗∗%6.3f∗∗", 10.5)

                         yields the string ``∗∗10.500∗∗''.  e is a double, so applicable formats are e, E, f, g,
                         and G.  Try ``%g'' as a starting point.

       @sval(se,e)       Return the string value of a cell selected by name.  String expression se must evaluate
                         to a column name (``A''-``AE'') and e must evaluate to a row number (0-199).  If se  or
                         e  is  out  of  bounds, or the cell has no string value, the result is the null string.
                         You  can  use  this  for  simple  table  lookups.   Be  sure  the  table  doesn't  move
                         unexpectedly!

       @upper(se)
       @lower(se)        will case the string expression to upper or lower.

       @capital(se)      will convert the first letter of words in a string into upper case and other letters to
                         lower case (the latter if all letters of the string are upper case).

       @ext(se,e)        Call an external function (program or script).   The  purpose  is  to  allow  arbitrary
                         functions  on values, e.g. table lookups and interpolations.  String expression se is a
                         command or command line to call with popen(3).  The value of e is converted to a string
                         and appended to the command line as an argument.  The result of @ext() is a string: the
                         first line printed to standard output by the command.  The command should emit  exactly
                         one output line.  Additional output, or output to standard error, messes up the screen.
                         @ext() returns a null string and prints an appropriate warning  if  external  functions
                         are disabled, se is null, or the attempt to run the command fails.

                         External functions can be slow to run, and if enabled are called at each screen update,
                         so they are disabled by default.  You can enable them with ^T when you really want them
                         called.

                         A simple example:

                              @ext ("echo", a1)

                         You can use @ston() to convert the @ext() result back to a number.  For example:

                              @ston (@ext ("form.sc.ext", a9 + b9))

                         Note  that  you can build a command line (including more argument values) from a string
                         expression with concatenation.  You can also "hide" the second argument by  ending  the
                         command line (first argument) with `` #'' (shell comment).

       @coltoa(e)        Returns a string name for a column from the numeric argument.  For example:

                              @coltoa(@mycol-1)      @nval(coltoa(@mycol-1), @myrow+1)

   Built-in Financial Functions
       Financial  functions  compute  the  mortgage  (or  loan)  payment,  future  value,  and the present value
       functions.  Each accepts three arguments, an amount, a rate of interest (per period), and the  number  of
       periods.   These  functions  are  the  same  as  those commonly found in other spreadsheets and financial
       calculators

       @pmt(e1,e2,e3)    @pmt(60000,.01,360) computes the monthly payments for a $60000 mortgage at  12%  annual
                         interest (.01 per month) for 30 years (360 months).

       @fv(e1,e2,e3)     @fv(100,.005,36)  computes  the  future  value  for  36  monthly payments of $100 at 6%
                         interest (.005 per month).  It answers the question: "How much will I have in 36 months
                         if  I  deposit  $100  per  month  in  a  savings  account paying 6% interest compounded
                         monthly?"

       @pv(e1,e2,e3)     @pv(1000,.015,36) computes the present value of  an  ordinary  annuity  of  36  monthly
                         payments  of  $1000  at  18% annual interest.  It answers the question: "How much can I
                         borrow at 18% for 3 years if I pay $1000 per month?"

   Built-in Date and Time Functions
       Time for sc follows the system standard: the number of seconds since the beginning of 1970.  All date and
       time functions except @date() return numbers, not strings.

       @now              Return  the  current  time  encoded as the number of seconds since the beginning of the
                         epoch (December 31, 1969, midnight, GMT).

       @dts(e1,e2,e3)    Convert a date to the number of seconds from the epoch  to  the  first  second  of  the
                         specified  date,  local  time.   Dates  may  be  specified in either (m,d,y) or (y,m,d)
                         format, although the latter is preferred, since it's more universally recognized (m,d,y
                         is  only used in America).  If e2 > 12 or e3 > 31, then (m,d,y) is assumed.  Otherwise,
                         (y,m,d) is assumed.  For example, @date(@dts(1976,12,14)) yields

                              Tue Dec 14 00:00:00 1976

                         The month should range from  1 to 12; the day should range from 1 to the number of days
                         in  the  specified month; and the year should include the century (e.g. 1999 instead of
                         99).  Any date capable of being handled by the system is valid, typically 14  Dec  1901
                         to  18  Jan 2038 on a system that uses a 32 bit time_t.  Invalid dates or dates outside
                         of this range will return ERROR.  For rapid entry  of  dates  using  only  the  numeric
                         keypad,  sc  provides  the  alternate  syntax  y.m.d  or  m.d.y, which is automatically
                         converted to the @dts(...) format above.  The year, month,  and  day  must  be  entered
                         numerically in the alternate syntax; formulas are not allowed.

       @tts(e1,e2,e3)    @tts(8,20,45)  converts  the  time 8:40:45 to the number of seconds since midnight, the
                         night before.  The hour should range from 0 to 23; the minutes and seconds should range
                         from 0 to 59.

       The following functions take the time in seconds (e.g. from @now) as an argument and return the specified
       value.  The functions all convert from GMT to local time.

       @date(e)
       @date(e,se)       Convert the time in seconds to a date string.  With a single numeric argument, the date
                         will be 24 characters long in the following form:

                              Sun Sep 16 01:03:52 1973

                         Note  that  you can extract parts of this fixed-format string with @substr().  A format
                         string compatible with the strftime() function may optionally  be  given  as  a  second
                         argument to override the default format.  See the strftime(3) man page for details.

       @year(e)          Return  the year.  Valid years begin with 1970, although many systems will return years
                         prior to 1970 if e is negative.  The last legal year is system dependent.

       @month(e)         Return the month, encoded as 1 (January) to 12 (December).

       @day(e)           Return the day of the month, encoded as 1 to 31.

       @hour(e)          Return the number of hours since midnight, encoded as 0 to 23.

       @minute(e)        Return the number of minutes since the last full hour, encoded as 0 to 59.

       @second(e)        Return the number of seconds since the last full minute, encoded as 0 to 59.

   Spreadsheet Update
       Re-evaluation of spreadsheet expressions  is  done  by  row  or  by  column  depending  on  the  selected
       calculation  order.   Evaluation  is  repeated  up  to  iterations times for each update if necessary, so
       forward references usually work as expected.  See set above.  If  stability  is  not  reached  after  ten
       iterations,  a  warning  is  printed.   This is usually due to a long series of forward references, or to
       unstable cyclic references (for example, set A0's expression to ``A0+1'').

       @numiter          Returns the number of iterations performed so far.

   Programmable Function Keys
       Function keys can be used in sc if your terminal supports them, and they are  programmable.   To  program
       the  function  keys, you use the fkey command.  This command may be used in a .scrc file or a macro file,
       or it may be entered directly into sc's command line.  Defined function keys will be saved with the file.
       There  is  no  shortcut,  as there is with most commands, so the full command must be typed in.  Pressing
       enter when not editing a line will start you off with a blank line for this purpose.  The format  of  the
       fkey command is:

              fkey n = "command"

       where  n  is the function key number (n = 1 for F1, n = 2 for F2, etc.), and command is the command to be
       run.  For example,

              fkey 2 = "merge \"|~/scmacros/macro1\""

       will run the macro called macro1 located in a subdirectory of your home directory  called  scmacros  when
       the F2 key is pressed.  Note that embedded quotes must be escaped by a backslash.  If you want to include
       the cell address of the current cell in the command line, you may do so by entering ``$$'' in  its  place
       in the command.  For example,

              fkey 5 = "fmt $$ \"^D%A\""

       will  cause  the  F5  key to format the current cell to display the full weekday name of the numeric date
       value stored there.  The ^D is a CTRL-D character, which denotes a date format.

       Although it may be overridden by the fkey command, the F1 key is predefined by default to execute man sc.
       Unlike  the  user-defined  function  keys,  this  definition will also work in edit, insert, replace, and
       navigate modes.

       To undefine a function key, merely define it as the empty  string  ("").   Undefining  the  F1  key  will
       restore the default behavior.

   Plugins
       There  are three ways in which external programs can be used as plugins with sc.  First, they can be used
       as external commands.  When used as an external command,  any  command  not  recognized  by  sc  will  be
       searched for first in $HOME/.sc/plugins, and then in /usr/share/doc/sc/plugins.  If found, it will be run
       with its standard input and standard output redirected back to sc.  These are used to send  commands  to,
       and receive responses back from sc in the same way that advanced macros do.

       The second and third ways that programs can be used as plugins with sc are to automatically convert files
       to and from sc format based on their extensions.  In order to use  them  in  this  way,  you  must  first
       associate  a  given  extension to a corresponding plugin (for reading) or plugout (for writing) using the
       plugin and plugout commands.  These commands should be placed in your .scrc file, and have the  following
       syntax:

              plugin "ext" = "programname"

       or

              plugout "ext" = "programname"

       where  ext  is  the  extension and programname is the name of the plugin program to be used for filenames
       with that extension.  For input, the plugin merely reads the specified file, performs whatever conversion
       is  necessary,  and  writes  the  resulting  data  to  standard output.  For output, the plugin writes sc
       commands to standard output and reads the replies from standard input in the same way  that  an  advanced
       macro  would,  and  then  converts  the  data  to the appropriate format and writes it to a file with the
       specified filename.

FILES

       /usr/share/doc/sc/tutorial.sc Tutorial spreadsheet.

       $HOME/.scrc                   Initialization commands.

       ./.scrc                       More initialization commands.

SEE ALSO

       bc(1), dc(1), crypt(1), psc(1)

BUGS

       Top-to-bottom, left-to-right evaluation of expressions is silly.  A proper following  of  the  dependency
       graph with (perhaps) recourse to relaxation should be implemented.

       On  some  systems,  if  the  cell  cursor  is  in  column  0 with topline enabled (so the current cell is
       highlighted), or if any cell in column 0 is highlighted, the corresponding row number gets displayed  and
       then blanked during a screen refresh.  This looks like a bug in curses.

       Many  commands  give  no  indication  (a  message  or  beep)  if they have null effect.  Some should give
       confirmation of their action, but they don't.

AUTHORS

       This is a much modified version of a public domain spread sheet originally authored by James Gosling, and
       subsequently  modified  and  posted  to  USENET  by  Mark  Weiser  under  the  name  vc.  The program was
       subsequently renamed sc, and further modified by numerous contributors, Jeff Buhrt of Proslink, Inc.  and
       Robert   Bond   of   Sequent,   prominent   among   them.    The   current  maintainer  is  Chuck  Martin
       (nrocinu@myrealbox.com).

       Other contributors include: Tom Anderson, Glenn T. Barry, Gregory Bond, Stephen (Steve) M. Brooks,  Peter
       Brower,  John Campbell, Lawrence Cipriani, Jim Clausing, Dave Close, Chris Cole, Jonathan Crompron, David
       I. Dalva, Glen Ditchfield, Sam Drake, James P. Dugal, Paul  Eggert,  Andy  Fyfe,  Jack  Goral,  Piercarlo
       "Peter"  Grandi, Henk Hesselink, Jeffrey C Honig, Kurt Horton, Jonathan I. Kamens, Peter King, Tom Kloos,
       Michael Lapsley, Casey Leedom, Jay Lepreau, Dave Lewis, Rick Linck, Soren  Lundsgaard,  Tad  Mannes,  Rob
       McMahon,  Chris  Metcalf,  Mark  Nagel,  Ulf Noren, Marius Olafsson, Gene H. Olson, Henk P. Penning, Rick
       Perry, Larry Philps, Eric Putz, Jim Richardson, Michael Richardson, R. P. C. Rodgers, Kim  Sanders,  Mike
       Schwartz,  Alan Silverstein, Lowell Skoog, Herr Soeryantono, Tim Theisen, Tom Tkacik, Andy Valencia, Adri
       Verhoef, Rick Walker, Petri Wessman, and Tim Wilson.