;;; --- Copyright University of Sussex 1999. All rights reserved. ----------
;;; File:          C.all/lisp/src/exports
;;; Purpose:       Data file used by C.all/lisp/src/export.p
;;; Author:        John Williams, May 29 1987 (see revisions)
;;; Related Files: C.all/lisp/src/export.p, C.all/lisp/src/exportv.p

;;; N.B. THIS FILE IS COMPILED LINE BY LINE.
;;;         THEREFORE MULTI-LINE COMMENTS ARE NOT PERMITTED.


/* Built in functions */

@*,                              times_n,                         [0 N 1]
@+,                              plus_n,                          [0 N 1]
@-,                              minus_n,                         [1 N 1]
@/,                              divide_n,                        [1 N 1]
@/=,                             num_/=,                          [1 ? 1]
@1+,                             nonop +(% 1 %),                  [1 1 1]
@1-,                             nonop -(% 1 %),                  [1 1 1]
@<,                              compare_nums(% nonop < %),       [1 N 1]
@<=,                             compare_nums(% nonop <= %),      [1 N 1]
@=,                              compare_nums(% num_= %),         [1 N 1]
@>,                              compare_nums(% nonop > %),       [1 N 1]
@>=,                             compare_nums(% nonop >= %),      [1 N 1]
@ABORT,                          "LISP",                          "?"
@ABS,                            abs,                             []
@ACONS,                          "LISP",                          1,
@ACOS,                           arccos,                          []
@ACOSH,                          arccosh,                         []
@ADJOIN,                         "LISP",                          1
@ADJUST-ARRAY,                   "LISP",                          1
@ADJUSTABLE-ARRAY-P,             adjustable_array_p,              "boolean"
@ALPHA-CHAR-P,                   char_code <> isalphacode,        "boolean"
@ALPHANUMERICP,                  alphanumericp,                   "boolean"
@AND,                            "LISP",                          "macro"
@APPEND,                         append_n,                        [0 N 1]
@APPLY,                          cl_apply,                        [2 ? ?]
@APROPOS,                        "LISP",                          0
@APROPOS-LIST,                   apropos_list,                    [1 2 1]
@AREF,                           aref,                            [1 ? 1]
@ARITHMETIC-ERROR-OPERANDS,      "LISP",                          1
@ARITHMETIC-ERROR-OPERATION,     "LISP",                          1
@ARRAY-DIMENSION,                array_dimension,                 []
@ARRAY-DIMENSIONS,               array_dimensions,                []
@ARRAY-ELEMENT-TYPE,             array_element_type,              []
@ARRAY-HAS-FILL-POINTER-P,       is_fp_array,                     "boolean"
@ARRAY-IN-BOUNDS-P,              array_in_bounds_p,               [1 ? 1]
@ARRAY-RANK,                     array_rank,                      []
@ARRAY-ROW-MAJOR-INDEX,          array_row_major_index,           [1 ? 1]
@ARRAY-TOTAL-SIZE,               array_size,                      []
@ARRAYP,                         arrayp,                          "boolean"
@ASH,                            nonop <<,                        []
@ASIN,                           arcsin,                          []
@ASINH,                          arcsinh,                         []
@ASSERT,                         "LISP",                          "macro"
@ASSOC,                          "LISP",                          1
@ASSOC-IF,                       "LISP",                          1
@ASSOC-IF-NOT,                   "LISP",                          1
@ATAN,                           atan,                            [1 2 1]
@ATANH,                          arctanh,                         []
@ATOM,                           atom,                            "boolean"
@BIT,                            cl_bit,                          [1 ? 1]
@BIT-AND,                        bit_and,                         [2 3 1]
@BIT-ANDC1,                      bit_andc1,                       [2 3 1]
@BIT-ANDC2,                      bit_andc2,                       [2 3 1]
@BIT-EQV,                        bit_eqv,                         [2 3 1]
@BIT-IOR,                        bit_ior,                         [2 3 1]
@BIT-NAND,                       bit_nand,                        [2 3 1]
@BIT-NOR,                        bit_nor,                         [2 3 1]
@BIT-NOT,                        bit_not,                         [1 2 1]
@BIT-ORC1,                       bit_orc1,                        [2 3 1]
@BIT-ORC2,                       bit_orc2,                        [2 3 1]
@BIT-VECTOR-P,                   bitvectorp,                      "boolean"
@BIT-XOR,                        bit_xor,                         [2 3 1]
@BLOCK,                          Block,                           "special"
@BOOLE,                          boole,                           []
@BOTH-CASE-P,                    char_code <> isalphacode,        "boolean"
@BOUNDP,                         boundp,                          "boolean"
@BREAK,                          "LISP",                          1
@BROADCAST-STREAM-STREAMS,       broadcast_stream_streams,        [1 1 1]
@BUTLAST,                        butlast,                         [1 2 1]
@BYTE,                           integer_field,                   [2 2 1]
@BYTE-POSITION,                  byte_position,                   [1 1 1]
@BYTE-SIZE,                      byte_size,                       [1 1 1]
@CAAAAR,                         caar <> caar,                    [1 1 1]
@CAAADR,                         cadr <> caar,                    [1 1 1]
@CAAAR,                          caar <> car,                     [1 1 1]
@CAADAR,                         cdar <> caar,                    [1 1 1]
@CAADDR,                         cddr <> caar,                    [1 1 1]
@CAADR,                          cadr <> car,                     [1 1 1]
@CAAR,                           caar,                            [1 1 1]
@CADAAR,                         caar <> cadr,                    [1 1 1]
@CADADR,                         cadr <> cadr,                    [1 1 1]
@CADAR,                          cdar <> car,                     [1 1 1]
@CADDAR,                         cdar <> cadr,                    [1 1 1]
@CADDDR,                         cddr <> cadr,                    [1 1 1]
@CADDR,                          cddr <> car,                     [1 1 1]
@CADR,                           cadr,                            [1 1 1]
@CALL-NEXT-METHOD,               call_next_method,                [0 N ?]
@CAR,                            car,                             [1 1 1]
@CASE,                           "LISP",                          "macro"
@CATCH,                          Catch,                           "special"
@CCASE,                          "LISP",                          "macro"
@CDAAAR,                         caar <> cdar,                    [1 1 1]
@CDAADR,                         cadr <> cdar,                    [1 1 1]
@CDAAR,                          caar <> cdr,                     [1 1 1]
@CDADAR,                         cdar <> cdar,                    [1 1 1]
@CDADDR,                         cddr <> cdar,                    [1 1 1]
@CDADR,                          cadr <> cdr,                     [1 1 1]
@CDAR,                           cdar,                            [1 1 1]
@CDDAAR,                         caar <> cddr,                    [1 1 1]
@CDDADR,                         cadr <> cddr,                    [1 1 1]
@CDDAR,                          cdar <> cdr,                     [1 1 1]
@CDDDAR,                         cdar <> cddr,                    [1 1 1]
@CDDDDR,                         cddr <> cddr,                    [1 1 1]
@CDDDR,                          cddr <> cdr,                     [1 1 1]
@CDDR,                           cddr,                            [1 1 1]
@CDR,                            cdr,                             [1 1 1]
@CEILING,                        ceiling,                         [1 2 2]
@CELL-ERROR-NAME,                "LISP",                          1
@CERROR,                         "LISP",                          1
@CHAR,                           lisp_char,                       [2 2 1]
@CHAR-CODE,                      char_code,                       [1 1 1]
@CHAR-DOWNCASE,                  char_downcase,                   [1 1 1]
@CHAR-EQUAL,                     compare_CHARS(% nonop == %),     [1 N 1]
@CHAR-GREATERP,                  compare_CHARS(% nonop fi_> %),   [1 N 1]
@CHAR-INT,                       destcharacter,                   [1 1 1]
@CHAR-LESSP,                     compare_CHARS(% nonop fi_< %),   [1 N 1]
@CHAR-NAME,                      char_name,                       [1 1 1]
@CHAR-NOT-EQUAL,                 char_not_equal,                  [1 ? 1]
@CHAR-NOT-GREATERP,              compare_CHARS(% nonop fi_<= %),  [1 N 1]
@CHAR-NOT-LESSP,                 compare_CHARS(% nonop fi_>= %),  [1 N 1]
@CHAR-UPCASE,                    char_upcase,                     [1 1 1]
@CHAR/=,                         char_/=,                         [1 ? 1]
@CHAR<,                          compare_chars(% nonop fi_<  %),  [1 N 1]
@CHAR<=,                         compare_chars(% nonop fi_<= %),  [1 N 1]
@CHAR=,                          compare_chars(% nonop ==    %),  [1 N 1]
@CHAR>,                          compare_chars(% nonop fi_>  %),  [1 N 1]
@CHAR>=,                         compare_chars(% nonop fi_>= %),  [1 N 1]
@CHARACTER,                      character,                       [1 1 1]
@CHARACTERP,                     ischaracter,                     "boolean"
@CHECK-TYPE,                     "LISP",                          "macro"
@CIS,                            cis,                             []
@CLASS-OF,                       class_of,                        [1 1 1]
@CLEAR-INPUT,                    clear_input,                     [0 1 1]
@CLEAR-OUTPUT,                   clear_output,                    [0 1 1]
@CLOSE,                          "LISP",                          1
@CLRHASH,                        clrhash,                         []
@CODE-CHAR,                      conscharacter,                   [1 1 1]
@COERCE,                         coerce,                          []
@COMPILE,                        "LISP",                          1
@COMPILE-FILE,                   "LISP",                          1
@COMPILED-FUNCTION-P,            compiled_function_p,             "boolean"
@COMPILER-MACRO-FUNCTION,        compiler_macro_function,         [1 2 1]
@COMPILER-MACROEXPAND,           "LISP",                          2
@COMPILER-MACROEXPAND-1,         compiler_macroexpand1,           [1 2 2]
@COMPLEMENT,                     complement,                      [1 1 1]
@COMPLEX,                        complex,                         [1 2 1]
@COMPLEXP,                       iscomplex,                       "boolean"
@COMPUTE-APPLICABLE-METHODS,     compute_applicable_methods,      [2 2 1]
@COMPUTE-RESTARTS,               "LISP",                          1
@CONCATENATE,                    concatenate,                     [1 ? 1]
@CONCATENATED-STREAM-STREAMS,    conc_stream_streams,             [1 1 1]
@COND,                           "LISP",                          "macro"
@CONJUGATE,                      conjugate,                       [1 1 1]
@CONS,                           conspair,                        [2 2 1]
@CONSP,                          ispair,                          "boolean"
@CONSTANTLY,                     constantly,                      [1 1 1]
@CONSTANTP,                      constantp,                       "boolean"
@CONTINUE,                       "LISP",                          "?"
@COPY-ALIST,                     copy_alist,                      [1 1 1]
@COPY-LIST,                      copy_list,                       [1 1 1]
@COPY-PPRINT-DISPATCH,           copy_pprint_dispatch,            [0 1 1]
@COPY-READTABLE,                 copy_readtable,                  [0 2 1]
@COPY-SEQ,                       copy_seq,                        [1 1 1]
@COPY-SYMBOL,                    copy_symbol,                     [1 2 1]
@COPY-TREE,                      copy_tree,                       [1 1 1]
@COS,                            cos,                             []
@COSH,                           cosh,                            []
@COUNT,                          "LISP",                          1
@COUNT-IF,                       "LISP",                          1
@COUNT-IF-NOT,                   "LISP",                          1
@CTYPECASE,                      "LISP",                          "macro"
@DECF,                           "LISP",                          "macro"
@DECLAIM,                        "LISP",                          "macro"
@DECLARE,                        Declare,                         "special"
@DECODE-FLOAT,                   decode_float,                    [1 1 3]
@DECODE-UNIVERSAL-TIME,          decode_universal_time,           [1 2 9]
@DEFCONSTANT,                    "LISP",                          "macro"
@DEFINE-COMPILER-MACRO,          "LISP",                          "macro"
@DEFINE-CONDITION,               "LISP",                          "macro"
@DEFINE-MODIFY-MACRO,            "LISP",                          "macro"
@DEFINE-SETF-METHOD,             "LISP",                          "macro"
@DEFMACRO,                       "LISP",                          "macro"
@DEFPACKAGE,                     "LISP",                          "macro"
@DEFPARAMETER,                   "LISP",                          "macro"
@DEFSETF,                        "LISP",                          "macro"
@DEFSTRUCT,                      "LISP",                          "macro"
@DEFTYPE,                        "LISP",                          "macro"
@DEFUN,                          "LISP",                          "macro"
@DEFVAR,                         "LISP",                          "macro"
@DELETE,                         "LISP",                          1
@DELETE-DUPLICATES,              "LISP",                          1
@DELETE-FILE,                    "LISP",                          1
@DELETE-IF,                      "LISP",                          1
@DELETE-IF-NOT,                  "LISP",                          1
@DELETE-PACKAGE,                 delete_package,                  "boolean"
@DENOMINATOR,                    denominator,                     []
@DEPOSIT-FIELD,                  deposit_field,                   []
@DESCRIBE,                       describe,                        [1 1 0]
@DESTRUCTURING-BIND,             "LISP",                          "macro"
@DIGIT-CHAR,                     digit_char,                      [1 2 1]
@DIGIT-CHAR-P,                   digit_char_p,                    [1 2 1]
@DIRECTORY,                      directory,                       [0 ? 1]
@DIRECTORY-NAMESTRING,           directory_namestring,            []
@DISASSEMBLE,                    disassemble,                     [1 1 0]
@DO*,                            "LISP",                          "macro"
@DO,                             "LISP",                          "macro"
@DO-ALL-SYMBOLS,                 "LISP",                          "macro"
@DO-EXTERNAL-SYMBOLS,            "LISP",                          "macro"
@DO-SYMBOLS,                     "LISP",                          "macro"
@DOCUMENTATION,                  "LISP",                          1
@DOLIST,                         "LISP",                          "macro"
@DOTIMES,                        "LISP",                          "macro"
@DPB,                            dpb,                             []
@DRIBBLE,                        dribble,                         [0 1 0]
@ECASE,                          "LISP",                          "macro"
@ECHO-STREAM-INPUT-STREAM,       echo_stream_input_stream,        [1 1 1]
@ECHO-STREAM-OUTPUT-STREAM,      echo_stream_output_stream,       [1 1 1]
@ED,                             ed,                              [0 1 0]
@EIGHTH,                         Nth(% 7 %),                      [1 1 1]
@ELT,                            elt,                             []
@ENCODE-UNIVERSAL-TIME,          encode_universal_time,           [6 7 1]
@ENDP,                           endp,                            "boolean"
@ENOUGH-NAMESTRING,              enough_namestring,               [1 2 1]
@EQ,                             nonop ==,                        "boolean"
@EQL,                            nonop ==#,                       "boolean"
@EQUAL,                          equal,                           "boolean"
@EQUALP,                         equalp,                          "boolean"
@ERROR,                          "LISP",                          1
@ETYPECASE,                      "LISP",                          "macro"
@EVAL,                           eval,                            [1 1 ?]
@EVAL-WHEN,                      Eval_when,                       "special"
@EVENP,                          nonop &&=_0(% 1 %),              "boolean"
@EVERY,                          "LISP",                          1
@EXP,                            exp,                             []
@EXPORT,                         "LISP",                          1
@EXPT,                           nonop **,                        []
@FBOUNDP,                        fboundp,                         "boolean"
@FCEILING,                       fceiling,                        [1 2 2]
@FDEFINITION,                    fdefinition,                     [1 1 1]
@FFLOOR,                         ffloor,                          [1 2 2]
@FIFTH,                          Nth(% 4 %),                      [1 1 1]
@FILE-AUTHOR,                    file_author,                     []
@FILE-ERROR-PATHNAME,            "LISP",                          1
@FILE-LENGTH,                    file_length,                     []
@FILE-NAMESTRING,                file_namestring,                 []
@FILE-POSITION,                  file_position,                   [1 2 1]
@FILE-STRING-LENGTH,             file_string_length,              [2 2 1]
@FILE-WRITE-DATE,                file_write_date,                 []
@FILL,                           "LISP",                          1
@FILL-POINTER,                   fill_pointer,                    []
@FIND,                           "LISP",                          1
@FIND-ALL-SYMBOLS,               "LISP",                          1
@FIND-CLASS,                     find_class,                      [1 3 1]
@FIND-IF,                        "LISP",                          1
@FIND-IF-NOT,                    "LISP",                          1
@FIND-PACKAGE,                   find_package,                    "boolean"
@FIND-RESTART,                   "LISP",                          1
@FIND-SYMBOL,                    find_symbol,                     [1 2 2]
@FINISH-OUTPUT,                  finish_output,                   [0 1 1]
@FIRST,                          car,                             [1 1 1]
@FLET,                           Flet,                            "special"
@FLOAT,                          float,                           [1 2]
@FLOAT-DIGITS,                   float_digits,                    []
@FLOAT-PRECISION,                float_precision,                 []
@FLOAT-RADIX,                    float_radix,                     []
@FLOAT-SIGN,                     float_sign,                      [1 2 1]
@FLOATP,                         isdecimal,                       "boolean"
@FLOOR,                          floor,                           [1 2 2]
@FMAKUNBOUND,                    fmakunbound,                     []
@FORCE-OUTPUT,                   force_output,                    [0 1 1]
@FORMAT,                         format,                          [2 ? 1]
@FORMATTER,                      "LISP",                          1
@FOURTH,                         Nth(% 3 %),                      [1 1 1]
@FRESH-LINE,                     fresh_line,                      [0 1 1]
@FROUND,                         fround,                          [1 2 2]
@FTRUNCATE,                      ftruncate,                       [1 2 2]
@FUNCALL,                        funcall,                         [1 ? ?]
@FUNCTION,                       Function,                        "special"
@FUNCTION-LAMBDA-EXPRESSION,     function_lambda_expression,      [1 1 3]
@FUNCTIONP,                      functionp,                       "boolean"
@GCD,                            gcd_n,                           [0 N 1]
@GENSYM,                         gensymbol,                       [0 1 1]
@GENTEMP,                        gentemp,                         [0 2 1]
@GET,                            get,                             [2 3 1]
@GET-DECODED-TIME,               get_decoded_time,                [0 0 9]
@GET-DISPATCH-MACRO-CHARACTER,   get_dmac_char,                   [2 3 1]
@GET-INTERNAL-REAL-TIME,         get_internal_real_time,          [0 0 1]
@GET-INTERNAL-RUN-TIME,          get_internal_run_time,           [0 0 1]
@GET-MACRO-CHARACTER,            get_macro_char,                  [1 2 2]
@GET-OUTPUT-STREAM-STRING,       get_stringout_string,            []
@GET-PROPERTIES,                 get_properties,                  []
@GET-SETF-METHOD,                get_setf_method(% false %),      [1 2 5]
@GET-SETF-METHOD-MULTIPLE-VALUE, get_setf_method(% true %),       [1 2 5]
@GET-UNIVERSAL-TIME,             get_universal_time,              []
@GETF,                           getf,                            [2 3 1]
@GETHASH,                        gethash,                         [2 3 2]
@GO,                             Go,                              "special"
@GRAPHIC-CHAR-P,                 graphic_char_p,                  "boolean"
@HANDLER-BIND,                   "LISP",                          "macro"
@HANDLER-CASE,                   "LISP",                          "macro"
@HASH-TABLE-COUNT,               hash_table_count,                [1 1 1]
@HASH-TABLE-P,                   isproperty,                      "boolean"
@HASH-TABLE-REHASH-SIZE,         hash_table_rehash_size,          [1 1 1]
@HASH-TABLE-REHASH-THRESHOLD,    hash_table_rehash_threshold,     [1 1 1]
@HASH-TABLE-SIZE,                hash_table_size,                 [1 1 1]
@HASH-TABLE-TEST,                hash_table_test,                 [1 1 1]
@HOST-NAMESTRING,                host_namestring,                 []
@IDENTITY,                       identfn,                         [1 1 1]
@IF,                             If,                              "special"
@IGNORE-ERRORS,                  "LISP",                          "macro"
@IMAGPART,                       imagpart,                        [1 1 1]
@IMPORT,                         "LISP",                          1
@IN-PACKAGE,                     "LISP",                          "macro"
@INCF,                           "LISP",                          "macro"
@INPUT-STREAM-P,                 is_input_stream,                 "boolean"
@INSPECT,                        lispinspect,                     [1 1 0]
@INTEGER-DECODE-FLOAT,           integer_decode_float,            [1 1 3]
@INTEGER-LENGTH,                 integer_length,                  [1 1 1]
@INTEGERP,                       isintegral,                      "boolean"
@INTERACTIVE-STREAM-P,           is_interactive_stream,           "boolean"
@INTERN,                         intern,                          [1 2 2]
@INTERSECTION,                   "LISP",                          1
@INVOKE-DEBUGGER,                "LISP",                          0
@INVOKE-RESTART,                 "LISP",                          "?"
@INVOKE-RESTART-INTERACTIVELY,   "LISP",                          "?"
@ISQRT,                          "LISP",                          [1 1 1]
@KEYWORDP,                       keywordp,                        "boolean"
@LABELS,                         Labels,                          "special"
@LAST,                           lastcons,                        [1 2 1]
@LCM,                            lcm_n,                           [0 N 1]
@LDB,                            ldb,                             []
@LDB-TEST,                       ldb_test,                        []
@LDIFF,                          "LISP",                          1
@LENGTH,                         seq_length,                      []
@LET*,                           Let_*,                           "special"
@LET,                            Let,                             "special"
@LISP-IMPLEMENTATION-TYPE,       "LISP",                          1
@LISP-IMPLEMENTATION-VERSION,    "LISP",                          1
@LIST*,                          list_*,                          [1 N 1]
@LIST,                           conslist,                        [0 N 1]
@LIST-ALL-PACKAGES,              list_all_packages,               []
@LIST-LENGTH,                    "LISP",                          1
@LISTEN,                         listen <> lisp_true,             [0 1 1]
@LISTP,                          listp,                           "boolean"
@LOAD,                           "LISP",                          1
@LOAD-LOGICAL-PATHNAME-TRANSLATIONS, load_logical_pathname_translations, []
@LOAD-TIME-VALUE,                Load_time_value,                 "special"
@LOCALLY,                        Locally,                         "special"
@LOG,                            logN,                            [1 2 1]
@LOGAND,                         "LISP",                          [0 ? 1]
@LOGANDC1,                       boole_op_table(boole_andc1),     []
@LOGANDC2,                       boole_op_table(boole_andc2),     []
@LOGBITP,                        logbitp,                         "boolean"
@LOGCOUNT,                       integer_bitcount,                []
@LOGEQV,                         "LISP",                          [0 ? 1]
@LOGICAL-PATHNAME,               logical_pathname,                [1 1 1]
@LOGICAL-PATHNAME-TRANSLATIONS,  logical_pathname_translations,   [1 1 1]
@LOGIOR,                         "LISP",                          [0 ? 1]
@LOGNAND,                        boole_op_table(boole_nand),      []
@LOGNOR,                         boole_op_table(boole_nor),       []
@LOGNOT,                         nonop ~~,                        []
@LOGORC1,                        boole_op_table(boole_orc1),      []
@LOGORC2,                        boole_op_table(boole_orc2),      []
@LOGTEST,                        nonop &&/=_0,                    "boolean"
@LOGXOR,                         "LISP",                          [0 ? 1]
@LONG-SITE-NAME,                 lisphost(% "fullsitename" %),    [0 0 1]
@LOOP,                           "LISP",                          "macro"
@LOOP-FINISH,                    "LISP",                          "macro"
@LOWER-CASE-P,                   char_code <> islowercode,        "boolean"
@MACHINE-INSTANCE,               sys_host_name,                   "boolean"
@MACHINE-TYPE,                   lisphost(% "machinetype" %),     [0 0 1]
@MACHINE-VERSION,                lisphost(% "machine" %),         [0 0 1]
@MACRO-FUNCTION,                 macro_function,                  [1 2 1]
@MACROEXPAND,                    "LISP",                          2
@MACROEXPAND-1,                  macroexpand1,                    [1 2 2]
@MACROLET,                       Macrolet,                        "special"
@MAKE-ARRAY,                     "LISP",                          1
@MAKE-BROADCAST-STREAM,          make_broadcast_stream,           [0 ? 1]
@MAKE-CONCATENATED-STREAM,       make_conc_stream,                [0 ? 1]
@MAKE-CONDITION,                 "LISP",                          1
@MAKE-DISPATCH-MACRO-CHARACTER,  make_dmac_char,                  [1 3 1]
@MAKE-ECHO-STREAM,               make_echo_stream,                []
@MAKE-HASH-TABLE,                "LISP",                          1
@MAKE-LIST,                      "LISP",                          1
@MAKE-LOAD-FORM,                 "LISP",                          2
@MAKE-LOAD-FORM-SAVING-SLOTS,    make_load_form_saving_slots,     [1 2 2]
@MAKE-PACKAGE,                   "LISP",                          1
@MAKE-PATHNAME,                  "LISP",                          1
@MAKE-RANDOM-STATE,              new_random_state,                [0 1 1]
@MAKE-SEQUENCE,                  "LISP",                          1
@MAKE-STRING,                    "LISP",                          1
@MAKE-STRING-INPUT-STREAM,       make_stringin_stream,            [1 3 1]
@MAKE-STRING-OUTPUT-STREAM,      "LISP",                          1
@MAKE-SYMBOL,                    make_symbol,                     []
@MAKE-SYNONYM-STREAM,            make_synonym_stream,             []
@MAKE-TWO-WAY-STREAM,            make_io_stream,                  []
@MAKUNBOUND,                     makunbound,                      []
@MAP,                            "LISP",                          1
@MAP-INTO,                       "LISP",                          1
@MAPC,                           "LISP",                          1
@MAPCAN,                         "LISP",                          1
@MAPCAR,                         "LISP",                          1
@MAPCON,                         "LISP",                          1
@MAPHASH,                        maphash,                         []
@MAPL,                           "LISP",                          1
@MAPLIST,                        "LISP",                          1
@MASK-FIELD,                     mask_field,                      []
@MAX,                            max_n,                           [1 N 1]
@MEMBER,                         "LISP",                          1
@MEMBER-IF,                      "LISP",                          1
@MEMBER-IF-NOT,                  "LISP",                          1
@MERGE,                          "LISP",                          1
@MERGE-PATHNAMES,                merge_pathnames,                 [1 3 1]
@MIN,                            min_n,                           [1 N 1]
@MINUSP,                         nonop <(% 0 %),                  "boolean"
@MISMATCH,                       "LISP",                          1
@MOD,                            nonop mod,                       []
@MUFFLE-WARNING,                 "LISP",                          "?"
@MULTIPLE-VALUE-BIND,            "LISP",                          "macro"
@MULTIPLE-VALUE-CALL,            Multiple_value_call,             "special"
@MULTIPLE-VALUE-LIST,            "LISP",                          "macro"
@MULTIPLE-VALUE-PROG1,           Multiple_value_prog1,            "special"
@MULTIPLE-VALUE-SETQ,            "LISP",                          "macro"
@NAME-CHAR,                      name_char,                       []
@NAMESTRING,                     namestring,                      []
@NBUTLAST,                       nbutlast,                        [1 2 1]
@NCONC,                          nconc_n,                         [0 N 1]
@NINTERSECTION,                  "LISP",                          1
@NINTH,                          Nth(% 8 %),                      [1 1 1]
@NOT,                            nonop ==_nil,                    "boolean"
@NOTANY,                         "LISP",                          1
@NOTEVERY,                       "LISP",                          1
@NRECONC,                        "LISP",                          1
@NREVERSE,                       nreverse,                        []
@NSET-DIFFERENCE,                "LISP",                          1
@NSET-EXCLUSIVE-OR,              "LISP",                          1
@NSTRING-CAPITALIZE,             "LISP",                          1
@NSTRING-DOWNCASE,               "LISP",                          1
@NSTRING-UPCASE,                 "LISP",                          1
@NSUBLIS,                        "LISP",                          1
@NSUBST,                         "LISP",                          1
@NSUBST-IF,                      "LISP",                          1
@NSUBST-IF-NOT,                  "LISP",                          1
@NSUBSTITUTE,                    "LISP",                          1
@NSUBSTITUTE-IF,                 "LISP",                          1
@NSUBSTITUTE-IF-NOT,             "LISP",                          1
@NTH,                            nth,                             [2 2 1]
@NTH-VALUE,                      "LISP",                          "macro"
@NTHCDR,                         nthcdr,                          [2 2 1]
@NULL,                           nonop ==_nil,                    "boolean"
@NUMBERP,                        isnumber,                        "boolean"
@NUMERATOR,                      numerator,                       []
@NUNION,                         "LISP",                          1
@ODDP,                           nonop &&/=_0(% 1 %),             "boolean"
@OPEN,                           "LISP",                          1
@OPEN-STREAM-P,                  is_open_stream,                  "boolean"
@OR,                             "LISP",                          "macro"
@OUTPUT-STREAM-P,                is_output_stream,                "boolean"
@PACKAGE-ERROR-PACKAGE,          "LISP",                          1
@PACKAGE-NAME,                   package_name,                    []
@PACKAGE-NICKNAMES,              package_nicknames,               []
@PACKAGE-SHADOWING-SYMBOLS,      package_shadowing_symbols,       []
@PACKAGE-USE-LIST,               package_use_list,                []
@PACKAGE-USED-BY-LIST,           package_used_by_list,            []
@PACKAGEP,                       ispackage,                       "boolean"
@PAIRLIS,                        "LISP",                          1
@PARSE-INTEGER,                  "LISP",                          2
@PARSE-NAMESTRING,               "LISP",                          2
@PATHNAME,                       pathname,                        []
@PATHNAME-DEVICE,                "LISP",                          1
@PATHNAME-DIRECTORY,             "LISP",                          1
@PATHNAME-HOST,                  "LISP",                          1
@PATHNAME-MATCH-P,               pathname_match_p,                "boolean"
@PATHNAME-NAME,                  "LISP",                          1
@PATHNAME-TYPE,                  "LISP",                          1
@PATHNAME-VERSION,               "LISP",                          1
@PATHNAMEP,                      ispathname,                      "boolean"
@PEEK-CHAR,                      peek_char,                       [0 5 1]
@PHASE,                          phase,                           []
@PLUSP,                          nonop >(% 0 %),                  "boolean"
@POP,                            "LISP",                          "macro"
@POSITION,                       "LISP",                          1
@POSITION-IF,                    "LISP",                          1
@POSITION-IF-NOT,                "LISP",                          1
@PPRINT,                         "LISP",                          0
@PPRINT-DISPATCH,                "LISP",                          2
@PPRINT-EXIT-IF-LIST-EXHAUSTED,  "LISP",                          1
@PPRINT-FILL,                    "LISP",                          0
@PPRINT-INDENT,                  "LISP",                          1
@PPRINT-LINEAR,                  "LISP",                          0
@PPRINT-LOGICAL-BLOCK,           "LISP",                          1
@PPRINT-NEWLINE,                 "LISP",                          1
@PPRINT-POP,                     "LISP",                          1
@PPRINT-TAB,                     "LISP",                          1
@PPRINT-TABULAR,                 "LISP",                          0
@PRIN1,                          "LISP",                          1
@PRIN1-TO-STRING,                "LISP",                          1
@PRINC,                          "LISP",                          1
@PRINC-TO-STRING,                "LISP",                          1
@PRINT,                          "LISP",                          1
@PRINT-UNREADABLE-OBJECT,        "LISP",                          "macro"
@PROBE-FILE,                     probe_file,                      "boolean"
@PROCLAIM,                       proclaim,                        [1 1 0]
@PROG*,                          "LISP",                          "macro"
@PROG,                           "LISP",                          "macro"
@PROG1,                          "LISP",                          "macro"
@PROG2,                          "LISP",                          "macro"
@PROGN,                          Progn,                           "special"
@PROGV,                          Progv,                           "special"
@PROVIDE,                        provide,                         []
@PSETF,                          "LISP",                          "macro"
@PSETQ,                          "LISP",                          "macro"
@PUSH,                           "LISP",                          "macro"
@PUSHNEW,                        "LISP",                          "macro"
@QUOTE,                          Quote,                           "special"
@RANDOM,                         apply_random_state,              [1 2 1]
@RANDOM-STATE-P,                 israndom_state,                  "boolean"
@RASSOC,                         "LISP",                          1
@RASSOC-IF,                      "LISP",                          1
@RASSOC-IF-NOT,                  "LISP",                          1
@RATIONAL,                       rational,                        []
@RATIONALIZE,                    rational(% %),                   []
@RATIONALP,                      isrational,                      "boolean"
@READ,                           read,                            [0 4 1]
@READ-BYTE,                      read_byte,                       [1 3 1]
@READ-CHAR,                      read_char,                       [0 4 1]
@READ-CHAR-NO-HANG,              read_char_no_hang,               [0 4 1]
@READ-DELIMITED-LIST,            read_delimited_list,             [1 3 1]
@READ-FROM-STRING,               "LISP",                          2
@READ-LINE,                      read_line,                       [0 4 2]
@READ-PRESERVING-WHITESPACE,     read_keeping_white,              [0 4 1]
@READTABLE-CASE,                 readtable_case,                  [1 1 1]
@READTABLEP,                     isreadtable,                     "boolean"
@REALP,                          isreal,                          "boolean"
@REALPART,                       realpart,                        []
@REDUCE,                         "LISP",                          1
@REM,                            nonop rem,                       []
@REMF,                           "LISP",                          "macro"
@REMHASH,                        remhash,                         "boolean"
@REMOVE,                         "LISP",                          1
@REMOVE-DUPLICATES,              "LISP",                          1
@REMOVE-IF,                      "LISP",                          1
@REMOVE-IF-NOT,                  "LISP",                          1
@REMPROP,                        remprop,                         []
@RENAME-FILE,                    "LISP",                          3
@RENAME-PACKAGE,                 "LISP",                          0
@REPLACE,                        "LISP",                          1
@REQUIRE,                        require,                         [1 2 1]
@REST,                           cdr,                             [1 1 1]
@RESTART-BIND,                   "LISP",                          "macro"
@RESTART-CASE,                   "LISP",                          "macro"
@RESTART-NAME,                   "LISP",                          1
@RETURN,                         "LISP",                          "macro"
@RETURN-FROM,                    Return,                          "special"
@REVAPPEND,                      "LISP",                          1
@REVERSE,                        reverse,                         []
@ROOM,                           room,                            [0 1 0]
@ROTATEF,                        "LISP",                          "macro"
@ROUND,                          round2,                          [1 2 2]
@ROW-MAJOR-AREF,                 row_major_aref,                  [2 2 1]
@RPLACA,                         rplaca,                          [2 2 1]
@RPLACD,                         rplacd,                          [2 2 1]
@SBIT,                           cl_bit,                          [1 ? 1]
@SCALE-FLOAT,                    float_scale,                     []
@SCHAR,                          schar,                           []
@SEARCH,                         "LISP",                          1
@SECOND,                         cadr,                            [1 1 1]
@SET,                            set,                             [2 2 1]
@SET-DIFFERENCE,                 "LISP",                          1
@SET-DISPATCH-MACRO-CHARACTER,   set_dmac_char,                   [3 4 1]
@SET-EXCLUSIVE-OR,               "LISP",                          1
@SET-MACRO-CHARACTER,            set_macro_char,                  [2 4 1]
@SET-PPRINT-DISPATCH,            set_pprint_dispatch,             [2 4 1]
@SET-SYNTAX-FROM-CHAR,           set_syntax_from_char,            [2 4 1]
@SETF,                           "LISP",                          "macro"
@SETQ,                           Setq,                            "special"
@SEVENTH,                        Nth(% 6 %),                      [1 1 1]
@SHADOW,                         "LISP",                          1
@SHADOWING-IMPORT,               "LISP",                          1
@SHIFTF,                         "LISP",                          "macro"
@SHORT-SITE-NAME,                lisphost(% "site" %),            [0 0 1]
@SIGNAL,                         "LISP",                          "?"
@SIGNUM,                         sign,                            [1 1 1]
@SIMPLE-BIT-VECTOR-P,            isbitvector,                     "boolean"
@SIMPLE-CONDITION-FORMAT-ARGUMENTS, "LISP",                       1
@SIMPLE-CONDITION-FORMAT-CONTROL, "LISP",                         1
@SIMPLE-STRING-P,                isstring,                        "boolean"
@SIMPLE-VECTOR-P,                isvector,                        "boolean"
@SIN,                            sin,                             [1 1 1]
@SINH,                           sinh,                            [1 1 1]
@SIXTH,                          Nth(% 5 %),                      [1 1 1]
@SLEEP,                          sleep,                           [1 1 1]
@SLOT-BOUNDP,                    slot_boundp,                     "boolean"
@SLOT-EXISTS-P,                  slot_exists_p,                   "boolean"
@SLOT-MAKUNBOUND,                slot_makunbound,                 [2 2 1]
@SLOT-VALUE,                     slot_value,                      [2 2 1]
@SOFTWARE-TYPE,                  lisphost(% "os" %),              [0 0 1]
@SOFTWARE-VERSION,               lisphost(% "osversion" %),       [0 0 1]
@SOME,                           "LISP",                          1
@SORT,                           "LISP",                          1
@SPECIAL-OPERATOR-P,             special_form_p,                  "boolean"
@SQRT,                           sqrt,                            [1 1 1]
@STABLE-SORT,                    "LISP",                          1
@STANDARD-CHAR-P,                standard_char_p,                 "boolean"
@STEP,                           "LISP",                          "macro"
@STORE-VALUE,                    "LISP",                          "?"
@STREAM-ELEMENT-TYPE,            stream_element_type,             []
@STREAM-ERROR-STREAM,            "LISP",                          1
@STREAM-EXTERNAL-FORMAT,         "LISP",                          1
@STREAMP,                        isstream,                        "boolean"
@STRING,                         coerce_string,                   []
@STRING-CAPITALIZE,              "LISP",                          1
@STRING-CHAR-P,                  string_char_p,                   "boolean"
@STRING-DOWNCASE,                "LISP",                          1
@STRING-EQUAL,                   "LISP",                          1
@STRING-GREATERP,                "LISP",                          1
@STRING-LEFT-TRIM,               string_left_trim,                []
@STRING-LESSP,                   "LISP",                          1
@STRING-NOT-EQUAL,               "LISP",                          1
@STRING-NOT-GREATERP,            "LISP",                          1
@STRING-NOT-LESSP,               "LISP",                          1
@STRING-RIGHT-TRIM,              string_right_trim,               []
@STRING-TRIM,                    string_trim,                     []
@STRING-UPCASE,                  "LISP",                          1
@STRING/=,                       "LISP",                          1
@STRING<,                        "LISP",                          1
@STRING<=,                       "LISP",                          1
@STRING=,                        "LISP",                          1
@STRING>,                        "LISP",                          1
@STRING>=,                       "LISP",                          1
@STRINGP,                        stringp,                         "boolean"
@SUBLIS,                         "LISP",                          1
@SUBSEQ,                         subseq,                          [2 3 1]
@SUBSETP,                        "LISP",                          1
@SUBST,                          "LISP",                          1
@SUBST-IF,                       "LISP",                          1
@SUBST-IF-NOT,                   "LISP",                          1
@SUBSTITUTE,                     "LISP",                          1
@SUBSTITUTE-IF,                  "LISP",                          1
@SUBSTITUTE-IF-NOT,              "LISP",                          1
@SUBTYPEP,                       subtypep,                        [2 2 2]
@SVREF,                          svref,                           []
@SXHASH,                         sxhash,                          []
@SYMBOL-FUNCTION,                symbol_function,                 []
@SYMBOL-MACROLET,                Symbol_macrolet,                 "special"
@SYMBOL-NAME,                    symbol_name,                     []
@SYMBOL-PACKAGE,                 symbol_package,                  []
@SYMBOL-PLIST,                   symbol_plist,                    []
@SYMBOL-VALUE,                   symbol_value,                    []
@SYMBOLP,                        issymbol,                        "boolean"
@SYNONYM-STREAM-SYMBOL,          synonym_stream_symbol,           [1 1 1]
@TAGBODY,                        Tagbody,                         "special"
@TAILP,                          "LISP",                          1
@TAN,                            tan,                             []
@TANH,                           tanh,                            []
@TENTH,                          Nth(% 9 %),                      [1 1 1]
@TERPRI,                         "LISP",                          1
@THE,                            The,                             "special"
@THIRD,                          Nth(% 2 %),                      [1 1 1]
@THROW,                          Throw,                           "special"
@TIME,                           "LISP",                          "macro"
@TRACE,                          "LISP",                          "macro"
@TRANSLATE-LOGICAL-PATHNAME,     translate_logical_pathname,      [1 ? 1]
@TRANSLATE-PATHNAME,             "LISP",                          1
@TREE-EQUAL,                     "LISP",                          1
@TRUENAME,                       truename,                        []
@TRUNCATE,                       truncate,                        [1 2 2]
@TWO-WAY-STREAM-INPUT-STREAM,    io_stream_input_stream,          [1 1 1]
@TWO-WAY-STREAM-OUTPUT-STREAM,   io_stream_output_stream,         [1 1 1]
@TYPE-ERROR-DATUM,               "LISP",                          1
@TYPE-ERROR-EXPECTED-TYPE,       "LISP",                          1
@TYPE-OF,                        "LISP",                          1
@TYPECASE,                       "LISP",                          "macro"
@TYPEP,                          typep,                           "boolean"
@UNEXPORT,                       "LISP",                          1
@UNINTERN,                       unintern,                        [1 2 1]
@UNION,                          "LISP",                          1
@UNLESS,                         "LISP",                          "macro"
@UNREAD-CHAR,                    unread_char,                     [1 2 1]
@UNTRACE,                        "LISP",                          "macro"
@UNUSE-PACKAGE,                  "LISP",                          1
@UNWIND-PROTECT,                 Unwind_protect,                  "special"
@UPGRADED-ARRAY-ELEMENT-TYPE,    upgraded_array_element_type,     [1 1 1]
@UPGRADED-COMPLEX-PART-TYPE,     upgraded_complex_part_type,      [1 1 1]
@UPPER-CASE-P,                   char_code <> isuppercode,        "boolean"
@USE-PACKAGE,                    "LISP",                          1
@USE-VALUE,                      "LISP",                          "?"
@USER-HOMEDIR-PATHNAME,          user_homedir_pathname,           [0 1 1]
@VALUES,                         erase,                           [0 N ?]
@VALUES-LIST,                    values_list,                     [1 1 ?]
@VECTOR,                         consvector,                      [0 N 1]
@VECTOR-POP,                     vector_pop,                      []
@VECTOR-PUSH,                    vector_push,                     []
@VECTOR-PUSH-EXTEND,             vector_push_extend,              [2 3 1]
@VECTORP,                        vectorp,                         "boolean"
@WARN,                           "LISP",                          1
@WHEN,                           "LISP",                          "macro"
@WILD-PATHNAME-P,                wild_pathname_p,                 [1 2 1]
@WITH-COMPILATION-UNIT,          "LISP",                          "macro"
@WITH-CONDITION-RESTARTS,        "LISP",                          "macro"
@WITH-HASH-TABLE-ITERATOR,       "LISP",                          "macro"
@WITH-INPUT-FROM-STRING,         "LISP",                          "macro"
@WITH-OPEN-FILE,                 "LISP",                          "macro"
@WITH-OPEN-STREAM,               "LISP",                          "macro"
@WITH-OUTPUT-TO-STRING,          "LISP",                          "macro"
@WITH-PACKAGE-ITERATOR,          "LISP",                          "macro"
@WITH-SIMPLE-RESTART,            "LISP",                          "macro"
@WITH-STANDARD-IO-SYNTAX,        "LISP",                          "macro"
@WRITE,                          "LISP",                          1
@WRITE-BYTE,                     write_byte,                      []
@WRITE-CHAR,                     write_char,                      [1 2 1]
@WRITE-LINE,                     "LISP",                          1
@WRITE-STRING,                   "LISP",                          1
@WRITE-TO-STRING,                "LISP",                          1
@Y-OR-N-P,                       "LISP",                          1
@YES-OR-NO-P,                    "LISP",                          1
@ZEROP,                          "LISP",                          1


