(#f "Constant.  The boolean False."
    "Equivalent to nil, (), and false.")
(#t "Constant.  The boolean True." "Equivalent to t and true.")
(#> "Syntax.  (#> arg1...)"
    "Equivalent to (run (lambda () arg1...))."
    "Delimits the extent of control operations in arg."
    "Example:"
    "        (add1 (#> (sub1 (F (lambda (k) (k (k 3)))))))"
    "   =    (add1 (#> ((lambda (k) (k (k 3))) sub1)))"
    "   =    (add1 (#> (sub1 (sub1 3))))"
    "   =    (add1 (#> 1))"
    "   =    (add1 1)"
    "   =    2"
    ""
    "[Also see: F and run]")
(* "Function.  (* arg1 arg2)"
   "Returns the product of the numbers ARG1 and ARG2.")
(*print-during-load* "Constant.  If *print-during-load* is non-nil,"
    "the results of evaluating expressions while loading"
    "will be printed.  Defaults to nil.")
(*trace-level*
    "Variable.  The current nesting level of trace-lambdas.")
(+ "Function.  (+ arg1 arg2)"
   "Returns the sum of the numbers ARG1 and ARG2.")
(- "Function.  (- arg1 arg2)"
   "Returns the difference of ARG2 from ARG1.")
(/ "Function.  (/ arg1 arg2)"
   "Returns the true quotient of the numbers ARG1 and ARG2."
   "Note: (/ integer integer) returns a rational.")
(< "Function.  (< arg1 arg2)"
   "Returns whether the number ARG1 is less than the number"
   "ARG2.  Equivalent to (<? arg1 arg2).")
(<0 "Predicate Function.  (<0 arg)"
    "Returns whether the number ARG is positive."
    "Equivalent to (negative? arg) and (< 0 arg).")
(<= "Function.  (<= arg1 arg2)"
    "Returns whether the number ARG1 is less than or equal"
    "to the number ARG2."
    "Equivalent to (<=? arg1 arg2) and (or (< arg1 arg2)"
    "                                      (= arg1 arg2)).")
(<=? "Function.  (<=? arg1 arg2)"
     "Returns whether the number ARG1 is less than or equal"
     "to the number ARG2."
     "Equivalent to (<= arg1 arg2) and (or (< arg1 arg2)"
     "                                     (= arg1 arg2)).")
(<? "Function.  (<? arg1 arg2)"
    "Returns whether the number ARG1 is less than the number"
    "ARG2.  Equivalent to (< arg1 arg2).")
(= "Function.  (= arg1 arg2)"
   "Returns whether the numbers ARG1 and ARG2 are equivalent."
   "Equivalent to (=? arg1 arg2).")
(=0 "Predicate Function.  (=0 arg)"
    "Returns whether the number ARG is 0."
    "Equivalent to (zero? arg).")
(=? "Function.  (=? arg1 arg2)"
    "Returns whether the numbers ARG1 and ARG2 are equivalent."
    "Equivalent to (= arg1 arg2).")
(> "Function.  (> arg1 arg2)"
   "Returns whether the number ARG1 is greater than the number"
   "ARG2.  Equivalent to (>? arg1 arg2).")
(>0 "Predicate Function.  (>0 arg)"
    "Returns whether the number ARG is positive."
    "Equivalent to (positive? arg) and (> 0 arg).")
(>= "Function.  (>= arg1 arg2)"
    "Returns whether the number ARG1 is greater than or equal"
    "to the number ARG2."
    "Equivalent to (>=? arg1 arg2) and (or (> arg1 arg2)"
    "                                      (= arg1 arg2)).")
(>=? "Function.  (>=? arg1 arg2)"
     "Returns whether the number ARG1 is greater than or equal"
     "to the number ARG2."
     "Equivalent to (>= arg1 arg2) and (or (> arg1 arg2)"
     "                                     (= arg1 arg2)).")
(>>> "Constant.  'a_prompt.")
(>? "Function.  (>? arg1 arg2)"
    "Returns whether the number ARG1 is greater than the number"
    "ARG2.  Equivalent to (> arg1 arg2).")
(abs "Function.  (abs arg)"
     "Returns the absolute value of the number ARG."
     "Equivalent to (magnitude arg).")
(acos "Function.  (acos arg)"
      "Returns the arccosine of the number ARG (taken in radians)."
      "Equivalent to (arccos arg).")
(acosh "Function.  (acosh arg)"
       "Returns the hyperbolic arccosine of the number ARG (taken"
       "in radians).  Equivalent to (arccosh arg).")
(add-to-syntax-table "Function.  (add-to-syntax-table arg1 arg2)"
    "Declares or redefines a syntactic extension."
    "ARG1 must be a list of keywords for the syntactic"
    "extension, the car of which must be the name of it."
    "ARG2 must be a function of one argument which, given"
    "the original expression, returns the equivalent"
    "transformed expression.")
(add1 "Function.  (add1 arg)" "Equivalent to (+ arg 1).")
(alias "Special Form.  (alias arg1 arg2)"
       "Declares the symbol ARG1 to be equivalent to the"
       "existing special form or syntax ARG2." "Returns ARG1.")
(alist "Class.  (Association list)  A specific class of lists."
       "Has the form ((key1 . data1)...).  Used for dictionary"
       "class lookup on keys, with assoc, assv, and assq.")
(and "Syntax.  (and arg1...)"
     "Evaluates ARG1...ARGn (left-to-right), until ARGi such that"
     "ARGi is false, and returns false.  Returns ARGn if no ARGi"
     "is false.")
(angle "Function.  (angle arg)"
       "Returns the phase angle of the complex number ARG."
       "Note:  Since this is not uniquely determined, the"
       "return value is in the range [0,2*pi).")
(any "Constant.  '#!Unspecified")
(append "Function.  (append arg1...)"
        "Returns a list which is the concatenation of the"
        "lists ARG1 to ARGn.  Equivalent to (concat arg1...).")
(append! "Function.  (append! arg1...)"
         "Changes the lists ARG1...ARGn-1, so that each will"
         "be concatenation of itself and any following strings."
         "Returns the modified ARG1.")
(append-cont "Function.  (append-cont arg1 arg2)"
    "*** No help available. ***")
(application-semantics "Function.  (application-semantics arg)"
    "*** No help available. ***")
(apply "Function.  (apply arg1 arg2)"
       "Applies the function ARG1 to the list of arguments ARG2,"
       "returning the value of the application.")
(apply-if "Syntax.  (apply-if test func exp1...)"
    "TEST is evaluated.  If it is non-null, FUNC is applied to"
    "its value, and the application's value returned.  Else, EXP1"
    "...EXPn are evaluated, and EXPn returned.")
(arccos "Function.  (arccos arg)"
        "Returns the arccosine of the number ARG (taken in radians)."
        "Equivalent to (acos arg).")
(arccosh "Function.  (arccosh arg)"
         "Returns the hyperbolic arccosine of the number ARG (taken"
         "in radians).  Equivalent to (acosh arg).")
(arcsin "Function.  (arcsin arg)"
        "Returns the arcsine of the number ARG (taken in radians)."
        "Equivalent to (asin arg).")
(arcsinh "Function.  (arcsinh arg)"
         "Returns the hyperbolic arcsine of the number ARG (taken"
         "in radians).  Equivalent to (asinh arg).")
(arctan "Function.  (arctan arg)"
        "Returns the arctangent of the number ARG (taken in radians)."
        "Equivalent to (atan arg 1).")
(arctanh "Function.  (arctanh arg)"
         "Returns the hyperbolic arctangent of the number ARG (taken"
         "in radians).  Equivalent to (atanh arg).")
(ascii->symbol "Function.  (ascii->symbol arg)"
    "Creates and returns an interned symbol with its name"
    "as the character ascii-coded by the integer ARG.")
(asin "Function.  (asin arg)"
      "Returns the arcsine of the number ARG (taken in radians)."
      "Equivalent to (arcsin arg).")
(asinh "Function.  (asinh arg)"
       "Returns the hyperbolic arcsine of the number ARG (taken"
       "in radians).  Equivalent to (arcsinh arg).")
(assoc "Selector Function.  (assoc arg1 arg2)"
       "Returns the key/data pair of the association list"
       "(alist) ARG2 whose key is equal? to ARG1."
       "Returns the empty list if no key is equal? to ARG1.")
(assq "Selector Function.  (assq arg1 arg2)"
      "Returns the key/data pair of the association list"
      "(alist) ARG2 whose key is eq? to ARG1."
      "Returns the empty list if no key is eq? to ARG1.")
(assv "Selector Function.  (assv arg1 arg2)"
      "Returns the key/data pair of the association list"
      "(alist) ARG2 whose key is eqv? to ARG1."
      "Returns the empty list if no key is eqv? to ARG1.")
(atan "Function.  (atan arg1 arg2)"
      "Returns the arctangent of the number ARG1/ARG2 (taken in"
      "radians)."
      "Equivalent to (arctan (/ arg1 arg2)) or (angle (make-"
      "rectangular arg1 arg2)).")
(atanh "Function.  (atanh arg)"
       "Returns the hyperbolic arctangent of the number ARG (taken"
       "in radians).  Equivalent to (arctanh arg).")
(atom "Class.  A single object."
      "Union of symbols, numbers, and the empty list.")
(autoload "Syntax.  (autoload id formals filename)"
    "Creates a function called ID with parameter list FORMALS."
    "When invoked, it loads the file FILENAME (via 'load'), and"
    "applies ID (which should be redefined in FILENAME) to the"
    "instantiated FORMALS."
    "Used for large, but seldom needed, functions.")
(autoload-syntactic-extension
    "Syntax.  (autoload-syntactic-extension id filename)"
    "Creates a syntactic extension called ID.  When used, it"
    "loads the file FILENAME (via 'load'), and processes ID"
    "(which should be redefined in FILENAME) again."
    "Used for large, but seldom needed, syntactic extensions.")
(begin "Syntax.  (begin exp1...)"
       "Executes expressions EXP1...EXPn in order, returning"
       "the value from EXPn.  Equivalent to ((lambda () exp1...)).")
(begin0 "Syntax.  (begin0 exp0 exp1...)"
        "Executes expressions EXP0...EXPn in order, returning"
        "the value from EXP0."
        "Equivalent to (let ((v exp0)) (begin exp1... v)).")
(beta-tag "Function.  (beta-tag arg)"
    "*** No help available. ***")
(boolean? "Predicate Function.  (boolean? arg)"
    "Returns whether ARG is boolean: one of t or nil.")
(call-with-input-file "Function.  (call-with-input-file arg1 arg2)"
    "Returns the value of applying the function ARG1 to an"
    "input port associated with the file named by the string"
    "ARG2.")
(call-with-output-file "Function.  (call-with-output-file arg1 arg2)"
    "Returns the value of applying the function ARG1 to an"
    "output port associated with the file named by the string"
    "ARG2.")
(call/cc "Function.  (call/cc arg)"
    "*** No help available. ***")
(call/ccc "Function.  (call/ccc arg)"
    "*** No help available. ***")
(car "Selector Function.  (car arg)"
     "Returns the car of the pair ARG.  It is an error if ARG")
(case "Syntax.  (case exp (obj1 exp11...)... [(else expn1...)])"
  "If sequence, each OBJi is compared with EXP.  If OBJi is"
  "eq? to EXP, EXPi1...EXPim is executed, returning EXPim,"
  "without continuing further comparisons.  The 'else' clause"
  "will always succeed.  If no clause succeeds, the empty"
  "list is returned.")
(cdr "Selector Function.  (cdr arg)"
     "Returns the cdr of the pair ARG.")
(ceiling "Function.  (ceiling arg)"
         "Returns the ceiling of the number ARG."
         "I.e., returns ARG rounded up to the nearest integer.")
(char->integer "Function.  (char->integer arg)"
    "Returns the integer ascii-code of the character ARG.")
(char-alphabetic? "Predicate Function.  (char-alphabetic? arg)"
    "Returns whether the character ARG is alphabetic" "(a-z,A-Z).")
(char-ci<=? "Function.  (char-ci<=? arg1 arg2)"
    "Returns whether the character ARG1 is less than or equal"
    "to the character ARG2.  (Case insensitive ASCII comparison)")
(char-ci<? "Function.  (char-ci<? arg1 arg2)"
    "Returns whether the character ARG1 is less than the"
    "character ARG2.  (Case insensitive ASCII comparison)")
(char-ci=? "Function.  (char-ci=? arg1 arg2)"
    "Returns whether the characters ARG1 and ARG2 are equal."
    "(Case insensitive)")
(char-ci>=? "Function.  (char-ci>=? arg1 arg2)"
    "Returns whether the character ARG1 is greater than or"
    "equal to the character ARG2.  (Case insensitive"
    "ASCII comparison)")
(char-ci>? "Function.  (char-ci>? arg1 arg2)"
    "Returns whether the character ARG1 is greater than the"
    "character ARG2.  (Case insensitive ASCII comparison)")
(char-downcase "Function.  (char-downcase arg)"
    "if ARG is upper-case, it returns the lower-case"
    "equivalent of ARG, else it returns the character ARG.")
(char-lower-case? "Predicate Function.  (char-lower-case? arg)"
    "Returns whether the character ARG is lower case (a-z).")
(char-numeric? "Predicate Function.  (char-numeric? arg)"
    "Returns whether the character ARG is numeric (0-9).")
(char-ready? "Function.  (char-ready? [arg])"
    "Returns whether there is input available from the"
    "input port ARG (defaults to current-input-port).")
(char-upcase "Function.  (char-upcase arg)"
    "If ARG is lower-case, it returns the upper-case"
    "equivalent of ARG, else it returns the character ARG.")
(char-upper-case? "Predicate Function.  (char-upper-case? arg)"
    "Returns whether the character ARG is upper case (A-Z).")
(char-whitespace? "Predicate Function.  (char-whitespace? arg)"
    "Returns whether the character ARG is whitespace"
    "(#space, #tab, #newline, #page, #backspace)")
(char<=? "Function.  (char<=? arg1 arg2)"
         "Returns whether the character ARG1 is less than or equal"
         "to the character ARG2.  (ASCII comparison)")
(char<? "Function.  (char<? arg1 arg2)"
        "Returns whether the character ARG1 is less than the"
        "character ARG2.  (ASCII comparison)")
(char=? "Function.  (char=? arg1 arg2)"
        "Returns whether the characters ARG1 and ARG2 are equal.")
(char>=? "Function.  (char>=? arg1 arg2)"
         "Returns whether the character ARG1 is greater than or"
         "equal to the character ARG2.  (ASCII comparison)")
(char>? "Function.  (char>? arg1 arg2)"
        "Returns whether the character ARG1 is greater than the"
        "character ARG2.  (ASCII comparison)")
(char? "Predicate Function.  (char? arg)"
       "Returns whether ARG is a character.")
(close-input-port "Function.  (close-input-port arg)"
    "Closes the input-port ARG and returns the closed input-"
    "port.")
(close-output-port "Function.  (close-output-port arg)"
    "Closes the outpt-port ARG and returns the closed output-"
    "port.")
(compile "Function.  (compile arg)"
         "Returns the internal compiled form of ARG.")
(complex? "Predicate Function.  (complex? arg)"
    "Returns whether ARG is a complex number."
    "Equivalent to (number? arg).")
(concat "Function.  (concat arg1...)"
        "Returns a string which is the concatenation of the"
        "strings ARG1 to ARGn.  Equivalent to (append arg1...).")
(cond
  "Syntax.  (cond (test1 exp11...)... [(else expn1...)])"
  "In sequence, tests TESTi, and if non-null, executes"
  "EXPi1..EXPim, returning EXPim, then skipping any other"
  "tests.  The 'else' test will always succeed.  If no TESTi"
  "is non-null, the empty list is returned.")
(cons "Function.  (cons arg1 arg2)"
      "Creates and returns a new pair (cons cell) with car ARG1"
      "and cdr ARG2.")
(constant? "Predicate Function.  (constant? arg)"
    "Returns whether ARG is a constant.")
(copy "Function.  (copy arg)"
      "Returns a copy of ARG with different cons cells from the"
      "original.  Thus, (equal? arg (copy arg)) returns t, but"
      "changing ARG (e.g. with set-car!) does not effect the copy.")
(cos "Function.  (cos arg)"
     "Returns the cosine of the number ARG (taken in radians).")
(cosh "Function.  (cosh arg)"
      "Returns the hyperbolic cosine of the number ARG (taken"
      "in radians).")
(current-column "Function.  (current-column [arg])"
    "Returns the current column for printing for the output"
    "port ARG (defaults to current-output-port).")
(current-input-port "Function.  (current-input-port)"
    "Returns the current default input-port.")
(current-output-port "Function.  (current-output-port)"
    "Returns the current default output-port.")
(declare-constant "Function.  (declare-constant arg)"
    "Declares the identifier ARG to be a constant.")
(define! "Syntax.  (define! id exp)"
         "Equivalent to (begin (set! id exp) id).")
(delay "Syntax.  (delay exp1...)"
       "Returns a closure of zero arguments (a thunk), which when"
       "applied, returns the value of evaluating EXP1...EXPn in the"
       "delaying environment.  Note that EXP1...EXPn are evaluated"
       "only upon the first application.  See also force, freeze.")
(delete! "Function.  (delete! arg1 arg2)"
         "Deletes all things equal? to ARG2 from the list ARG1."
         "Returns the modified ARG1.")
(delq! "Function.  (delq! arg1 arg2)"
       "Deletes all things eq? to ARG2 from the list ARG1."
       "Returns the modified ARG1.")
(delv! "Function.  (delv! arg1 arg2)"
       "Deletes all things eqv? to ARG2 from the list ARG2."
       "Returns the modified ARG1.")
(denominator "Function.  (denominator arg)"
    "Returns the denominator of the rational number ARG.")
(deref "Function.  (deref arg)"
       "Returns the value of the reference cell ARG.")
(describe "Syntax.  (describe arg1...)"
    "Equivalent to (help 'arg1...).")
(display "Function.  (display arg1 [arg2])"
         "Prints ARG1 in a machine-readable format to the output port"
         "ARG2 (defaults to current-output-port).  Returns nil.")
(display& "Function.  (display& arg1 [arg2])"
    "Prints ARG1 in a machine-readable format to the output port"
    "ARG2 (defaults to current-output-port).  Unlike display"
    "in that unprintable objects are printed with internal"
    "format.  Returns nil.")
(else "Constant.  Equivalent to true and #t.")
(eof "Constant.  Object indicating end-of-file.")
(eof-object? "Predicate Function.  (eof-object? arg)"
    "Returns whether ARG indicates the end-of-file.")
(eq? "Predicate Function.  (eq? arg1 arg2)"
     "Returns whether ARG1 and ARG2 are the same objects."
     "Atoms are eq? to themselves, except for numbers."
     "Pairs are eq? to other pairs only if created by the"
     "same function calls.")
(equal? "Predicate Function.  (equal? arg1 arg2)"
        "Returns whether ARG1 and ARG2 are similar objects."
        "Objects are equal? if they are eqv? or, for structures,"
        "if their components are equal?")
(eqv? "Predicate Function.  (eqv? arg1 arg2)"
      "Returns whether ARG1 and ARG2 are the same objects (eq?),"
      "or are numbers of the same class and equal.")
(error "Function.  (error arg1...)"
       "Prints the error message given by ARG1 to ARGn, and returns"
       "to the top-level.")
(even? "Predicate Function.  (even? arg)"
       "Returns whether the integer ARG is even.")
(execute "Function.  (execute arg)"
         "Executes the internal instructions encoded in the list"
         "ARG, and returns the final value.")
(exit "Function.  (exit)" "Exits from scheme88.  Does not return.")
(exit-try "Function.  (exit-try arg)"
          "*** No help available. ***")
(exp "Function.  (exp arg)"
     "Returns the number ARG to the power of nat-log-base."
     "Equivalent to (expt arg nat-log-base).")
(expand "Function.  (expand arg)"
        "Returns the macro expansion of the expression ARG.")
(expand-once "Function.  (expand-once arg)"
    "Returns the macro expansion of the expression ARG"
    "such that expansion is only done once.")
(explode "Function.  (explode arg)"
         "Returns a list of the characters of the print name"
         "of the symbol ARG.")
(expt "Function.  (expt arg1 arg2)"
      "Returns the number ARG1 to the power of the number ARG2.")
(F "Procedure of one argument"
   "Expects arg to evaluate to a procedure of one variable."
   "Let cont be the procedure representing the current continuation"
   "(relative to the closest prompt #>). Aborts the current continuation"
   "and evaluates (arg cont)."
   "Example:  (add1 (F (lambda (k) (k 0))))
            = ((lambda (k) (k 0)) add1)
            = 1"
   ""
   "[Also see: #> and run]")
(false "Constant.  The boolean False."
       "Equivalent to nil, (), and #f.")
(file-exists? "Function.  (file-exists? arg)"
    "Returns whether the file named by the string or symbol"
    "ARG exists.")
(fix "Function.  (fix arg)"
     "Returns the nearest integer below the number ARG."
     "Equivalent to (floor arg).")
(float "Function.  (float arg)"
       "Returns the real number equivalent of the rational ARG.")
(floor "Function.  (floor arg)" "Returns the floor of the number ARG."
       "I.e., returns ARG rounded down to the nearest integer."
       "Equivalent to (fix arg).")
(flush-input "Function.  (flush-input [arg])"
    "Eliminates input from input buffer for the input port ARG"
    "(defaults to current-input-port).  Returns nil."
    "***Not implemented***")
(flush-output "Function.  (flush-output [arg])"
    "Eliminates output from output buffer for the output port ARG"
    "(defaults to current-output-port).  Returns nil."
    "***Not implemented***")
(force "Function.  (force arg)"
       "Invokes the thunk ARG.  See also delay."
       "Equivalent to (lambda (arg) (arg)) or (thaw arg).")
(freeze "Syntax.  (freeze exp1...)"
        "Returns a closure of zero arguments (a thunk), which when"
        "applied, evaluates EXP1...EXPn in the freezing environment."
        "Equivalent to (lambda () exp1...).  See also thaw, delay.")
(function-alias "Function.  (function-alias arg1 arg2)"
    "Declares the scheme88 function ARG1 to be equivalent to the"
    "existing Common Lisp function ARG2.")
(function? "Predicate Function.  (function? arg)"
    "Returns whether ARG is a function/closure."
    "Equivalent to (procedure? arg).")
(gc "Function.  (gc arg)"
    "Causes garbage collection to be performed.  This normally"
    "occurs automatically whenever necessary.  ARG specifies"
    "the completeness of garbage collection (1, 2, or 3).")
(gcd "Function.  (gcd arg1...)"
     "Returns the greatest common divisor of the numbers"
     "ARG1 to ARGn.")
(genbase "Function.  (genbase)"
         "Returns an empty environment.")
(gensym "Function.  (gensym arg)"
        "If ARG is a number, the gensym counter is set to ARG."
        "If ARG is a string or string, the gensym leader is set"
        "to ARG, and the gensym counter is incremented.  The"
        "gensym leader defaults to '^'."
        "Returns a new atom whose name is the gensym leader"
        "followed by the gensym counter.")
(getprop "Function.  (getprop arg1 arg2)"
         "Returns the value found of the property list (plist)"
         "for the symbol ARG1 for the property indicated by the"
         "symbol ARG2.  If ARG1's property list does not contain"
         "the property ARG2, it returns false.")
(global-binding "Function.  (global-binding arg)"
    "Returns the global binding of the identifier ARG.")
(global-namespace-type "Function.  (global-namespace-type arg)"
    "Returns the class (e.g. primitive, constant, ...) of the"
    "object referred to by the global identifier ARG.")
(global-scheme-top-level
    "Constant Function.  (global-scheme-top-level)"
    "Constant value of the initial scheme-top-level.")
(help "Function.  (help arg1...)"
      "Prints brief messages about the subjects (class, function,"
      "etc.) of ARGs, which must be quoted.  If a function's"
      "arguments' classes are specified, it is anerror for those"
      "arguments not to be of that class."
      "With no arguments, help returns the list of topics for"
      "which there is help, else it returns the empty list.")
(identifier "An identifier is a name that which references an object."
    "An identifier may be any legal symbol." ""
    "Conventions often followed:"
    "    Global constants             : *foo*"
    "    Predicate functions          : foo?"
    "    Functions with side effects  : foo!"
    "    Function for class conversion: foo->bar")
(identifier-semantics "Function.  (identifier-semantics arg)"
    "*** No help available. ***")
(if "Special Form.  (if arg1 arg2 [arg3])"
    "Evaluates ARG1, if it is non-nil, then ARG2 is evaluated"
    "and its valued returned.  Else, ARG3 is evaluated"
    "(defaults to nil) and returned.")
(imag-part "Function.  (imag-part arg)"
    "Returns the imaginary part of the complex number ARG.")
(implode "Function.  (implode arg)"
         "ARG must be a list of characters, single-character"
         "symbols, and/or ascii-coded characters."
         "Returns a symbol whose print name is the concatenation"
         "of the character equivalents of the members of ARG.")
(import "Function.  (import arg)"
    "Declares the scheme88 function ARG to be equivalent to the"
    "existing Common Lisp function ARG."
    "Equivalent to (function-alias arg arg) and (import-from-host arg).")
(import-from-host "Function.  (import-from-host arg)"
    "Declares the scheme88 function ARG to be equivalent to the"
    "existing Common Lisp function ARG."
    "Equivalent to (function-alias arg arg) and (import arg).")
(integer->char "Function.  (integer->char arg)"
    "Returns the character ascii-coded by the integer ARG.")
(integer? "Predicate Function.  (integer? arg)"
    "Returns whether ARG is an integer.")
(intern* "Function.  (intern* arg)"
    "*** No help available. ***")
(lambda "Special Form.  (lambda arg1 arg2...)"
    "Returns a closure with bound identifiers as the atom"
    "or list ARG1 and body ARG2.  When applied, it binds"
    "the identifiers in ARG1, executes ARG2...ARGn, and"
    "returns the value of ARGn."
    "If ARG1 is a proper list, the closure expects the same"
    "number of arguments as identifiers.  If ARG1 is an atom"
    "or an improper list of the form (a b ... . z), the last"
    "identifier is bound to the list of any arguments not"
    "bound to another identifier.")
(last-pair "Function.  (last-pair arg)"
    "Recursively descends the cdr of ARG, returning the pair"
    "whose cdr is an atom.")
(lcm "Function.  (lcm arg1...)"
     "Returns the least common multiple of the numbers"
     "ARG1 to ARGn.")
(length "Function.  (length arg)"
        "Returns the length of the list ARG."
        "(list-tail arg (length arg)) returns the empty list.")
(let "Syntax.  (let ((id1 exp1)...) body1...)"
  "Binds IDi to the result of EXPi (evaluated in the"
  "environment surrounding the let), evaluates BODY1..."
  "BODYn in the environment with these bindings, and"
  "returns the value of BODYn.")
(let* "Syntax.  (let* ((id1 exp1)...) body1...)"
  "Binds IDi to the result of EXPi (evaluated in the"
  "environment containing the bindings for ID1...IDi-1),"
  "evaluates BODY1...BODYn in the environment with these"
  "bindings, and returns the value of BODYn.")
(letrec "Syntax.  (letrec ((id1 exp1)...) body1...)"
        "Binds IDi to the result of EXPi (evaluated in the"
        "environment containing these bindings), evaluates"
        "BODY1...BODYn in this environment, and returns BODYn.")
(line-length "Function.  (line-length [arg])"
    "Returns the line length for printing for the output"
    "port ARG (defaults to current-output-port).")
(lisp-eval "Function.  (lisp-eval arg)"
    "Returns the value of ARG evaluated in IBUKI Common Lisp."
    "Note that the environment that ARG will be evaluated in"
    "contains the scheme88 interpreter.")
(list "Class.  Union of the empty list nil and pairs whose"
      "final cdr is the empty list." "" "Function.  (list arg1...)"
      "Returns list of ARGs: (arg1 arg2 ...)")
(list->string "Function.  (list->string arg)"
    "Returns the string consisting of the characters in"
    "the list ARG.")
(list->vector "Function.  (list->vector arg)"
    "Returns the vector with the same length and components"
    "as the list ARG.")
(list-ref "Function.  (list-ref arg1 arg2)"
    "Returns the ARG2-th element (0-based) of ARG1."
    "Returns the empty list if ARG2 > (length arg1)."
    "Equivalent to (car (list-tail arg1 arg2)), except in"
    "the latter case." "Equivalent to (nth (sub1 arg2) arg1).")
(list-tail "Function.  (list-tail arg1 arg2)"
    "Returns the ARG2-th cdr of ARG1.  (list-tail arg1 0)"
    "returns ARG1.  If ARG2 > (length arg1), it returns"
    "the empty list.  This is equivalent to nthcdr in other"
    "languages.")
(literal-semantics "Function.  (literal-semantics arg)"
    "*** No help available. ***")
(load "Function.  (load arg)"
      "Loads the expressions in the file indicated by the string"
      "or symbol ARG as if they were entered via the keyboard."
      "Uses the default extensions .s and .ss, if necessary.")
(load-file "Function.  (load-file arg)"
    "Loads the expressions in the file indicated by the string"
    "ARG as if they were entered via the keyboard.")
(log "Function.  (log arg)"
     "Returns the natural logarithm of the number ARG.")
(magnitude "Function.  (magnitude arg)"
    "Returns the magnitude of the complex number ARG."
    "Equivalent to (abs arg).")
(make-printable "Function.  (make-printable arg)"
    "*** No help available. ***"
    "See also (make-unprintable arg1 arg2).")
(make-polar "Function.  (make-polar arg1 arg2)"
    "Returns the complex number with magnitude ARG1 and"
    "angle ARG2.")
(make-rectangular "Function.  (make-rectangular arg1 arg2)"
    "Returns the complex number ARG1 + ARG2*i."
    "I.e., returns the complex number with real-part ARG1"
    "and imaginary part ARG2.")
(make-string "Function.  (make-string arg1 [arg2])"
    "Returns a string of length ARG1.  If ARG2 is given, it"
    "is initialized to be filled with the character ARG2.")
(make-unprintable "Function.  (make-unprintable arg1 arg2)"
    "*** No help available. ***"
    "See also (make-printable arg).")
(make-vector "Function.  (make-vector arg1 [arg2])"
    "Returns a vector of length ARG1.  If ARG2 is given, it"
    "is initialized to be filled with ARG2.")
(match "Syntax."
       "*** No help available. ***")
(match-lambda "Syntax."
     "*** No help available. ***")
(match-mulambda "Syntax."
     "*** No help available. ***")
(max "Function.  (max arg1...)"
     "Returns the largest of the numbers ARG1 to ARGn.")
(member "Function.  (member arg1 arg2)"
        "Returns the cdr of ARG2 whose car is equal? to ARG1."
        "Returns the empty list, if ARG1 is not in ARG2.")
(memq "Function.  (memq arg1 arg2)"
      "Returns the cdr of ARG2 whose car is eq? to ARG1."
      "Returns the empty list, if ARG1 is not in ARG2.")
(memv "Function.  (memv arg1 arg2)"
      "Returns the cdr of ARG2 whose car is eqv? to ARG1."
      "Returns the empty list, if ARG1 is not in ARG2.")
(min "Function.  (min arg1...)"
     "Returns the smallest of the numbers ARG1 to ARGn.")
(minus "Function.  (minus arg)"
       "Returns the negation of the number ARG."
       "Equivalent to (- 0 arg).")
(mod "Function.  (mod arg1 arg2)"
     "Returns the modulus of the numbers ARG1 and ARG2.")
(nat-log-base "Constant.  Natural logarithm base. 'e'"
    "Equivalent to (exp 1).  2.71828...")
(negative? "Predicate Function.  (negative? arg)"
    "Returns whether the number ARG is negative."
    "Equivalent to (<0 arg) and (< 0 arg).")
(newline "Function.  (newline [arg])"
         "Writes a newline/carriage return to the output port ARG"
         "(defaults to current-output-port).  Returns nil.")
(nil "Constant.  The empty list.  The boolean False."
     "Equivalent to (), #f, and false." "It is NOT a pair.")
(not "Function.  (not arg)"
     "Returns t if ARG is the empty list, nil otherwise."
     "Equivalent to null?.")
(nth "Function.  (nth arg1 arg2)"
     "Returns the ARG1-th element (1-based) of ARG2."
     "Returns the empty list if ARG1 > (length arg2)."
     "Equivalent to (list-tail arg2 (add1 arg1)).")
(null? "Predicate Function.  (null? arg)"
       "Returns whether ARG is the empty list." "Equivalent to not.")
(number "Class.  Equivalent to complex numbers.  Significant"
        "subclasses are reals, rationals, and integers."
        "A subclass of atoms.")
(number? "Predicate Function.  (number? arg)"
         "Returns whether ARG is a number.")
(numerator "Function.  (numerator arg)"
    "Returns the numerator of the rational number ARG.")
(odd? "Predicate Function.  (odd? arg)"
      "Returns whether the integer ARG is odd.")
(open-append-file "Functon.  (open-append-file arg)"
    "Opens and returns the output port from the file named"
    "by the string or symbol ARG.  Creates the file ARG if"
    "necessary.  Any new output is appended onto the end"
    "of that already in the file.")
(open-input-file "Function.  (open-input-file arg)"
    "Opens and returns the input port from the file named"
    "by the string or symbol ARG.")
(open-output-file "Function.  (open-output-file arg)"
    "Opens and returns the output port from the file named"
    "by the string or symbol ARG.  Creates the file ARG if"
    "necessary.  Any information in the file is destroyed.")
(or "Syntax.  (or arg1...)"
    "Evaluates ARG1...ARGn (left-to-right), until ARGi such that"
    "ARGi is non-null, and returns ARGi.  Returns false if no"
    "ARGi is non-null.")
(pair "Class.  An object with two values: a car and cdr."
      "Created by 'cons'.")
(pair? "Predicate Function.  (pair? arg)"
       "Returns whether ARG is a pair.")
(partial-cont "Function.  (partial-cont arg1 arg2)"
    "*** No help available. ***")
(pi "Constant.  The ratio of the circumference to the diameter"
    "of a circle.  3.1415...")
(plist "Class.  (Property List)  A data structure for associating"
       "values with properties of symbols.  It can be conceptualized"
       "as a (usually sparse) two-dimensional array of symbols X"
       "properties (other symbols).  It's external representation"
       "(via 'proplist') is a list of the form (property1 value1 ..."
       "propertyn valuen) associated with symbols.")
(port "Class.  An input or output communications port."
      "Subclases: input-port, output-port (both of which are"
      "open/active), and closed-port.")
(port? "Predicate Function.  (port? arg)"
       "Returns whether ARG is a port.")
(positive? "Predicate Function.  (positive? arg)"
    "Returns whether the number ARG is positive."
    "Equivalent to (>0 arg) and (> 0 arg).")
(predicate "Class of Function.  Returns whether its argument is"
    "of the specified class.")
(print "Function.  (print arg1 [arg2])"
       "Prints ARG1 in a human-readable format to the output port"
       "ARG2 (defaults to current-output-port).  Returns nil.")
(print& "Function.  (print& arg1 [arg2])"
        "Prints ARG1 in a human-readable format to the output port"
        "ARG2 (defaults to current-output-port).  Unlike print"
        "in that unprintable objects are printed with internal"
        "format.  Returns nil.")
(print-length "Function.  (print-length arg)"
    "The (approximate) length of the printed value of ARG.")
(procedure? "Predicate Function.  (procedure? arg)"
    "Returns whether ARG is a function/closure."
    "Equivalent to (function? arg).")
(prompt "Feature.  The indicator that input is expected."
        "The top-level prompt is normally >>>, unless transcripting,"
        "in which case it is ::>")
(prompt-read "Function.  (prompt-read arg)"
    "Prints the prompt ARG and reads from the current-input-"
    "port, returning the value read."
    "Equivalent to (begin (print arg) (read)).")
(proplist "Function.  (proplist arg)"
    "Returns the property list (plist) of the symbol ARG.")
(putprop "Function.  (putprop arg1 arg2 arg3)"
         "Places ARG2 on the property list (plist) of the symbol"
         "ARG1, under the property indicated by the symbol ARG3.")
(quote "Special Form.  (quote arg)"
       "Returns the literal value of ARG." "Equivalent to 'arg.")
(quotient "Function.  (quotient arg1 arg2)"
    "Returns the integer quotient of the numbers ARG1 and ARG2."
    "Note:  (+ (* b (quotient a b)) (remainder a b)) returns a.")
(random "Function.  (random arg)"
        "Returns a pseudo-random integer or floating-point number"
        "in the range [0..ARG) of the integer or floating-point"
        "number ARG.")
(rational "Function.  (rational arg)"
    "Returns the rational number exactly equivalent to the"
    "real number ARG (up to the limit of precision stored).")
(rational? "Predicate Function.  (rational? arg)"
    "Returns whether ARG is a rational number.")
(rationalize "Function.  (rationalize arg)"
    "Returns the rational number approximately equal to"
    "the real number ARG.  Attempts to round to a 'simple'"
    "rational.")
(read "Function.  (read [arg])"
      "Reads from the input port ARG (defaults to current-"
      "input-port) and returns the expression read.")
(read-char "Function.  (read-char [arg])"
    "Reads from the input port ARG (defaults to current-"
    "input-port) and returns the single character read.")
(real-part "Function.  (real-part arg)"
    "Returns the real part of the complex number ARG.")
(real? "Predicate Function.  (real? arg)"
       "Returns whether ARG is a real number.")
(rec "Syntax.  (rec id exp)"
     "Returns EXP evaluated in an environment where ID is already"
     "bound to EXP.  Used to define recursive objects."
     "Equivalent to ((lambda (id) (set! id exp) exp) any).")
(ref "Function.  (ref arg)"
     "Creates and returns a reference cell whose value is ARG.")
(ref? "Predicate Function.  (ref? arg)"
      "Returns whether ARG is a reference cell.")
(reference "Class.  A reference cell is an object with a single value."
    "Created by 'ref'.")
(reify "Function.  (reify arg)"
       "If ARG is printable, it returns ARG."
       "Else, it returns a human-readable format of the object.")
(remainder "Function.  (remainder arg1 arg2)"
    "Returns the remainder of the numbers ARG1 and ARG2."
    "Note:  (+ (* b (quotient a b)) (remainder a b)) returns a.")
(remove-from-namespace "Function.  (remove-from-namespace arg)"
    "Removes the identifier ARG from the scheme88 namespace.")
(remprop "Function.  (remprop arg1 arg2)"
         "Returns the portion of the property list (plist) of"
         "the symbol ARG1 beginning with the property indicated"
         "by the symbol ARG2.  Removes this property and its value"
         "from the property list.")
(reset "Function.  (reset)"
       "Returns to the scheme88 top-level, scheme-top-level.  Resets"
       "current-in/out-port to standard in/output, and *trace-level*"
       "to 0.")
(reverse "Function.  (reverse arg)"
         "Returns the reverse of the list ARG.")
(reverse! "Function.  (reverse! arg)"
    "Changes ARG to be the reverse of the list ARG, and"
    "returns the modified ARG.  Equivalent to (set! arg"
    "(reverse arg)).")
(round "Function.  (round arg)"
       "Returns the number ARG rounded to the nearest integer."
       "If ARG = integer + .5, returns the nearest even integer."
       "Note:  IEEE rounding standard.")
(run "Procedure of one argument"
     "Expects arg to be a thunk."
     "Delimits the extent of control operations"
     "performed in the evaluation of the thunk."
     "Example: (add1 (run (lambda () (F (lambda (k) (k 0))))))
             = 1 added to (F (lambda (k) (k 0)))
             = 1"
     ""
     "[Also see: F and #>]")
(scheme-constants "Function.  (scheme-constants)"
    "Returns a sorted list of constant identifiers.")
(scheme-directory "Variable.  The path of the directory for scheme88"
    "source and special files.")
(scheme-globals "Function.  (scheme-globals)"
    "Returns a list of all global identifiers.")
(scheme-primitives "Function.  (scheme-primitives)"
    "Returns a sorted list of primitive function identifiers."
    "(Primitives with a fixed number of arguments.)")
(scheme-reset "Function.  (scheme-reset)"
    "Returns to the initial scheme88 top-level, global-scheme-"
    "top-level.  Resets current-in/out-port to standard in/output,"
    "and *trace-level* to 0.")
(scheme-top-level "Function.  (scheme-top-level)"
    "The scheme88 top-level read-eval-print sequence.")
(scheme88 "Version 0.1 -- May 1988" ""
    "Implemented by Matthias Felleison" "               John Greiner"
    "               Dorai Sitaram"
    "Rice University Computer Science Department" ""
    "Based on Scheme84, CS Dept. Indiana University")
(scoped? "Predicate Function.  (scoped? arg)"
    "*** No help available. ***")
(selector "Class of Function.  A function which returns a part of"
    "a list.  E.g. car, cdr, caadr, nth, last-pair, assq, etc.")
(set! "Special Form.  (set! id exp)"
      "If the identifier ID is bound in the current environment,"
      "its value is changed to the result of EXP.  Else, the"
      "global variable ID is created and bound to the result of"
      "EXP.  Returns the value of EXP.")
(set-car! "Function.  (set-car! arg1 arg2)"
    "Changes the car of the pair ARG1 to be ARG2."
    "Returns the new pair ARG1.")
(set-cdr! "Function.  (set-cdr! arg1 arg2)"
    "Changes the cdr of the pair ARG1 to be ARG2."
    "Returns the new pair ARG1.")
(set-line-length! "Function.  (set-line-length arg1 [arg2])"
    "Sets and returns the line length of the output port"
    "ARG2 (defaults to current-output-port) to be ARG1.")
(set-ref! "Function.  (set-ref! arg1 arg2)"
    "Sets the value of the reference cell ARG1 to be ARG2.")
(sin "Function.  (sin arg)"
     "Returns the sine of the number ARG (taken in radians).")
(sinh "Function.  (sinh arg)"
      "Returns the hyperbolic sine of the number ARG (taken in"
      "radians).")
(sqrt "Function.  (sqrt arg)"
      "Returns the (possibly complex) square root of the"
      "number ARG.")
(standard-input "Variable.  The input-port to be used by default.")
(standard-output
    "Variable.  The output-port to be used by default.")
(string->list "Function.  (string->list arg)"
    "Returns the list of characters comprising the string" "ARG.")
(string->number "Function.  (string->number arg1 arg2)"
    "Returns the number in the string ARG1 when evaluated"
    "with radix specified by ARG2.  Radix: 'B -> 2, 'O -> 8"
    "'D -> 10, 'X -> 16.")
(string->symbol "Function.  (string->symbol arg)"
    "Creates and returns an interned symbol with name ARG.")
(string->uninterned-symbol
    "Function.  (string->uninterned-symbol arg)"
    "Creates and returns an uninterned symbol with name ARG.")
(string-append "Function.  (string-append arg1 arg2)"
    "Returns the string that is the concatenation of the"
    "strings ARG1 and ARG2.")
(string-capitalize "Function.  (string-capitalize arg)"
    "Returns a copy of the string ARG, with all characters"
    "in lower-case, except those at the beginning of each" "word.")
(string-ci<=? "Function.  (string-ci<=? arg1 arg2)"
    "Returns whether the string ARG1 is less than or equal"
    "to the string ARG2.  (Case insensitive ASCII comparison)")
(string-ci<? "Function.  (string-ci<? arg1 arg2)"
    "Returns whether the string ARG1 is less than the"
    "string ARG2.  (Case insensitive ASCII comparison)")
(string-ci=? "Function.  (string-ci=? arg1 arg2)"
    "Returns whether the strings ARG1 and ARG2 are equal."
    "(Case insensitive)")
(string-ci>=? "Function.  (string-ci>=? arg1 arg2)"
    "Returns whether the string ARG1 is greater than or"
    "equal to the string ARG2.  (Case insensitive ASCII"
    "comparison)")
(string-ci>? "Function.  (string-ci>? arg1 arg2)"
    "Returns whether the string ARG1 is greater than the"
    "string ARG2.  (Case insensitive ASCII comparison)")
(string-copy "Function.  (string-copy arg)"
    "Returns a copy of the string ARG.")
(string-downcase "Function.  (string-downcase arg)"
    "Returns a copy of the string ARG, with all characters"
    "in lower-case.")
(string-fill! "Function.  (string-fill! arg1 arg2)"
    "Changes the string ARG1 to consist of (string-length"
    "arg1) characters ARG2.  Returns the modified ARG1.")
(string-length "Function.  (string-length arg)"
    "Returns the length of the string ARG.")
(string-ref "Function.  (string-ref arg1 arg2)"
    "Returns the ARG2-th character (0-based) of the string" "ARG1.")
(string-set! "Function.  (string-set! arg1 arg2 arg3)"
    "Sets the ARG2-th character (0-based) of the string ARG1"
    "to be the character ARG3.")
(string-upcase "Function.  (string-upcase arg)"
    "Returns a copy of the string ARG, with all characters"
    "in upper-case.")
(string<=? "Function.  (string<=? arg1 arg2)"
    "Returns whether the string ARG1 is less than or equal"
    "to the string ARG2.  (ASCII comparison)")
(string<? "Function.  (string<? arg1 arg2)"
    "Returns whether the string ARG1 is less than the string"
    "ARG2.  (ASCII comparison)")
(string=? "Function.  (string=? arg1 arg2)"
    "Returns whether the strings ARG1 and ARG2 are equal.")
(string>=? "Function.  (string>=? arg1 arg2)"
    "Returns whether the string ARG1 is greater than or"
    "equal to the string ARG2.  (ASCII comparison)")
(string>? "Function.  (string>? arg1 arg2)"
    "Returns whether the string ARG1 is greater than the"
    "string ARG2.  (ASCII comparison)")
(string? "Predicate Function.  (string? arg)"
         "Returns whether ARG is a string.")
(sub1 "Function.  (sub1 arg)" "Equivalent to (- arg 1).")
(subst "Function.  (subst arg1 arg2 arg3)"
       "Returns the list or atom that is obtained by replacing"
       "the object ARG1 for any object in the list or atom ARG3"
       "that is eq? to ARG2.")
(substring "Function.  (substring arg1 arg2 arg3)"
    "Returns a copy of the substring of string ARG1 from the"
    "ARG2-th to ARG3-th characters (0-based) inclusive.")
(swap-ref! "Function.  (swap-ref! arg1 arg2)"
    "Sets the value of the reference cell ARG1 to be ARG2."
    "Returns the old value of ARG1.")
(symbol "Class.  A lexicographic object."
        "May contain the characters: A-Z, 0-9, !#$%^&*<>-_=+~;/?."
        "without special treatment (lower-case equivalent to upper"
        "case).  The atom must be surrounded by || to allow"
        "# at the beginning (except for #f, #t, #>), :(){}[]`'\",@"
        "and spaces, and to make letters case-sensitive." ""
        "In general, a symbol must be quoted to be used as an atom,"
        "otherwise it is an identifier.")
(symbol->ascii "Function.  (symbol->ascii arg)"
    "Returns the integer ascii-code of the first character"
    "in the name of the symbol ARG.")
(symbol->string "Function.  (symbol->string arg)"
    "Returns the string of the name of the symbol ARG.")
(symbol<? "Function.  (symbol<? arg1 arg2)"
    "Returns whether the symbol ARG1 is lexicographically"
    "less than the symbol ARG2.")
(symbol>? "Function.  (symbol>? arg1 arg2)"
    "Returns whether the symbol ARG1 is lexicographically"
    "greater than the symbol ARG2.")
(symbol? "Predicate Function.  (symbol? arg)"
         "Returns whether ARG is a symbol.")
(syntactic-extension?
    "Predicate Function.  (syntactic-extension? arg)"
    "Returns whether ARG is a syntactic-extension.")
(syntactic-extensions "Function.  (syntactic-extensions)"
    "Returns a sorted list of syntactic-extensions identifiers.")
(system-functions "Function.  (system-functions)"
    "Returns a sorted list of system function identifiers."
    "(Primitives with a variable number of arguments.)")
(t "Constant.  The boolean True." "Equivalent to #t and true.")
(tan "Function.  (tan arg)"
     "Returns the tangent of the number ARG (taken in radians).")
(tanh "Function.  (tanh arg)"
      "Returns the hyperbolic tangent of the number ARG (taken"
      "in radians).")
(thaw "Function.  (thaw arg)"
      "Invokes the thunk ARG.  See also freeze."
      "Equivalent to (lambda (arg) (arg)) or (force arg).")
(throw "Syntax.  (throw arg1 arg2)"
       "*** No help available. ***")
(thunk "Class.  A thunk is a 0-ary function.")
(top-level-assigned-identifiers
    "Function.  (top-level-assigned-identifiers)"
    "Returns a sorted list of global assigned identifiers.")
(trace-lambda "Syntax.  (trace-lambda id arg1 arg2...)"
    "Returns a closure with bound identifiers ARG1 and"
    "bodies ARG2...ARGn as with lambda.  Upon application,"
    "it prints the level of tracing (in *trace-level*), ID,"
    "and the list of values bound to the identifiers in ARG1."
    "Upon the end of the application, it prints the level of"
    "tracing, ID, and the return value.")
(transcript "Feature.  Duplicates any i/o to the transcript file."
    "To indicate this feature is on, the normal prompt is"
    "replaced by ::>")
(transcript-off "Function.  (transcript-off)"
    "Quits transcripting."
    "See also (transcript-on arg).")
(transcript-on "Function.  (transcript-on arg)"
    "Initiates transcripting to the file named by the string"
    "or symbol ARG.  Creates the file if necessary.  Destroys"
    "any contents of the file."
    "See also (transcript-off).")
(transpose "Function.  (transpose arg)"
    "Returns the matrix transpose of ARG.  ARG must be a"
    "list of n lists of n elements.")
(true "Constant.  The boolean True." "Equivalent to t and #t.")
(truncate "Function.  (truncate arg)"
    "Returns the truncation, the integral part, of the number"
    "ARG.  I.e., rounds down for positive numbers, up for"
    "negative numbers.")
(try "Function.  (try arg1 arg2 arg3 arg4 arg5)"
     "*** No help available. ***")
(undeclare-constant "Function.  (undeclare-constant arg)"
    "Declares the constant identifier ARG to no longer be"
    "constant.")
(unique "Constant Function.  (unique)"
        "Returns a unique object, so that (eq? (unique)"
        "(unique)) returns false.")
(untag-special-form "Function.  (untag-special-form arg)"
    "*** No help available. ***")
(vector "Class.  A one-dimensional array of specified size."
        "Can be used to simulate n-dimensional arrays by"
        "vectors of vectors."
        "Created by 'make-vector' or 'list->vector'."
        ""
        ""
        "Function.  (vector arg1...)"
        "Returns the vector containing ARG1...ARGn."
        "Equivalent to (lambda x (list->vector x)).")
(vector->list "Function.  (vector->list arg)"
    "Returns the list with the same length and components"
    "as the vector ARG.")
(vector-fill! "Function.  (vector-fill! arg1 arg2)"
    "Changes the vector ARG1 to consist of (vector-length"
    "arg1) components of ARG2.")
(vector-length "Function.  (vector-length arg)"
    "Returns the length (number of components) of the vector" "ARG.")
(vector-ref "Function.  (vector-ref arg1 arg2)"
    "Returns the ARG2-th component (0-based) of the vector" "ARG1.")
(vector-set! "Function.  (vector-set! arg1 arg2 arg3)"
    "Sets the ARG2-th component (0-based) of the vector"
    "ARG1 to be ARG3.  Returns the modified ARG1.")
(vector? "Predicate Function.  (vector? arg)"
         "Returns whether ARG is a vector.")
(when "Syntax.  (when test exp1...)"
      "Equivalent to (if test (begin exp1...) false).")
(with-input-from-file "Function.  (with-input-from-file arg1 arg2)"
    "Temporarily rebinds standard-input to a input port"
    "associated with the file named by the string ARG1,"
    "and returns the value of thawing the thunk ARG2.")
(with-output-to-file "Function.  (with-output-to-file arg1 arg2)"
    "Temporarily rebinds standard-output to a output port"
    "associated with the file named by the string ARG1,"
    "and returns the value of thawing the thunk ARG2.")
(write-char "Function.  (write-char [arg])"
    "Writes the character ARG to the output port ARG (defaults"
    "to current-output-port).  Writes only the character, NOT"
    "the # representation of a character object." "Returns nil.")
(writeln "Function.  (writeln arg1...)"
         "Writes the objects ARG1 to ARGn to the standard-output,"
         "followed by a new-line.")
(Y "Function.  (Y arg)"
   "*** No help available. ***")
(zero? "Predicate Function.  (zero? arg)"
       "Returns whether the number ARG is 0."
       "Equivalent to (=0 arg).")
