Provided by: sc_7.16-2_i386 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.