/* Procedures exported to SYSTEM package */

@SYS:&MULTIPLE-VALUE-BIND,       Multiple_value_bind,             "special"
@SYS:&MULTIPLE-VALUE-LIST,       Multiple_value_list,             "special"
@SYS:&MULTIPLE-VALUE-SETQ,       Multiple_value_setq,             "special"
@SYS:&NTH-VALUE,                 Nth_value,                       "special"
@SYS:&PSETQ,                     Psetq,                           "special"
@SYS:=,                          sys_=,                           "boolean"
@SYS:ADDRESS-OF,                 address_of,                      [1 1 1]
@SYS:ALLOCATE-STRUCTURE,         allocate_structure,              [2 2 1]
@SYS:ALWAYS-T,                   erase1_true,                     [1 1 1]
@SYS:APPPACKAGE,                 apppackage,                      [4 4 0]
@SYS:BREAK-OK,                   break_ok,                        "boolean"
@SYS:CLASS-OF-INSTANCE,          i_class_instance,                [1 1 1]
@SYS:DEFAULT-PRINT-OBJECT,       default_print_object,            [2 2 1]
@SYS:DEFINE-CLASS,               clos_define_class,               [7 7 1]
@SYS:DEFINE-METHOD,              define_method,                   [6 6 1]
@SYS:DEFINE-STRUCT,              define_struct,                   [5 5 1]
@SYS:EQ-MEMBER,                  fast_lmember,                    "boolean"
@SYS:EQL-ASSOC,                  eql_assoc,                       "boolean"
@SYS:EQL-MEMBER,                 eql_member,                      "boolean"
@SYS:EQL-RASSOC,                 eql_rassoc,                      "boolean"
@SYS:FAST,                       procedure(); Fast endprocedure,  "boolean"
@SYS:FIX*,                       nonop fi_*,                      [2 2 1]
@SYS:FIX+,                       nonop fi_+,                      [2 2 1]
@SYS:FIX-,                       nonop fi_-,                      [2 2 1]
@SYS:FIX<,                       nonop fi_<,                      "boolean"
@SYS:FIX>,                       nonop fi_>,                      "boolean"
@SYS:GFN-NAME,                   gfn_clos_name,                   "boolean"
@SYS:GLOBAL-SPECIAL-P,           global_special_p,                "boolean"
@SYS:HASH-TABLE-ITERATOR-NEXT,   hash_table_iterator_next,        [1 1 3]
@SYS:INVOKE-DEBUGGER,            break,                           [1 1 0]
@SYS:MAKE-DESTRUCTURING-FORM,    make_destructuring_form,         [7 7 1]
@SYS:MAKE-HASH-TABLE-ITERATOR,   make_hash_table_iterator,        [1 1 1]
@SYS:MAKE-PACKAGE-ITERATOR,      make_package_iterator,           [2 2 1]
@SYS:MAP-1-LIST,                 map_list,                        [2 2 1]
@SYS:MAP-2-LISTS,                map_2_lists,                     [3 3 1]
@SYS:NEQ,                        nonop /==,                       "boolean"
@SYS:NEWLY-ADDED-SLOTS,          newly_added_slots,               [2 2 1]
@SYS:NREVERSE-LIST,              fast_ncrev,                      [1 1 1]
@SYS:PARSE-BODY,                 parse_body <> lisp_true,         [3 3 3]
@SYS:PATHNAME-FIELD,             pathname_field,                  [3 3 1]
@SYS:POP11-CLASS-NAME,           class_name,                      [1 1 1]
@SYS:REPORT-ERROR,               report_error,                    "boolean"
@SYS:SAVELISP,                   savelisp,                        "boolean"
@SYS:SETF-IS-UPDATER,            setf_is_updater,                 "boolean"
@SYS:STRING-INPUT-STREAM-INDEX,  get_stringin_index,              [1 1 1]
@SYS:SYMBOL-MACRO-P,             symbol_macro,                    "boolean"
@SYS:TRY-QUIT-TO-TOP-LEVEL,      Db_quit,                         [0 0 0]
@SYS:UPDATE-SETF-EXPANDER,       updater(setf_method),            [2 2 0]
@SYS:UPDATE-TYPE-EXPANDER,       updater(type_expander),          [2 2 0]
@SYS:VEDSCREENBELL,              vedscreenbell,                   [0 0 0]

;;; pp stuff

@SYS:CALL-FORMAT-COMPILE,        format_compile(% "lisp" %),      [1 1 1]
@SYS:CALL-FORMAT-PRINT,          call_format_print,               [3 3 1]
@SYS:PPRINT-LOGICAL-BLOCK,       pprint_logical_block,            [6 6 0]
@SYS:PPRINT-ANY,                 pprint_any,                      [2 2 0]
@SYS:PPRINT-DISPATCH,            pprint_dispatch,                 "boolean"
@SYS:PPRINT-EXIT,                pprint_exit,                     [0 0 1]
@SYS:PPRINT-INDENT,              pprint_indent,                   [3 3 0]
@SYS:PPRINT-NEWLINE,             pprint_newline,                  [2 2 0]
@SYS:PPRINT-POP,                 pprint_pop,                      [0 0 1]
@SYS:PPRINT-TAB,                 pprint_tab,                      [4 4 0]
@SYS:PPRINT-TEST-EXIT,           pprint_test_exit,                [0 0 1]


@SYS:ADD-METHOD,                 add_method,                      [2 2 1]
@SYS:ADJUST-ARRAY,               adjust_array,                    []
@SYS:ALLOCATE-INSTANCE,          allocate_instance,               [1 1 1]
@SYS:CALL-METHOD,                call_iom,                        [2 2 ?]
@SYS:CHANGE-CLASS,               change_class,                    [2 2 1]
@SYS:CLOSE,                      close_stream,                    [1 1 1]
@SYS:DELETE-FILE,                delete_file,                     [1 1 1]
@SYS:DOCUMENTATION,              documentation,                   "boolean"
@SYS:ENSURE-GENERIC-FUNCTION,    ensure_generic_function,         [6 6 1]
@SYS:EXPORT,                     export,                          [2 2 0]
@SYS:FIND-METHOD,                find_method,                     [4 4 1]
@SYS:IMPORT,                     import,                          [2 2 0]
@SYS:LOAD,                       lisp_load,                       "boolean"
@SYS:MAKE-ARRAY,                 make_array,                      []
@SYS:MAKE-HASH-TABLE,            make_hash_table,                 []
@SYS:MAKE-INSTANCES-OBSOLETE,    make_instances_obsolete,         [1 1 0]
@SYS:MAKE-PACKAGE,               make_package,                    []
@SYS:MAKE-PATHNAME,              make_pathname,                   []
@SYS:MAKE-SEQUENCE,              make_sequence,                   []
@SYS:MAKE-STRING,                make_string,                     []
@SYS:MAKE-STRING-OUTPUT-STREAM,  make_stringout_stream,           [1 1 1]
@SYS:METHOD-QUALIFIERS,          method_qualifiers,               [1 1 1]
@SYS:NEXT-METHOD-P,              next_method_p,                   "boolean"
@SYS:NSTRING-CAPITALIZE,         nstring_capitalize,              []
@SYS:NSTRING-DOWNCASE,           nstring_downcase,                []
@SYS:NSTRING-UPCASE,             nstring_upcase,                  []
@SYS:NTH-VALUE,                  nth_value,                       [1 N 1]
@SYS:OPEN,                       open,                            []
@SYS:PARSE-INTEGER,              parse_integer,                   [5 5 2]
@SYS:PARSE-NAMESTRING,           parse_namestring,                [6 6 2]
@SYS:PUTF,                       putf,                            []
@SYS:REMF,                       remf,                            [2 2 2]
@SYS:REMOVE-DUPLICATES,          remove_duplicates,               []
@SYS:REMOVE-IF,                  remove_if,                       []
@SYS:REMOVE-METHOD,              remove_method,                   [2 2 1]
@SYS:RENAME-FILE,                rename_file,                     [2 2 3]
@SYS:RENAME-PACKAGE,             rename_package,                  [2 2 1]
@SYS:SHADOW,                     shadow,                          [2 2 0]
@SYS:SHADOWING-IMPORT,           shadowing_import,                [2 2 0]
@SYS:SHARED-INITIALIZE,          shared_initialize,               [3 3 1]
@SYS:SORT,                       sort_seq,                        [4 4 1]
@SYS:STRING-CAPITALIZE,          string_capitalize,               []
@SYS:STRING-DOWNCASE,            string_downcase,                 []
@SYS:STRING-EQUAL,               string_equal,                    "boolean"
@SYS:STRING-GREATERP,            string_greaterp,                 "boolean"
@SYS:STRING-LESSP,               string_lessp,                    "boolean"
@SYS:STRING-NOT-EQUAL,           string_not_equal,                "boolean"
@SYS:STRING-NOT-GREATERP,        string_not_greaterp,             "boolean"
@SYS:STRING-NOT-LESSP,           string_not_lessp,                "boolean"
@SYS:STRING-UPCASE,              string_upcase,                   []
@SYS:STRING/=,                   string_/=,                       "boolean"
@SYS:STRING<,                    string_<,                        "boolean"
@SYS:STRING<=,                   string_<=,                       "boolean"
@SYS:STRING=,                    string_=,                        "boolean"
@SYS:STRING>,                    string_>,                        "boolean"
@SYS:STRING>=,                   string_>=,                       "boolean"
@SYS:TRACE,                      lisp_trace,                      [1 1 1]
@SYS:TRANSLATE-PATHNAME,         translate_pathname,              [3 3 1]
@SYS:UNEXPORT,                   unexport,                        [2 2 0]
@SYS:UNTRACE,                    lisp_untrace,                    [1 1 1]
@SYS:UNUSE-PACKAGE,              unuse_package,                   [2 2 0]
@SYS:USE-PACKAGE,                use_package,                     [2 2 0]
@SYS:WRITE,                      write,                           [4 4 1]
@SYS:WRITE-SIMPLE-STRING,        fast_write_string,               [2 2 1]
@SYS:WRITE-STRING,               write_string,                    [5 5 1]


/* Some non-standard functions that should be available to the user */

@POPLOG:BYE,                     magic_word_handler(@POPLOG:BYE), [0 0 0]
@POPLOG:INITLISP,                initlisp,                        [0 1 0]
@POPLOG:MAKE-POP11-PROCEDURE,    make_pop11_procedure,            [2 2 1]
@POPLOG:POP11,                   magic_word_handler(@POPLOG:POP11), [0 0 0]
@POPLOG:POP11-VAL,               pop11_val,                       [1 1 ?]
@POPLOG:RESTORELISP,             restorelisp,                     [1 1 0]
@POPLOG:SAVELISP,                "LISP",                          1
@POPLOG:SETLISP,                 setlisp,                         [0 0 0]

;;; Revision Notes
;;; 27 Aug 1999, Aaron Sloman
;;; Replaced define_class with clos_define_class
