(make-package "COMPILER" :use '("LISP"))
(make-package "SLOOP" :use '("LISP"))
(make-package "SERROR" :use '("LISP" "SLOOP"))
(make-package "ANSI-LOOP" :use '("LISP"))
(make-package "DEFPACKAGE" :use '("LISP"))
(make-package "TK" :use '("LISP" "SLOOP"))

;;; CMPMAIN  Compiler main program.
;;;
;; Copyright (C) 1994 M. Hagiya, W. Schelter, T. Yuasa

;; This file is part of GNU Common Lisp, herein referred to as GCL
;;
;; GCL is free software; you can redistribute it and/or modify it under
;;  the terms of the GNU LIBRARY GENERAL PUBLIC LICENSE as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; 
;; GCL is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
;; FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public 
;; License for more details.
;; 
;; You should have received a copy of the GNU Library General Public License 
;; along with GCL; see the file COPYING.  If not, write to the Free Software
;; Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.


;;;		**** Caution ****
;;;	This file is machine/OS dependant.
;;;		*****************


(in-package 'compiler)


(export '(*compile-print* *compile-verbose*))

;;; This had been true with Linux 1.2.13 a.out or even older
;;; #+linux   (push :ld-not-accept-data  *features*)
;;; its now a bug preventing the :linux feature.


(defvar *compiler-in-use* nil)
(defvar *compiler-compile* nil)
(defvar *compiler-input*)
(defvar *compiler-output1*)
(defvar *compiler-output2*)
(defvar *compiler-output-data*)
(defvar *compiler-output-i*)

(defvar *error-p* nil)

(defvar *compile-print* nil)
(defvar *compile-verbose* t)
(defvar *cmpinclude* "\"cmpinclude.h\"")
;;If the following is a string, then it is inserted instead of
;; the include file cmpinclude.h, EXCEPT for system-p calls.
(defvar *cmpinclude-string* t)


;; Let the user write dump c-file etc to  /dev/null.
(defun get-output-pathname (file ext name &optional (dir (pathname-directory *default-pathname-defaults*))
				 (device (pathname-device *default-pathname-defaults*)))
  (cond 
	((equal file "/dev/null") (pathname file))
	#+aix3
	((and (equal name "float")
	      (equal ext "h"))
	 (get-output-pathname file ext "Float" ))
	(t
	 (make-pathname :device (or (and (not (null file))
					 (not (eq file t))
					 (pathname-device file))
				       device)
			:directory (or (and (not (null file))
					    (not (eq file t))
					    (pathname-directory file))
				       dir)
			:name (or (and (not (null file))
				       (not (eq file t))
				       (pathname-name file))
				  name)
			:type ext))))


(defun safe-system (string)
 (multiple-value-bind
  (code result) (system string)
    (unless (and (zerop code) (zerop result))
      (cerror "Continues anyway."
              "(SYSTEM ~S) returned a non-zero value ~D."
              string
              result)
      (setq *error-p* t))
    (values result)))

;; If this is t we use fasd-data on all but system-p files.   If it
;; is :system-p we use it on all files.   If nil use it on none.
(defvar *fasd-data* t)
(defvar *data* nil)
(defvar *default-system-p* nil)
(defvar *default-c-file* nil)
(defvar *default-h-file* nil)
(defvar *default-data-file* nil)
(defvar *keep-gaz* nil)

;;  (list section-length split-file-names next-section-start-file-position)
;;  Many c compilers cannot handle the large C files resulting from large lisp files.
;;  If *split-files* is a number then, separate compilations for sections
;;  *split-files* long, with the 
;;  will be performed for separate chunks of the lisp files.
(defvar *split-files* nil)  ;; if 

(defun check-end (form eof)
  (cond  ((eq form eof)
	  (setf (third *split-files*) nil))
	 ((> (file-position *compiler-input*)
	     (car *split-files*))
	  (setf (third *split-files*)(file-position *compiler-input*)))))
	  

(defun compile-file  (&rest args
			    &aux (*print-pretty* nil)
			    (*package* *package*) (*split-files* *split-files*)
			    (*PRINT-CIRCLE* NIL)
			    (*PRINT-RADIX* NIL)
			    (*PRINT-ARRAY* T)
			    (*PRINT-LEVEL* NIL)
			    (*PRINT-PRETTY* T)
			    (*PRINT-LENGTH* NIL)
			    (*PRINT-GENSYM* T)
			    (*PRINT-CASE* :UPCASE)
			    (*PRINT-BASE* 10)
			    (*PRINT-ESCAPE* T)
			    (section-length *split-files*)
			    tem)
  (loop 
   (compiler::init-env)
   (setq tem (apply 'compiler::compile-file1 args))
   (cond ((atom *split-files*)(return tem))
	 ((and (consp *split-files*)
	       (null (third *split-files*)))
	  (let ((gaz (let ((*DEFAULT-PATHNAME-DEFAULTS* (car args)))
			    			    (gazonk-name)))
		(*readtable* (si::standard-readtable)))
	    (setq gaz (get-output-pathname gaz "lsp" (car args)))
	    (with-open-file (st gaz :direction :output)
	      (print
	       `(eval-when (load eval)
			   (dolist (v ',(nreverse (second *split-files*)))
				   (load (merge-pathnames v si::*load-pathname*))))
	       st))
	    (setq *split-files* nil)
	    (or (member :output-file args)
		(setq args (append args (list :output-file (car args)))))
	    (return 
	     (prog1 (apply 'compile-file gaz (cdr args))
	       (unless *keep-gaz* (delete-file gaz))))
	    ))
	 (t nil))
   (if (consp *split-files*)
       (setf (car *split-files*) (+ (third *split-files*) section-length)))
   ))


(defun compile-file1 (input-pathname
                      &key (output-file input-pathname)
                           (o-file t)
                           (c-file *default-c-file*)
                           (h-file *default-h-file*)
                           (data-file *default-data-file*)
			   (c-debug nil)
                           #+aosvs (ob-file nil)
                           (system-p *default-system-p*)
			   (print nil)
                           (load nil)
                      &aux (*standard-output* *standard-output*)
                           (*error-output* *error-output*)
                           (*compiler-in-use* *compiler-in-use*)
			   (*c-debug* c-debug)
			   (*compile-print* (or print *compile-print*))
                           (*package* *package*)
			   (*DEFAULT-PATHNAME-DEFAULTS* #"")
			   (*data* (list (make-array 50 :fill-pointer 0
						     :adjustable t
						     )
					 nil ;inits
					 nil
					 ))
			   *init-name* 	
			   (*fasd-data* *fasd-data*)
                           (*error-count* 0))
  (declare (special *c-debug* *init-name* system-p))

  (cond (*compiler-in-use*
         (format t "~&The compiler was called recursively.~%~
Cannot compile ~a.~%"
                 (namestring (merge-pathnames input-pathname #".lsp")))
         (setq *error-p* t)
         (return-from compile-file1 (values)))
        (t (setq *error-p* nil)
           (setq *compiler-in-use* t)))  

  (unless (probe-file (merge-pathnames input-pathname #".lsp"))
    (format t "~&The source file ~a is not found.~%"
            (namestring (merge-pathnames input-pathname #".lsp")))
    (setq *error-p* t)
    (return-from compile-file1 (values)))

  (when *compile-verbose*
    (format t "~&Compiling ~a.~%"
            (namestring (merge-pathnames input-pathname #".lsp"))))

  (and *record-call-info* (clear-call-table))

  (with-open-file
          (*compiler-input* (merge-pathnames input-pathname #".lsp"))


    (cond ((numberp *split-files*)
	   (if (< (file-length *compiler-input*) *split-files*)
	       (setq *split-files* nil)
	     ;;*split-files* = ( section-length split-file-names next-section-start-file-position
	     ;;                           package-ops)
	     (setq *split-files* (list *split-files* nil 0 nil)))))

    (cond ((consp *split-files*)
	   (file-position *compiler-input* (third *split-files*))
	   (setq output-file
		 (make-pathname :directory (pathname-directory output-file)
				:name (format nil "~a~a"
					      (length (second *split-files*))
					      (pathname-name (pathname output-file)))
				:type "o"))
	   
	   (push (pathname-name output-file)   (second *split-files*))
	   ))
	   
    
	 
    
  (let* ((eof (cons nil nil))
         (dir (or (and (not (null output-file))
                       (pathname-directory output-file))
                  (pathname-directory input-pathname)))
         (name (or (and (not (null output-file))
                        (pathname-name output-file))
                   (pathname-name input-pathname)))
	 (device (or (and (not (null output-file))
                        (pathname-device output-file))
                   (pathname-device input-pathname)))

         (o-pathname (get-output-pathname o-file "o" name dir device))
         (c-pathname (get-output-pathname c-file "c" name dir device))
         (h-pathname (get-output-pathname h-file "h" name dir device))
         (data-pathname (get-output-pathname data-file "data" name dir device))
;	 (i-pathname  (get-output-pathname data-file "i" name dir))
         #+aosvs (ob-pathname (get-output-pathname ob-file "ob" name dir device))
         )
    (declare (special dir name ))

    (init-env)

    (and (boundp 'si::*gcl-version*)
	 (not system-p)
	 (add-init `(si::warn-version ,si::*gcl-major-version*
				      ,si::*gcl-minor-version*
				      ,si::*gcl-extra-version*)))

    (when (probe-file "./gcl_cmpinit.lsp")
      (load  "./gcl_cmpinit.lsp"
            :verbose *compile-verbose*))

    (with-open-file (*compiler-output-data*
                      data-pathname
                     :direction :output)
    (progn 
      (setq *fasd-data*      		      
	    (cond  ((if system-p (eq *fasd-data* :system-p)
		      *fasd-data*)
		    (list
		     (si::open-fasd *compiler-output-data* :output nil nil)
		     ;(si::open-fasd *compiler-output-i* :output nil nil)
		     ))))

      (wt-data-begin)

      (let* ((rtb *readtable*)
               (prev (and (eq (get-macro-character #\# rtb)
                              (get-macro-character
                                #\# (si:standard-readtable)))
                          (get-dispatch-macro-character #\# #\, rtb))))
          (if (and prev (eq prev (get-dispatch-macro-character
                                   #\# #\, (si:standard-readtable))))
              (set-dispatch-macro-character #\# #\,
                'si:sharp-comma-reader-for-compiler rtb)
              (setq prev nil))
	  
	  ;; t1expr the package ops again..
	  (if (consp *split-files*)
	      (dolist (v (fourth *split-files*)) (t1expr v)))
          (unwind-protect
            (do ((form (read *compiler-input* nil eof)
                       (read *compiler-input* nil eof))
		 (load-flag (or (eq :defaults *eval-when-defaults*)
				(member 'load *eval-when-defaults*))))
                (nil)
              (cond
	       ((eq form eof))
	       (load-flag (t1expr form))
	       ((maybe-eval nil form)))
	      (cond
	       ((and *split-files* (check-end form eof))
		(setf (fourth *split-files*) (reverse (third *data*)))
		(return nil))
	       ((eq form eof) (return nil)))
	      )
	    

            (when prev (set-dispatch-macro-character #\# #\, prev rtb)))))

     (setq *init-name* (init-name input-pathname system-p))

      (when (zerop *error-count*)
        (when *compile-verbose* (format t "~&End of Pass 1.  ~%"))
        (compiler-pass2 c-pathname h-pathname system-p ))
	

      (wt-data-end)

      ) ;;; *compiler-output-data* closed.

    (init-env)

    (if (zerop *error-count*)

        #+aosvs
        (progn
          (when *compile-verbose* (format t "~&End of Pass 2.  ~%"))
          (when data-file
            (with-open-file (in fasl-pathname)
              (with-open-file (out data-pathname :direction :output)
                (si:copy-stream in out))))
          (cond ((or fasl-file ob-file)
                 (compiler-cc c-pathname ob-pathname)
                 (cond ((probe-file ob-pathname)
                        (when fasl-file
                              (compiler-build ob-pathname fasl-pathname)
                              (when load (load fasl-pathname)))
                        (unless ob-file (delete-file ob-pathname))
                        (when *compile-verbose*
                              (print-compiler-info)
                              (format t "~&Finished compiling ~a.~%" (namestring output-file))
			      ))
                       (t (format t "~&Your C compiler failed to compile the intermediate file.~%")
                          (setq *error-p* t))))
                (*compile-verbose*
                 (print-compiler-info)
                 (format t "~&Finished compiling ~a.~%" (namestring output-file)
			 )))
          (unless c-file (delete-file c-pathname))
          (unless h-file (delete-file h-pathname))
          (unless fasl-file (delete-file fasl-pathname)))


        (progn
          (when *compile-verbose* (format t "~&End of Pass 2.  ~%"))
	  (cond (*record-call-info*
		 (dump-fn-data (get-output-pathname output-file "fn" name dir device))))
          (cond (o-file
                 (compiler-cc c-pathname o-pathname  )
                 (cond ((probe-file o-pathname)
                        (compiler-build o-pathname data-pathname)
                        (when load (load o-pathname))
                       (when *compile-verbose*
                              (print-compiler-info)
                              (format t "~&Finished compiling ~a.~%" (namestring output-file)
				      )))
                       (t 
                          (format t "~&Your C compiler failed to compile the intermediate file.~%")
                          (setq *error-p* t))))
                 (*compile-verbose*
                  (print-compiler-info)
                  (format t "~&Finished compiling ~a.~%" (namestring output-file)
			  )))
          (unless c-file (delete-file c-pathname))
          (unless h-file (delete-file h-pathname))
          (unless (or data-file #+ld-not-accept-data t system-p) (delete-file data-pathname))
	  o-pathname)

        (progn
          (when (probe-file c-pathname) (delete-file c-pathname))
          (when (probe-file h-pathname) (delete-file h-pathname))
          (when (probe-file data-pathname) (delete-file data-pathname))
          (format t "~&No FASL generated.~%")
          (setq *error-p* t)
	  (values)
	  ))))))

(defun gazonk-name ( &aux tem)
  (dotimes (i 1000)
	   (unless (probe-file (setq tem (merge-pathnames (format nil "gazonk~d.lsp" i))))
		  (return-from gazonk-name (pathname tem))))
  (error "1000 gazonk names used already!"))

(defun prin1-cmp (form strm)
  (let ((*compiler-output-data* strm)
	(*fasd-data* nil))
    (wt-data1 form)  ;; this binds all the print stuff
    ))

(defun compile (name &optional def &aux tem gaz (*default-pathname-defaults* #"."))

  (cond ((not(symbolp name)) (error "Must be a name"))
	((and (consp def)
	      (member (car def) '(lambda )))
	 (or name (setf name 'cmp-anon))
	 (setf (symbol-function name)
	       def)
	 (compile name))
	(def (error "def not a lambda expression"))
	((setq tem (macro-function name))
	 (setf (symbol-function 'cmp-anon) tem)
	 (compile 'cmp-anon)
	 (setf (macro-function name) (macro-function name))
	 ;; FIXME -- support warnings-p and failures-p.  CM 20041119
	 (values name nil nil))
	((and (setq tem (symbol-function name))
	      (consp tem))
	 (let ((na (if (symbol-package name) name 'cmp-anon))
	       (tem (if *keep-gaz* tem (wrap-literals tem))))
	   (unless (and (fboundp 'si::init-cmp-anon) (or (si::init-cmp-anon) (fmakunbound 'si::init-cmp-anon)))
	     (with-open-file
	      (st (setq gaz (gazonk-name)) :direction :output)
	      (prin1-cmp `(defun ,na ,@ (ecase (car tem)
					       (lambda (cdr tem))
					       (lambda-block (cddr tem))
					       ))       st))
	     (let ((fi (let ((*compiler-compile* t))
			 (compile-file gaz))))
	       (load fi)
	       (delete-file fi))
	     (unless *keep-gaz* (delete-file gaz)))
	   (or (eq na name) (setf (symbol-function name) (symbol-function na)))
	 ;; FIXME -- support warnings-p and failures-p.  CM 20041119
	   (values (symbol-function name) nil nil)
	   ))
	(t (error "can't compile ~a" name))))

(defun disassemble (name &aux tem)
  (cond ((and (consp name)
	      (eq (car name) 'lambda))
	 (eval `(defun cmp-anon ,@ (cdr name)))
	 (disassemble 'cmp-anon))
	((not(symbolp name)) (error "Not a lambda or a name"))
	((setq tem(macro-function name))
	 (setf (symbol-function 'cmp-tmp-macro) tem)
	 (disassemble 'cmp-tmp-macro)
	 (setf (macro-function name) (macro-function name))
	 name)
	((and (setq tem (symbol-function name))
	      (consp tem)
	      (eq (car tem) 'lambda-block))
	 (let ((gaz (gazonk-name)))
	   (with-open-file
	     (st gaz :direction :output)
	     (prin1-cmp `(defun ,name ,@ (cddr tem))       st))
	   (let (*fasd-data*)
	     (compile-file gaz 
			   :h-file t 
			   :c-file t
			   :data-file t
			   :o-file t))
	   (let ((cn (get-output-pathname gaz "c" gaz ))
		 (dn (get-output-pathname gaz "data" gaz ))
		 (hn (get-output-pathname gaz "h" gaz ))
		 (on (get-output-pathname gaz "o" gaz )))
	     (with-open-file (st cn)
			     (do () ((let ((a (read-line st)))
				       (when (>= (si::string-match "gazonk[0-9]*.h" a) 0)
					 (format t "~%~d~%" a)
					 a))))
			     (si::copy-stream st *standard-output*))
	     (with-open-file (st dn)
			     (si::copy-stream st *standard-output*))
	     (with-open-file (st hn)
			     (si::copy-stream st *standard-output*))
	     (system (si::string-concatenate "objdump -d -l "
					     (namestring on)))
	     (delete-file cn)
	     (delete-file dn)
	     (delete-file hn)
	     (delete-file on)
	     (unless *keep-gaz* (delete-file gaz)))))
	(t (error "can't disassemble ~a" name))))


(defun compiler-pass2 (c-pathname h-pathname system-p )
  (with-open-file (st c-pathname :direction :output)
    (let ((*compiler-output1* (if (eq system-p 'disassemble) *standard-output*
				st)))
      (declare (special *compiler-output1*))
    (with-open-file (*compiler-output2* h-pathname :direction :output)
      (cond ((and 
	      (stringp *cmpinclude-string*)
	      (not system-p)
	      (si::fwrite *cmpinclude-string* 0
			  (length *cmpinclude-string*) *compiler-output1*)))
	    (t (wt-nl1 "#include " *cmpinclude*)))
      (wt-nl1 "#include \""
	      (namestring
	        (make-pathname :name
	          (pathname-name h-pathname)
	           :type (pathname-type h-pathname)))

              #+aosvs (string-downcase (namestring h-pathname))
              "\"")

      (catch *cmperr-tag* (ctop-write *init-name*))
      (if system-p
	  (wt
	   "

#ifdef SYSTEM_SPECIAL_INIT
SYSTEM_SPECIAL_INIT
#endif
"))

      (terpri *compiler-output1*)
      ;; write ctl-z at end to make sure preprocessor stops!
      #+dos (write-char (code-char 26) *compiler-output1*)
      (terpri *compiler-output2*)))))


(defvar *cc* "cc")
(defvar *ld* "ld")
(defvar *ld-libs* "ld-libs")
(defvar *opt-three* "")
(defvar *opt-two* "")
(defvar *init-lsp* "init-lsp")

(defvar *use-buggy* nil)

(defun  compiler-command (&rest args &aux na )
  (declare (special *c-debug*))
  (let ((dirlist (pathname-directory (first args)))
	(name (pathname-name (first args)))
	dir)
    (cond (dirlist (setq dir (namestring (make-pathname :directory dirlist))))
	  (t (setq dir ".")))
    (setq na  (namestring
	       (make-pathname :name name :type (pathname-type(first args)))))
   #+(or dos winnt)
      (format nil "~a -I~a ~a ~a -c -w ~s -o ~s"
	      *cc*
	      (concatenate 'string si::*system-directory* "../h")
	      (if (and (boundp '*c-debug*) *c-debug*) " -g " "")
	      (case *speed*
		    (3 *opt-three* )
		    (2 *opt-two*) 
		    (t ""))	
	      (namestring (make-pathname  :type "c" :defaults (first args)))
	      (namestring (make-pathname  :type "o" :defaults (first args)))
	      )

   #-(or dos winnt)
   (format nil  "~a -I~a ~a ~a -c ~s -o ~s ~a"
	   *cc*
	   (concatenate 'string si::*system-directory* "../h")
	   (if (and (boundp '*c-debug*) *c-debug*) " -g " "")
           (case *speed*
		 (3 *opt-three* )
		 (2 *opt-two*) 
		 (t ""))	
	   (namestring (first args))
	   (namestring (second args))
	   (prog1
	       #+aix3
	     (format nil " -w ;ar x /lib/libc.a fsavres.o  ; ar qc XXXfsave fsavres.o ; echo init_~a > XXexp ; mv  ~a  XXX~a ; ld -r -D-1 -bexport:XXexp -bgc XXX~a -o ~a XXXfsave ; rm -f XXX~a XXexp XXXfsave fsavres.o"
		     *init-name*
		     (setq na (namestring (get-output-pathname na "o" nil)))
		     na na na na na)
	     #+(or dlopen irix5)
	     (if (not system-p)
		 (format nil
			 " -w ; mv ~a XX~a ; ld  ~a -shared XX~a  -o ~a -lc ; rm -f XX~a"  
			 (setq na (namestring (get-output-pathname na "o" nil)))			    na
			 #+ignore-unresolved "-ignore_unresolved"
			 #+expect-unresolved "-expect_unresolved '*'"
			 na na na))	
			    
	     #+bsd "-w"
	     #-(or aix3 bsd irix3) " 2> /dev/null ")
		  
		 
	   )
   )
  )

#+winnt (defun prep-win-path-acc ( s acc)
  (let ((pos (search "\~" s)))
    (if pos 
	(let ((start (subseq s 0 (1+ pos)))
	      (finish (subseq s (1+ pos))))
	  (prep-win-path-acc finish (concatenate 'string acc start "~")))
      (concatenate 'string acc s))))
#+winnt (defun prep-win-path ( s ) (prep-win-path-acc s ""))        

(defun compiler-cc (c-pathname o-pathname  )
  (safe-system
    (format
     nil
     (prog1
	 #+irix5 (compiler-command c-pathname o-pathname )
	 #+vax "~a ~@[~*-O ~]-S -I. -w ~a ; as -J -W -o ~A ~A"
	 #+(or system-v e15 dgux sgi ) "~a ~@[~*-O ~]-c -I. ~a 2> /dev/null"
	 #+winnt (prep-win-path (compiler-command c-pathname o-pathname ))
	 #-winnt (compiler-command c-pathname o-pathname)
	)
     *cc*
     (if (or (= *speed* 2) (= *speed* 3)) t nil)
            (namestring c-pathname)
             (namestring o-pathname)
  
            ))
  
  #+dont_need
  (let ((cname (pathname-name c-pathname))
        (odir (pathname-directory o-pathname))
        (oname (pathname-name o-pathname)))
    (unless (and (equalp (truename "./")
                         (truename (make-pathname :directory odir)))
                 (equal cname oname))
	(rename-file (make-pathname :name cname :type "o")
        	                  o-pathname)
)))


(defun compiler-build (o-pathname data-pathname)
  #+(and system-v (not e15))
  (safe-system (format nil "echo \"\\000\\000\\000\\000\" >> ~A"
                       (namestring o-pathname)))
    #+(or hp-ux sun sgi)
    (with-open-file (o-file
		    (namestring o-pathname)
		    :direction :output
		    :if-exists :append)
      ; we could do a safe-system, but forking is slow on the Iris
    #+(or hp-ux (and sgi (not irix5)))
    (dotimes (i 12)
      (write-char #\^@ o-file))
    #+sun  ; we could do a safe-system, but forking is slow on the Iris
    (dolist (v '(0 0 4 16 0 0 0 0))
	      (write-byte v o-file))

    )
  #-ld-not-accept-data  
  (when (probe-file o-pathname)
     (nconc-files o-pathname data-pathname)
    #+never
    (safe-system (format nil
			 "cat ~a  >> ~A"
			 (namestring data-pathname)
			 (namestring o-pathname)))))

(defun print-compiler-info ()
  (format t "~&OPTIMIZE levels: Safety=~d~:[ (No runtime error checking)~;~], Space=~d, Speed=~d~%"
          (cond ((null *compiler-check-args*) 0)
                ((null *safe-compile*) 1)
                ((null *compiler-push-events*) 2)
                (t 3))
          *safe-compile* *space* *speed*))

(defun nconc-files (a b)
  (let* ((n 256)
	 (tem (make-string n))
	 (m 0))
    (with-open-file (st-a a :direction :output :if-exists :append)
      (with-open-file (st-b b )
	(sloop::sloop
	   do (setq m (si::fread tem 0 n st-b))
	   while (and m (> m 0))
	   do (si::fwrite tem 0 m st-a))))))

#+dos
(progn
(defun directory (x &aux ans)
  (let* ((pa (pathname x))
	 (temp "XXDIR")
	 tem
	 (name (pathname-name pa)))
    (setq pa (make-pathname :directory (pathname-directory pa)
			    :name (or (pathname-name pa) :wild)
			    :type (pathname-type pa)))
    (setq name (namestring pa))
    (system (format nil "ls -d ~a > ~a" name temp))
    (with-open-file (st temp)
	    (loop (setq tem (read-line st nil nil))
		  (if (and tem (setq tem (probe-file tem)))
		      (push tem ans) (return))))
    ans))

(defvar *old-compile-file* #'compile-file) 
(defun compile-file (f &rest l)
  (let* ((p (pathname f)) dir pwd)
    (setq dir (pathname-directory p))
    (when dir
	  (setq dir (namestring (make-pathname :directory dir
					       :name ".")))
	  (setq pwd (namestring (truename ".")))
	  )
    (unwind-protect
	(progn (if dir (si::chdir dir))
	       (apply *old-compile-file* f l))
      (if pwd (si::chdir pwd)))))

(defun user-homedir-pathname ()
  (or (si::getenv "HOME") "/"))

)

;
;  These functions are added to build custom images requiring
;  the loading of binary objects on systems relocating with dlopen.
;

(defun make-user-init (files outn &aux tem)

  (let* ((c (pathname outn))
	 (c (merge-pathnames c (make-pathname :directory '(:current))))
	 (o (merge-pathnames (make-pathname :type "o") c))
	 (c (merge-pathnames (make-pathname :type "c") c)))
  
  (with-open-file (st c :direction :output)
		  (format st "#include <string.h>~%")
		  (format st "#include ~a~%~%" *cmpinclude*)

		  (format st "#define load2(a) do {")
		  (format st "printf(\"Loading %s...\\n\",(a));")
		  (format st "load(a);")
		  (format st "printf(\"Finished %s...\\n\",(a));} while(0)~%~%")

		  (let ((p nil))
		    (dolist (tem files)
		      (when (equal (pathname-type tem) "o")
			  (push (list
                                 (init-name tem t)
				 (namestring tem))
				p)))

		    (setq p (nreverse p))

		    (dolist (tem p)
		      (format st "extern void init_~a(void);~%" (car tem)))
		    (format st "~%")

		    (format st "typedef struct {void (*fn)(void);char *s;} Fnlst;~%")
		    (format st "#define NF ~a~%" (length p))
		    (format st "static Fnlst my_fnlst[NF]={")
		    (dolist (tem p)
		      (when (not (eq tem (car p)))
			(format st ",~%"))
		      (format st "{init_~a,\"~a\"}" (car tem) (cadr tem)))
		    (format st "};~%~%")
		    
		    (format st "object user_init(void) {~%")
		    (dolist (tem files)
		      (let ((tem (namestring tem)))
			    (cond ((equal (cadr (car p)) tem)
				   (format st "gcl_init_or_load1(init_~a,\"~a\");~%"
					   (car (car p)) tem)
				   (setq p (cdr p)))
				  (t 
				   (format st "load2(\"~a\");~%" tem)))))
		    (format st "return Cnil;}~%~%")

		    (format st "int user_match(const char *s,int n) {~%")
		    (format st "  const Fnlst *f;~%")
		    (format st "  for (f=my_fnlst;f<my_fnlst+NF;f++){~%")
		    (format st "     if (!strncmp(s,f->s,n)) {~%")
		    (format st "        gcl_init_or_load1(f->fn,f->s);~%")
		    (format st "        return 1;~%")
		    (format st "     }~%")
		    (format st "  }~%")
		    (format st "  return 0;~%")
		    (format st "}~%~%")))
		    
  (compiler-cc c o)
;  (system (format nil "~a ~a" *cc* tem))
  (delete-file c)

  o))
 
(defun mysub (str it new)
  (let ((x (search it str)))
    (unless x
      (return-from mysub str))
    (let ((y (+ (length it) (the fixnum x))))
      (declare (fixnum y))
      (concatenate (type-of str)
		   (subseq str 0 x)
		   new
		   (mysub (subseq str y) it new)))))

(defun link (files image &optional post extra-libs (run-user-init t) &aux raw init) 

  (let* ((ui (make-user-init files "user-init"))
	 (raw (pathname image))
	 (init (merge-pathnames (make-pathname
				 :name (concatenate 'string "init_" (pathname-name raw))
				 :type "lsp") raw))
	 (raw (merge-pathnames raw (make-pathname :directory (list :current))))
	 (raw (merge-pathnames (make-pathname
				:name (concatenate 'string "raw_" (pathname-name raw)))
			       raw))
	 (map (merge-pathnames (make-pathname
				:name (concatenate 'string (pathname-name raw) "_map")) raw))
	 #+winnt (raw (merge-pathnames (make-pathname :type "exe") raw))
	 )

    (with-open-file (st (namestring map) :direction :output))
    (system 
     (format nil "~a ~a ~a ~a -L~a ~a ~a ~a"
	     *ld* 
	     (namestring raw)
	     (namestring ui)
	     (let ((sfiles ""))
	       (dolist (tem files)
		 (if (equal (pathname-type tem) "o")
		     (setq sfiles (concatenate 'string sfiles " " (namestring tem)))))
	       sfiles) 
	     si::*system-directory*
	     #+gnu-ld (format nil "-Wl,-Map ~a" (namestring map)) #-gnu-ld ""
	     (let* ((par (namestring (make-pathname :directory '(:parent))))
		    (i (concatenate 'string " " par))
		    (j (concatenate 'string " " si::*system-directory* par)))
	       (mysub *ld-libs* i j))
	     (if (stringp extra-libs) extra-libs "")))
    
    (delete-file ui)
    
    (with-open-file (st init :direction :output)
		    (unless run-user-init
		      (format st "(fmakunbound 'si::user-init)~%"))
		    (format st "(setq si::*no-init* '(")
		    (dolist (tem files)
		      (format st " \"~a\"" (pathname-name tem)))
		    (format st "))~%")
		    (with-open-file (st1 
				     (format nil "~a~a" si::*system-directory* *init-lsp*))
				    (si::copy-stream st1 st))
		    (if (stringp post) (format st "~a~%" post))
		    (format st "(si::save-system \"~a\")~%" (namestring image)))
    
    (system (format nil "~a ~a < ~a" 
		    (namestring raw)
		    si::*system-directory*
		    (namestring init)))
    
    (delete-file raw)
    (delete-file init))

  image)


;;; Definitions for package WALKER of type ESTABLISH
(LISP::MAKE-PACKAGE "WALKER" :USE LISP::NIL)

;;; Definitions for package ITERATE of type ESTABLISH
(LISP::MAKE-PACKAGE "ITERATE" :USE LISP::NIL)

;;; Definitions for package PCL of type ESTABLISH
(LISP::MAKE-PACKAGE "PCL" :USE LISP::NIL)

;;; Definitions for package SLOT-ACCESSOR-NAME of type ESTABLISH
(LISP::MAKE-PACKAGE "SLOT-ACCESSOR-NAME" :USE LISP::NIL :NICKNAMES
    '("S-A-N"))

;;; Definitions for package TK of type ESTABLISH
(LISP::IN-PACKAGE "TK" :USE LISP::NIL)

;;; Definitions for package DEFPACKAGE of type ESTABLISH
(LISP::IN-PACKAGE "DEFPACKAGE" :USE LISP::NIL)

;;; Definitions for package ANSI-LOOP of type ESTABLISH
(LISP::IN-PACKAGE "ANSI-LOOP" :USE LISP::NIL)

;;; Definitions for package SERROR of type ESTABLISH
(LISP::IN-PACKAGE "SERROR" :USE LISP::NIL)

;;; Definitions for package COMMON-LISP of type ESTABLISH
(LISP::IN-PACKAGE "COMMON-LISP" :USE LISP::NIL)

;;; Definitions for package WALKER of type EXPORT
(LISP::IN-PACKAGE "WALKER" :USE '("LISP"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT
    '(WALKER::DEFINE-WALKER-TEMPLATE WALKER::*VARIABLE-DECLARATIONS*
         WALKER::NESTED-WALK-FORM WALKER::VARIABLE-DECLARATION
         WALKER::WALK-FORM-EXPAND-MACROS-P WALKER::VARIABLE-LEXICAL-P
         WALKER::VARIABLE-SPECIAL-P WALKER::WALK-FORM
         WALKER::MACROEXPAND-ALL WALKER::VARIABLE-GLOBALLY-SPECIAL-P))

;;; Definitions for package ITERATE of type EXPORT
(LISP::IN-PACKAGE "ITERATE" :USE '("WALKER" "LISP"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT
    '(ITERATE::SUMMING ITERATE::MINIMIZING ITERATE::PLIST-ELEMENTS
         ITERATE::ITERATE* ITERATE::MAXIMIZING ITERATE::LIST-TAILS
         ITERATE::*ITERATE-WARNINGS* ITERATE::GATHERING
         ITERATE::EACHTIME ITERATE::ELEMENTS ITERATE::GATHER
         ITERATE::LIST-ELEMENTS ITERATE::WHILE ITERATE::ITERATE
         ITERATE::UNTIL ITERATE::JOINING ITERATE::COLLECTING
         ITERATE::WITH-GATHERING ITERATE::INTERVAL))

;;; Definitions for package PCL of type EXPORT
(LISP::IN-PACKAGE "PCL" :USE '("LISP" "ITERATE" "WALKER"))
(LISP::IMPORT
    '(LISP::STANDARD-CLASS LISP::STRUCTURE-CLASS LISP::STANDARD-METHOD
         LISP::GENERIC-FUNCTION LISP::STANDARD-GENERIC-FUNCTION
         LISP::STANDARD-OBJECT LISP::BUILT-IN-CLASS
         LISP::METHOD-COMBINATION LISP::METHOD))
(LISP::EXPORT
    '(PCL::CLASS-PRECEDENCE-LIST PCL::SLOT-DEFINITION
         PCL::COMPUTE-APPLICABLE-METHODS-USING-CLASSES
         PCL::SLOT-DEFINITION-WRITERS PCL::CLASS-OF
         PCL::NO-APPLICABLE-METHOD PCL::STANDARD-WRITER-METHOD
         PCL::ENSURE-CLASS-USING-CLASS PCL::ENSURE-GENERIC-FUNCTION
         PCL::FIND-METHOD-COMBINATION PCL::UPDATE-DEPENDENT
         PCL::MAP-DEPENDENTS PCL::SLOT-MISSING PCL::SPECIALIZER
         PCL::CALL-NEXT-METHOD PCL::ENSURE-GENERIC-FUNCTION-USING-CLASS
         PCL::SLOT-MAKUNBOUND-USING-CLASS PCL::MAKE-INSTANCES-OBSOLETE
         PCL::INTERN-EQL-SPECIALIZER PCL::REMOVE-DIRECT-SUBCLASS
         PCL::METHOD-GENERIC-FUNCTION PCL::METHOD-QUALIFIERS
         PCL::FUNCALLABLE-STANDARD-CLASS PCL::EXTRACT-LAMBDA-LIST
         LISP::STANDARD-CLASS PCL::PRINT-OBJECT LISP::STRUCTURE-CLASS
         PCL::COMPUTE-EFFECTIVE-SLOT-DEFINITION
         PCL::GENERIC-FUNCTION-DECLARATIONS PCL::MAKE-INSTANCE
         PCL::METHOD-LAMBDA-LIST PCL::DEFGENERIC
         PCL::REMOVE-DIRECT-METHOD PCL::STANDARD-DIRECT-SLOT-DEFINITION
         PCL::GENERIC-FUNCTION-METHODS PCL::VALIDATE-SUPERCLASS
         PCL::REINITIALIZE-INSTANCE LISP::STANDARD-METHOD
         PCL::STANDARD-ACCESSOR-METHOD
         PCL::FUNCALLABLE-STANDARD-INSTANCE PCL::FUNCTION-KEYWORDS
         PCL::STANDARD PCL::FIND-METHOD PCL::EXTRACT-SPECIALIZER-NAMES
         PCL::INITIALIZE-INSTANCE PCL::GENERIC-FLET PCL::SLOT-UNBOUND
         PCL::STANDARD-INSTANCE PCL::SLOT-DEFINITION-TYPE
         PCL::COMPUTE-EFFECTIVE-METHOD PCL::ALLOCATE-INSTANCE
         PCL::SYMBOL-MACROLET LISP::GENERIC-FUNCTION
         PCL::GENERIC-FUNCTION-METHOD-COMBINATION
         PCL::SPECIALIZER-DIRECT-METHODS PCL::ADD-DIRECT-SUBCLASS
         PCL::WRITER-METHOD-CLASS PCL::SLOT-DEFINITION-INITARGS
         PCL::METHOD-SPECIALIZERS PCL::GENERIC-FUNCTION-METHOD-CLASS
         PCL::ADD-METHOD PCL::WITH-ACCESSORS
         PCL::SLOT-DEFINITION-ALLOCATION
         PCL::SLOT-DEFINITION-INITFUNCTION
         PCL::SLOT-DEFINITION-LOCATION PCL::ADD-DIRECT-METHOD
         PCL::SLOT-BOUNDP PCL::EQL-SPECIALIZER PCL::SHARED-INITIALIZE
         LISP::STANDARD-GENERIC-FUNCTION
         PCL::ACCESSOR-METHOD-SLOT-DEFINITION
         PCL::SLOT-BOUNDP-USING-CLASS PCL::ADD-DEPENDENT
         PCL::SPECIALIZER-DIRECT-GENERIC-FUNCTION
         PCL::WITH-ADDED-METHODS PCL::COMPUTE-CLASS-PRECEDENCE-LIST
         PCL::REMOVE-DEPENDENT PCL::NEXT-METHOD-P
         PCL::GENERIC-FUNCTION-NAME PCL::SLOT-VALUE
         PCL::EFFECTIVE-SLOT-DEFINITION PCL::CLASS-FINALIZED-P
         PCL::COMPUTE-DISCRIMINATING-FUNCTION LISP::STANDARD-OBJECT
         PCL::CLASS-DEFAULT-INITARGS PCL::CLASS-DIRECT-SLOTS
         PCL::FUNCALLABLE-STANDARD-INSTANCE-ACCESS LISP::BUILT-IN-CLASS
         PCL::NO-NEXT-METHOD PCL::SLOT-MAKUNBOUND
         PCL::STANDARD-READER-METHOD PCL::GENERIC-FUNCTION-LAMBDA-LIST
         PCL::GENERIC-FUNCTION-ARGUMENT-PRECEDENCE-ORDER
         PCL::INVALID-METHOD-ERROR PCL::METHOD-COMBINATION-ERROR
         PCL::SLOT-EXISTS-P PCL::FINALIZE-INHERITANCE
         PCL::SLOT-DEFINITION-NAME
         PCL::STANDARD-EFFECTIVE-SLOT-DEFINITION PCL::COMPUTE-SLOTS
         PCL::CLASS-SLOTS PCL::EFFECTIVE-SLOT-DEFINITION-CLASS
         PCL::STANDARD-INSTANCE-ACCESS PCL::WITH-SLOTS
         PCL::DIRECT-SLOT-DEFINITION PCL::DEFINE-METHOD-COMBINATION
         PCL::MAKE-METHOD-LAMBDA PCL::ENSURE-CLASS
         PCL::DIRECT-SLOT-DEFINITION-CLASS PCL::METHOD-FUNCTION
         PCL::STANDARD-SLOT-DEFINITION PCL::CHANGE-CLASS PCL::DEFMETHOD
         PCL::UPDATE-INSTANCE-FOR-DIFFERENT-CLASS
         PCL::UPDATE-INSTANCE-FOR-REDEFINED-CLASS
         PCL::FORWARD-REFERENCED-CLASS PCL::SLOT-DEFINITION-INITFORM
         PCL::REMOVE-METHOD PCL::READER-METHOD-CLASS PCL::CALL-METHOD
         PCL::CLASS-PROTOTYPE PCL::CLASS-NAME PCL::FIND-CLASS
         PCL::DEFCLASS PCL::COMPUTE-APPLICABLE-METHODS
         PCL::SLOT-VALUE-USING-CLASS LISP::METHOD-COMBINATION
         PCL::EQL-SPECIALIZER-INSTANCE PCL::GENERIC-LABELS LISP::METHOD
         PCL::SLOT-DEFINITION-READERS
         PCL::CLASS-DIRECT-DEFAULT-INITARGS
         PCL::CLASS-DIRECT-SUBCLASSES PCL::CLASS-DIRECT-SUPERCLASSES
         PCL::SET-FUNCALLABLE-INSTANCE-FUNCTION))

;;; Definitions for package SLOT-ACCESSOR-NAME of type EXPORT
(LISP::IN-PACKAGE "SLOT-ACCESSOR-NAME" :USE 'LISP::NIL :NICKNAMES
    '("S-A-N"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT 'LISP::NIL)

;;; Definitions for package TK of type EXPORT
(LISP::IN-PACKAGE "TK" :USE '("SLOOP" "LISP"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT 'LISP::NIL)

;;; Definitions for package DEFPACKAGE of type EXPORT
(LISP::IN-PACKAGE "DEFPACKAGE" :USE '("SLOOP" "LISP"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT '(DEFPACKAGE::DEFPACKAGE))

;;; Definitions for package ANSI-LOOP of type EXPORT
(LISP::IN-PACKAGE "ANSI-LOOP" :USE '("LISP"))
(LISP::IMPORT '(LISP::LOOP))
(LISP::EXPORT '(ANSI-LOOP::LOOP-FINISH LISP::LOOP))

;;; Definitions for package SERROR of type EXPORT
(LISP::IN-PACKAGE "SERROR" :USE '("SLOOP" "LISP"))
(LISP::IMPORT 'LISP::NIL)
(LISP::EXPORT
    '(SERROR::ERROR-CONTINUE-STRING SERROR::COND-ANY-ERROR
         SERROR::ERROR-STRING SERROR::DEF-ERROR-TYPE
         SERROR::ERROR-FORMAT-ARGS SERROR::ERROR-NAME
         SERROR::CONDITION-CASE SERROR::COND-ERROR))

;;; Definitions for package COMMON-LISP of type EXPORT
(LISP::IN-PACKAGE "COMMON-LISP" :USE 'LISP::NIL)
(LISP::IMPORT '(LISP::NIL LISP::T))
(LISP::EXPORT '(LISP::NIL LISP::T))

;;; Definitions for package WALKER of type SHADOW
(LISP::IN-PACKAGE "WALKER")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::CDDAR LISP::SHIFTF LISP::REMHASH LISP::CHAR-EQUAL
         LISP::NOTEVERY LISP::TRUNCATE LISP::SEARCH
         LISP::SPECIAL-FORM-P LISP::MAKE-BROADCAST-STREAM LISP::CDDDDR
         LISP::UNLESS LISP::INTERN LISP::CADDDR LISP::LOGANDC1
         LISP::READ-DELIMITED-LIST LISP::END-OF-FILE LISP::APPLY
         LISP::SUBST-IF-NOT LISP::CIS LISP::ADJUSTABLE-ARRAY-P
         LISP::SUBSTITUTE-IF LISP::FILE-STREAM LISP::QUIT
         LISP::MAKE-DISPATCH-MACRO-CHARACTER LISP::CONTROL-ERROR
         LISP::MAKE-STRING-OUTPUT-STREAM LISP::MAKE-STRING-INPUT-STREAM
         LISP::*STANDARD-INPUT* LISP::STANDARD-OBJECT LISP::GENSYM
         LISP::EQUALP LISP::DELETE-PACKAGE LISP::COMPLEXP
         SYSTEM::ALLOCATE LISP::MULTIPLE-VALUE-BIND LISP::CDAADR
         LISP::VECTOR-PUSH-EXTEND LISP::RENAME-PACKAGE LISP::CAAADR
         LISP::*EVALHOOK* LISP::UNTRACE LISP::STRING-CHAR LISP::KYOTO
         LISP::INTEGERP LISP::DENOMINATOR LISP::FLET LISP::HELP
         LISP::WITH-INPUT-FROM-STRING LISP::SHORT-SITE-NAME
         LISP::FILE-NAMESTRING LISP::WRITE-LINE LISP::UNINTERN
         LISP::PRINC LISP::SIMPLE-VECTOR LISP::NSUBST LISP::FBOUNDP
         LISP::SIMPLE-STRING LISP::SPICE LISP::TRACE
         LISP::METHOD-COMBINATION LISP::BOUNDP LISP::SYMBOL-NAME
         LISP::WITH-OPEN-STREAM LISP::UNSIGNED-BYTE LISP::HELP*
         LISP::NOTINLINE LISP::GET-MACRO-CHARACTER
         LISP::SET-MACRO-CHARACTER LISP::POP LISP::LIST-ALL-PACKAGES
         LISP::UNDEFINED-FUNCTION LISP::IEEE-FLOATING-POINT
         LISP::INTERSECTION LISP::CCLOSURE LISP::BOOLE-2 LISP::LOGTEST
         LISP::*QUERY-IO* LISP::MAX LISP::DEFSTRUCT LISP::CDDDAR
         LISP::ELT LISP::INSPECT LISP::CADDAR LISP::LIST-LENGTH
         LISP::NSET-DIFFERENCE LISP::STRING-CAPITALIZE
         LISP::ASSOC-IF-NOT LISP::+++ LISP::BYTE LISP::CHAR
         LISP::CONJUGATE LISP::CHAR-FONT-LIMIT LISP::CHAR-CODE-LIMIT
         LISP::SERIOUS-CONDITION LISP::CDAR LISP::COPY-ALIST
         LISP::FILE-LENGTH LISP::DECLARE LISP::BOOLE-1
         LISP::RANDOM-STATE-P LISP::VECTOR-PUSH LISP::USE-PACKAGE
         LISP::CHAR-BITS LISP::GENERIC-FUNCTION LISP::IMAGPART
         LISP::BROADCAST-STREAM LISP::CDAAAR LISP::CAAAAR
         LISP::GET-DISPATCH-MACRO-CHARACTER
         LISP::SET-DISPATCH-MACRO-CHARACTER LISP::STRING> LISP::GO
         LISP::NSUBST-IF-NOT LISP::FOURTH LISP::DEFINE-SETF-METHOD
         LISP::DO LISP::STORAGE-CONDITION LISP::BIT-ORC2
         LISP::STRING-TRIM LISP::MAPC LISP::PACKAGE LISP::NUMERATOR
         LISP::MACROLET LISP::HASH-TABLE-SIZE LISP::LDB-TEST
         LISP::READER-ERROR LISP::ROW-MAJOR-AREF
         LISP::CHAR-NOT-GREATERP LISP::REM LISP::ARRAYP LISP::CDADR
         LISP::FFLOOR LISP::SUBST-IF LISP::FIND-IF LISP::MAKE-SYMBOL
         LISP::MAKE-PACKAGE LISP::STRING= LISP::MAPLIST LISP::WRITE
         LISP::ATOM LISP::BIT-VECTOR LISP::DECF LISP::LOGXOR
         LISP::MULTIPLE-VALUES-LIMIT LISP::OPTIMIZE LISP::REST
         LISP::FIND-IF-NOT LISP::COUNT LISP::FMAKUNBOUND LISP::LIST
         LISP::BOOLE-NOR LISP::ZEROP LISP::// LISP::RASSOC LISP::1+
         LISP::RASSOC-IF LISP::NOTANY LISP::LAST LISP::*PRINT-PRETTY*
         LISP::MAPCAN LISP::DEFMACRO LISP::SHADOW LISP::NRECONC
         LISP::++ LISP::LIST* LISP::STRING< LISP::SOFTWARE-VERSION
         LISP::*GENSYM-COUNTER* LISP::REMOVE-DUPLICATES
         LISP::PARSE-NAMESTRING LISP::UPPER-CASE-P
         LISP::MAKE-CONCATENATED-STREAM LISP::DO-EXTERNAL-SYMBOLS
         LISP::CONCATENATE LISP::CHAR-CONTROL-BIT LISP::WARN
         LISP::BIGNUM LISP::SIMPLE-VECTOR-P LISP::DELETE-DUPLICATES
         LISP::NAMESTRING LISP::BIT-ORC1 LISP::SAFETY LISP::MEMBER-IF
         LISP::COPY-SEQ LISP::ECHO-STREAM LISP::Y-OR-N-P LISP::COMPLEX
         LISP::COUNT-IF-NOT LISP::REDUCE LISP::ASSOC-IF
         LISP::MACRO-FUNCTION LISP::MAKE-SYNONYM-STREAM LISP::NUMBERP
         LISP::SXHASH LISP::CAR LISP::LOGORC2 LISP::UNSIGNED-CHAR
         LISP::BYTE-POSITION LISP::UNIX LISP::DEFLA
         LISP::ENCODE-UNIVERSAL-TIME LISP::LOWER-CASE-P LISP::EVAL-WHEN
         LISP::ARRAY-TOTAL-SIZE LISP::DO* LISP::TRUENAME
         LISP::RANDOM-STATE LISP::WARNING LISP::FTYPE
         LISP::FLOATING-POINT-INVALID-OPERATION LISP::PARSE-ERROR
         LISP::INT-CHAR LISP::LAMBDA-PARAMETERS-LIMIT
         LISP::GET-INTERNAL-RUN-TIME LISP::GET-INTERNAL-REAL-TIME
         LISP::SIGNED-BYTE LISP::VECTOR LISP::PACKAGE-ERROR
         LISP::DESCRIBE LISP::UNREAD-CHAR LISP::WRITE-STRING
         LISP::OTHERWISE LISP::SPECIFIC-CORRECTABLE-ERROR
         LISP::ARRAY-HAS-FILL-POINTER-P LISP::LOGORC1 LISP::PROVIDE
         LISP::THROW LISP::TYPE-ERROR LISP::FORMAT LISP::DEFPARAMETER
         LISP::REMF LISP::DEFINE-MODIFY-MACRO
         LISP::MOST-NEGATIVE-LONG-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-SHORT-FLOAT LISP::MULTIPLE-VALUE-CALL
         LISP::TYPE-OF LISP::TAG LISP::&AUX LISP::TAGBODY
         LISP::SIMPLE-STRING-P LISP::READTABLEP LISP::READTABLE
         LISP::ARRAY-DIMENSION LISP::FILE-ERROR LISP::SLEEP
         LISP::SYNONYM-STREAM LISP::MINUSP LISP::DELETE-FILE
         LISP::CELL-ERROR LISP::COPY-READTABLE LISP::NUMBER
         LISP::WRITE-CHAR LISP::RENAME-FILE LISP::UNSIGNED-SHORT
         LISP::STRUCTURE-OBJECT LISP::QUOTE LISP::CADR LISP::BOOLE-IOR
         LISP::LISTP LISP::CHARACTERP LISP::CHARACTER
         LISP::LISP-IMPLEMENTATION-TYPE LISP::LOGICAL-PATHNAME
         LISP::CDADDR LISP::TAILP LISP::CAADDR LISP::PATHNAME-TYPE
         LISP::PLUSP LISP::CASE LISP::MACHINE-TYPE LISP::LOAD
         LISP::ENDP LISP::FRESH-LINE LISP::DEFCONSTANT LISP::SYMBOL
         LISP::VALUES LISP::SET-DIFFERENCE LISP::*PRINT-ARRAY*
         LISP::SET-EXCLUSIVE-OR LISP::PROG2 LISP::DIVISION-BY-ZERO
         LISP::PHASE LISP::CAAAR LISP::ETYPECASE LISP::CTYPECASE
         LISP::NOT LISP::BOOLE-C2 LISP::NTH LISP::SPECIAL-OPERATOR-P
         LISP::STREAM-ELEMENT-TYPE LISP::IDENTITY LISP::*PRINT-RADIX*
         LISP::MEMBER LISP::SHORT-FLOAT LISP::NIL LISP::ACONS LISP::MOD
         LISP::EQL LISP::CADDR LISP::/// LISP::KEYWORDP LISP::COERCE
         LISP::BSD LISP::CHAR-FONT LISP::*PRINT-LEVEL* LISP::PROBE-FILE
         LISP::PATHNAME-DIRECTORY LISP::PROG1 LISP::STABLE-SORT
         LISP::SIMPLE-WARNING LISP::CONDITION LISP::SQRT LISP::REQUIRE
         LISP::GCD LISP::GETHASH LISP::ISQRT LISP::DEFVAR
         LISP::LAMBDA-CLOSURE LISP::STREAM LISP::REMOVE-IF
         LISP::DECLARATION LISP::APROPOS LISP::READ-LINE
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-SHORT-FLOAT LISP::LONG-SITE-NAME
         LISP::NSTRING-UPCASE LISP::LONG-FLOAT-NEGATIVE-EPSILON
         LISP::LONG-FLOAT-EPSILON LISP::*BREAK-ENABLE* LISP::BIT-NAND
         LISP::ALPHANUMERICP LISP::FROUND LISP::LAMBDA-LIST-KEYWORDS
         LISP::CDADAR LISP::LENGTH LISP::OR LISP::TWO-WAY-STREAM
         LISP::COSH LISP::CAADAR LISP::WRITE-BYTE LISP::RATIONALP
         LISP::FIND LISP::SUBSTITUTE-IF-NOT LISP::DEPOSIT-FIELD
         LISP::FLOATING-POINT-UNDERFLOW LISP::FLOATING-POINT-OVERFLOW
         LISP::WITH-OPEN-FILE LISP::BOOLE-ANDC2 LISP::IF LISP::RATIONAL
         LISP::PARSE-INTEGER LISP::SFUN LISP::MOST-POSITIVE-LONG-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-SHORT-FLOAT LISP::PSETQ LISP::COMPILE
         LISP::VALUES-LIST LISP::GRAPHIC-CHAR-P LISP::LOCALLY
         LISP::SIGNED-CHAR LISP::BOOLE-C1 LISP::FLOATP
         LISP::DOUBLE-FLOAT LISP::DEFTYPE LISP::UNEXPORT LISP::SYSTEM
         LISP::GFUN LISP::MAKE-ARRAY LISP::ROOM LISP::APROPOS-LIST
         LISP::ASIN LISP::SETQ LISP::CFUN LISP::CHAR>= LISP::SYMBOLP
         LISP::PATHNAMEP LISP::TIME LISP::VECTOR-POP LISP::LABELS
         LISP::TENTH LISP::SET-SYNTAX-FROM-CHAR LISP::TYPECASE
         LISP::NINTH LISP::WITH-PACKAGE-ITERATOR LISP::SYMBOL-PACKAGE
         LISP::FLOAT-RADIX LISP::*LINK-ARRAY* LISP::VECTORP
         LISP::REMOVE LISP::EVAL LISP::** LISP::CHAR-CODE
         LISP::YES-OR-NO-P LISP::INTEGER-DECODE-FLOAT LISP::APPEND
         LISP::DRIBBLE LISP::USER-HOMEDIR-PATHNAME LISP::RETURN-FROM
         LISP::CHAR-UPCASE LISP::STREAMP LISP::DOTIMES LISP::CHAR<=
         LISP::POSITIVE-FIXNUM LISP::UNBOUND-VARIABLE
         LISP::SIGNED-SHORT LISP::CONSTANTP LISP::COMPILER-LET
         LISP::FLOAT-PRECISION LISP::IMPORT LISP::*TRACE-OUTPUT*
         LISP::TERPRI LISP::&ALLOW-OTHER-KEYS LISP::PATHNAME-DEVICE
         LISP::CHAR-INT LISP::STRING-STREAM LISP::STRING LISP::DPB
         LISP::LDB LISP::CDR LISP::DOLIST LISP::DEFCFUN
         LISP::BOOLE-ANDC1 LISP::STYLE-WARNING LISP::BREAK
         LISP::CHAR-NOT-EQUAL LISP::PROGV LISP::*STANDARD-OUTPUT*
         LISP::FIXNUM LISP::NUNION LISP::*PRINT-READABLY*
         LISP::MULTIPLE-VALUE-SETQ LISP::PRIN1
         LISP::PACKAGE-USED-BY-LIST LISP::PACKAGE-USE-LIST LISP::SUBLIS
         LISP::SCHAR LISP::MAKE-ECHO-STREAM LISP::INLINE LISP::DECLAIM
         LISP::SCALE-FLOAT LISP::*PRINT-LENGTH* LISP::PROG
         LISP::SHORT-FLOAT-NEGATIVE-EPSILON LISP::SHORT-FLOAT-EPSILON
         LISP::&WHOLE LISP::INPUT-STREAM-P LISP::SIMPLE-BASE-STRING
         LISP::PROG* LISP::DECODE-UNIVERSAL-TIME
         LISP::WITH-OUTPUT-TO-STRING LISP::COMMONP LISP::EVENP
         LISP::DELETE LISP::SUBST LISP::FUNCALL LISP::CHAR-NOT-LESSP
         LISP::SGC LISP::COS LISP::PATHNAME LISP::NTHCDR
         LISP::COMPILATION-SPEED LISP::*BREAK-ON-WARNINGS*
         LISP::CLRHASH LISP::*PRINT-GENSYM* LISP::SIXTH
         LISP::MAKE-RANDOM-STATE LISP::FIRST LISP::LOGNOT LISP::ROUND
         LISP::AREF LISP::DIGIT-CHAR LISP::*** LISP::LOGNAND LISP::CDDR
         LISP::SEVENTH LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::DOUBLE-FLOAT-EPSILON LISP::VARIABLE
         LISP::LISP-IMPLEMENTATION-VERSION LISP::BIT-XOR LISP::RPLACD
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-SHORT-FLOAT LISP::FINISH-OUTPUT
         LISP::PROCLAIM LISP::MAKE-STRING LISP::BASE-STRING
         LISP::BSD386 LISP::MACHINE-VERSION LISP::*APPLYHOOK*
         LISP::LOGCOUNT LISP::REMOVE-IF-NOT LISP::LOGBITP LISP::SPEED
         LISP::BOOLE-AND LISP::STANDARD-METHOD LISP::STRINGP
         LISP::GET-SETF-METHOD LISP::SVREF LISP::DELETE-IF-NOT
         LISP::LISTEN LISP::FUNCTION LISP::CHAR-HYPER-BIT
         LISP::MEMBER-IF-NOT LISP::CHAR-SUPER-BIT LISP::SPACE
         LISP::CDAAR LISP::STANDARD-CHAR-P LISP::MERGE LISP::CHAR-NAME
         LISP::EXPORT LISP::CEILING LISP::SINGLE-FLOAT LISP::INT
         LISP::CHAR-META-BIT LISP::ACOS LISP::DESTRUCTURING-BIND
         LISP::CDDDR LISP::GMP LISP::ECASE LISP::MAP LISP::CCASE
         LISP::LAMBDA LISP::ALPHA-CHAR-P LISP::ASH LISP::BIT-AND
         LISP::SOFTWARE-TYPE LISP::AND LISP::FIND-ALL-SYMBOLS
         LISP::SECOND LISP::LOGEQV LISP::CHAR-BITS-LIMIT
         LISP::SHADOWING-IMPORT LISP::DOUBLE LISP::STEP LISP::FCEILING
         LISP::NULL LISP::REVERSE LISP::MACRO
         LISP::MOST-NEGATIVE-FIXNUM LISP::PACKAGEP LISP::NBUTLAST
         LISP::REVAPPEND LISP::STANDARD-CLASS LISP::FILL
         LISP::NSUBST-IF LISP::PI LISP::BY LISP::INTEGER
         LISP::NSTRING-CAPITALIZE LISP::EQ LISP::CHAR-BIT
         LISP::STRING-EQUAL LISP::REMPROP LISP::LAMBDA-BLOCK
         LISP::LDIFF LISP::&KEY LISP::RATIONALIZE LISP::FLOAT-SIGN
         LISP::READ-PRESERVING-WHITESPACE LISP::PUSHNEW
         LISP::GET-PROPERTIES LISP::CHAR> LISP::READ-FROM-STRING
         LISP::STRING-GREATERP LISP::DIRECTORY-NAMESTRING LISP::PSETF
         LISP::PPRINT LISP::DISASSEMBLE LISP::>= LISP::NSUBSTITUTE
         LISP::IN-PACKAGE LISP::BYE LISP::LCM LISP::<= LISP::DEFUN
         LISP::LONG-FLOAT LISP::ATAN LISP::MACROEXPAND-1
         LISP::DIRECTORY LISP::ARRAY-RANK LISP::SYMBOL-PLIST
         LISP::HASH-TABLE-P LISP::UNION LISP::MC68020 LISP::PRINT
         LISP::PROGN LISP::PATHNAME-HOST LISP::/= LISP::CHAR=
         LISP::*READ-BASE* LISP::FLOATING-POINT-INEXACT
         LISP::MAKE-SEQUENCE LISP::SIGNUM LISP::STREAM-ERROR
         LISP::LOGNOR LISP::1- LISP::RASSOC-IF-NOT LISP::SIMPLE-ARRAY
         LISP::NTH-VALUE LISP::RATIO LISP::STRING-LESSP
         LISP::CONCATENATED-STREAM LISP::REAL LISP::SUBSTITUTE
         LISP::DIGIT-CHAR-P LISP::CHAR< LISP::INTEGER-LENGTH
         LISP::EQUAL LISP::COPY-SYMBOL LISP::CHAR-DOWNCASE
         LISP::DECODE-FLOAT LISP::NCONC LISP::ROTATEF
         LISP::ARRAY-ROW-MAJOR-INDEX LISP::WITH-HASH-TABLE-ITERATOR
         LISP::CLOSE LISP::RANDOM LISP::ARRAY LISP::CATCH
         LISP::MERGE-PATHNAMES LISP::GET-OUTPUT-STREAM-STRING
         LISP::OBJECT LISP::PROGRAM-ERROR LISP::NINTERSECTION
         LISP::ASINH LISP::IGNORE LISP::BOOLE-CLR LISP::SET-CHAR-BIT
         LISP::BIT-NOT LISP::SINGLE-FLOAT-NEGATIVE-EPSILON
         LISP::SINGLE-FLOAT-EPSILON LISP::MULTIPLE-VALUE-LIST
         LISP::POSITION-IF-NOT LISP::SAVE LISP::BIT-VECTOR-P
         LISP::BIT-EQV LISP::FLOAT-DIGITS LISP::ARRAY-DISPLACEMENT
         LISP::FILE-POSITION LISP::BOTH-CASE-P LISP::RETURN
         LISP::MAPHASH LISP::MOST-POSITIVE-FIXNUM LISP::READ-BYTE
         LISP::COPY-TREE LISP::CHAR-GREATERP LISP::CHECK-TYPE
         LISP::MACHINE-INSTANCE LISP::CONSTANTLY LISP::FUNCTIONP
         LISP::EVERY LISP::STRING/= LISP::STRING>= LISP::STRING<=
         LISP::MAKE-HASH-TABLE LISP::*DEFAULT-PATHNAME-DEFAULTS*
         LISP::SIMPLE-CONDITION LISP::&REST LISP::SYMBOL-FUNCTION
         LISP::RPLACA LISP::*TERMINAL-IO* LISP::CHAR/=
         LISP::PRINT-NOT-READABLE LISP::CONS LISP::*EVAL-WHEN-COMPILE*
         LISP::CADAR LISP::SIMPLE-BIT-VECTOR LISP::READ-CHAR-NO-HANG
         LISP::CDDADR LISP::BIT-ANDC2 LISP::NSTRING-DOWNCASE
         LISP::CADADR LISP::BOOLE-NAND LISP::LOG LISP::STANDARD-CHAR
         LISP::DOCUMENTATION LISP::GET-UNIVERSAL-TIME LISP::BIT-NOR
         LISP::SPECIFIC-ERROR LISP::APPLYHOOK LISP::ARRAY-RANK-LIMIT
         LISP::ABS LISP::GBC LISP::&ENVIRONMENT LISP::PATHNAME-NAME
         LISP::BOOLEAN LISP::*READ-SUPPRESS* LISP::VOID
         LISP::PACKAGE-NAME LISP::COMPILE-FILE-PATHNAME LISP::SINH
         LISP::SYMBOL-VALUE LISP::STRING-RIGHT-TRIM LISP::SBIT
         LISP::REALP LISP::TANH LISP::MAKE-PATHNAME LISP::ASSOC
         LISP::DEFSETF LISP::ODDP LISP::UNWIND-PROTECT LISP::READ
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::COUNT-IF
         LISP::OUTPUT-STREAM-P LISP::BLOCK LISP::AKCL LISP::COPY-LIST
         LISP::ARRAY-IN-BOUNDS-P LISP::UNBOUND-SLOT LISP::SET
         LISP::HASH-TABLE-TEST LISP::PACKAGE-SHADOWING-SYMBOLS
         LISP::ADJUST-ARRAY LISP::EXP LISP::TYPE LISP::FILE-WRITE-DATE
         LISP::MAKE-LIST LISP::LET LISP::FORCE-OUTPUT LISP::CDDAAR
         LISP::BIT-ANDC1 LISP::GET LISP::ARITHMETIC-ERROR LISP::CADAAR
         LISP::BIT LISP::KCL LISP::&OPTIONAL LISP::GCL
         LISP::FILE-AUTHOR LISP::NSUBLIS LISP::*PRINT-CIRCLE*
         LISP::*MODULES* LISP::BUILT-IN-CLASS LISP::*READTABLE*
         LISP::SORT LISP::MAPCON LISP::*MACROEXPAND-HOOK* LISP::PUSH
         LISP::POSITION-IF LISP::SUBSETP LISP::CAAR LISP::BOOLE-SET
         LISP::STRING-CHAR-P LISP::*LOAD-VERBOSE* LISP::STRING-DOWNCASE
         LISP::STRING-UPCASE LISP::DELETE-IF LISP::HOST-NAMESTRING
         LISP::STRING-LEFT-TRIM LISP::CALL-ARGUMENTS-LIMIT
         LISP::DEFENTRY LISP::CLEAR-INPUT LISP::DO-SYMBOLS
         LISP::STRUCTURE-CLASS LISP::MISMATCH LISP::MAPL
         LISP::MULTIPLE-VALUE-PROG1 LISP::REALPART LISP::NSUBSTITUTE-IF
         LISP::COND LISP::PACKAGE-NICKNAMES LISP::COMPILED-FUNCTION-P
         LISP::CONSP LISP::SATISFIES LISP::&BODY LISP::MAP-INTO
         LISP::FLOAT LISP::SIMPLE-TYPE-ERROR LISP::ED LISP::ERROR
         LISP::ACOSH LISP::WHEN LISP::OPEN LISP::THE LISP::BIT-IOR
         LISP::MAPCAR LISP::PATHNAME-VERSION LISP::*RANDOM-STATE*
         LISP::SEQUENCE LISP::CAADR LISP::SUBTYPEP LISP::MASK-FIELD
         LISP::FIND-SYMBOL LISP::INCF LISP::SOME
         LISP::SIMPLE-BIT-VECTOR-P LISP::FIND-PACKAGE LISP::*DEBUG-IO*
         LISP::POSITION LISP::GET-DECODED-TIME LISP::ARRAY-ELEMENT-TYPE
         LISP::LET* LISP::TRUNCATE_USE_C LISP::COMPLEMENT
         LISP::EVALHOOK LISP::COMPILED-FUNCTION LISP::ARRAY-DIMENSIONS
         LISP::BOOLE-EQV LISP::*ERROR-OUTPUT* LISP::EXTENDED-CHAR
         LISP::STRUCTURE LISP::NREVERSE LISP::ADJOIN
         LISP::NSET-EXCLUSIVE-OR LISP::METHOD LISP::T LISP::COMMON
         LISP::BOOLE-ORC2 LISP::BOOLE-ORC1 LISP::ARRAY-TOTAL-SIZE-LIMIT
         LISP::LOGIOR LISP::CERROR LISP::FIFTH LISP::ASSERT
         LISP::CLEAR-OUTPUT LISP::HASH-TABLE LISP::CLINES LISP::BOOLE
         LISP::BOOLE-XOR LISP::ARRAY-DIMENSION-LIMIT
         LISP::DO-ALL-SYMBOLS LISP::COMPILE-FILE LISP::*FEATURES*
         LISP::LOGAND LISP::REPLACE LISP::> LISP::= LISP::<
         LISP::LOGANDC2 LISP::MAKE-TWO-WAY-STREAM LISP::PROCLAMATION
         LISP::TYPEP LISP::SIN LISP::BUTLAST LISP::MACROEXPAND
         LISP::SETF LISP::FLOOR LISP::STRING-NOT-EQUAL LISP::TAN
         LISP::SPECIAL LISP::MIN LISP::CODE-CHAR LISP::/ LISP::-
         LISP::ATANH LISP::+ LISP::* LISP::MAKUNBOUND LISP::*PACKAGE*
         LISP::GETF LISP::PEEK-CHAR LISP::READ-CHAR
         LISP::STRING-NOT-GREATERP LISP::ENOUGH-NAMESTRING LISP::SUBSEQ
         LISP::NAME-CHAR LISP::MAKE-CHAR LISP::BASE-CHAR
         LISP::FTRUNCATE LISP::UNUSE-PACKAGE LISP::THIRD LISP::PAIRLIS
         LISP::EXPT LISP::GENTEMP LISP::LAMBDA-BLOCK-CLOSURE
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::LOOP LISP::KEYWORD
         LISP::GET-SETF-METHOD-MULTIPLE-VALUE LISP::NSUBSTITUTE-IF-NOT
         LISP::*PRINT-CASE* LISP::*PRINT-BASE* LISP::*PRINT-ESCAPE*
         LISP::BYTE-SIZE LISP::EIGHTH LISP::CHAR-LESSP
         LISP::CLX-LITTLE-ENDIAN LISP::HASH-TABLE-COUNT
         LISP::INTERNAL-TIME-UNITS-PER-SECOND LISP::TREE-EQUAL
         LISP::WRITE-TO-STRING LISP::STANDARD-GENERIC-FUNCTION
         LISP::FILL-POINTER LISP::STRING-NOT-LESSP LISP::CLASS
         LISP::PRINC-TO-STRING LISP::PRIN1-TO-STRING))

;;; Definitions for package ITERATE of type SHADOW
(LISP::IN-PACKAGE "ITERATE")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::CDDAR LISP::SHIFTF LISP::REMHASH LISP::CHAR-EQUAL
         LISP::NOTEVERY LISP::TRUNCATE LISP::SEARCH
         LISP::SPECIAL-FORM-P LISP::MAKE-BROADCAST-STREAM LISP::CDDDDR
         LISP::UNLESS LISP::INTERN LISP::CADDDR LISP::LOGANDC1
         LISP::READ-DELIMITED-LIST LISP::END-OF-FILE
         WALKER::VARIABLE-LEXICAL-P LISP::APPLY LISP::SUBST-IF-NOT
         LISP::CIS LISP::ADJUSTABLE-ARRAY-P LISP::SUBSTITUTE-IF
         LISP::FILE-STREAM LISP::QUIT
         LISP::MAKE-DISPATCH-MACRO-CHARACTER LISP::CONTROL-ERROR
         LISP::MAKE-STRING-OUTPUT-STREAM LISP::MAKE-STRING-INPUT-STREAM
         LISP::*STANDARD-INPUT* LISP::STANDARD-OBJECT LISP::GENSYM
         LISP::EQUALP LISP::DELETE-PACKAGE LISP::COMPLEXP
         SYSTEM::ALLOCATE LISP::MULTIPLE-VALUE-BIND LISP::CDAADR
         LISP::VECTOR-PUSH-EXTEND LISP::RENAME-PACKAGE LISP::CAAADR
         LISP::*EVALHOOK* LISP::UNTRACE LISP::STRING-CHAR LISP::KYOTO
         LISP::INTEGERP LISP::DENOMINATOR LISP::FLET LISP::HELP
         LISP::WITH-INPUT-FROM-STRING LISP::SHORT-SITE-NAME
         LISP::FILE-NAMESTRING LISP::WRITE-LINE LISP::UNINTERN
         LISP::PRINC LISP::SIMPLE-VECTOR LISP::NSUBST LISP::FBOUNDP
         LISP::SIMPLE-STRING LISP::SPICE LISP::TRACE
         LISP::METHOD-COMBINATION LISP::BOUNDP LISP::SYMBOL-NAME
         LISP::WITH-OPEN-STREAM LISP::UNSIGNED-BYTE LISP::HELP*
         LISP::NOTINLINE LISP::GET-MACRO-CHARACTER
         LISP::SET-MACRO-CHARACTER LISP::POP LISP::LIST-ALL-PACKAGES
         WALKER::VARIABLE-DECLARATION LISP::UNDEFINED-FUNCTION
         LISP::IEEE-FLOATING-POINT LISP::INTERSECTION LISP::CCLOSURE
         LISP::BOOLE-2 LISP::LOGTEST LISP::*QUERY-IO* LISP::MAX
         LISP::DEFSTRUCT LISP::CDDDAR LISP::ELT LISP::INSPECT
         LISP::CADDAR LISP::LIST-LENGTH LISP::NSET-DIFFERENCE
         LISP::STRING-CAPITALIZE LISP::ASSOC-IF-NOT LISP::+++
         LISP::BYTE LISP::CHAR LISP::CONJUGATE LISP::CHAR-FONT-LIMIT
         LISP::CHAR-CODE-LIMIT LISP::SERIOUS-CONDITION LISP::CDAR
         LISP::COPY-ALIST LISP::FILE-LENGTH LISP::DECLARE LISP::BOOLE-1
         LISP::RANDOM-STATE-P LISP::VECTOR-PUSH LISP::USE-PACKAGE
         LISP::CHAR-BITS LISP::GENERIC-FUNCTION LISP::IMAGPART
         LISP::BROADCAST-STREAM LISP::CDAAAR LISP::CAAAAR
         LISP::GET-DISPATCH-MACRO-CHARACTER
         LISP::SET-DISPATCH-MACRO-CHARACTER LISP::STRING> LISP::GO
         LISP::NSUBST-IF-NOT LISP::FOURTH LISP::DEFINE-SETF-METHOD
         LISP::DO LISP::STORAGE-CONDITION LISP::BIT-ORC2
         LISP::STRING-TRIM LISP::MAPC LISP::PACKAGE LISP::NUMERATOR
         LISP::MACROLET LISP::HASH-TABLE-SIZE LISP::LDB-TEST
         LISP::READER-ERROR LISP::ROW-MAJOR-AREF
         LISP::CHAR-NOT-GREATERP LISP::REM LISP::ARRAYP LISP::CDADR
         LISP::FFLOOR LISP::SUBST-IF LISP::FIND-IF LISP::MAKE-SYMBOL
         LISP::MAKE-PACKAGE LISP::STRING= LISP::MAPLIST LISP::WRITE
         LISP::ATOM LISP::BIT-VECTOR LISP::DECF LISP::LOGXOR
         LISP::MULTIPLE-VALUES-LIMIT LISP::OPTIMIZE LISP::REST
         LISP::FIND-IF-NOT LISP::COUNT LISP::FMAKUNBOUND LISP::LIST
         LISP::BOOLE-NOR LISP::ZEROP LISP::// LISP::RASSOC LISP::1+
         LISP::RASSOC-IF LISP::NOTANY LISP::LAST LISP::*PRINT-PRETTY*
         LISP::MAPCAN LISP::DEFMACRO LISP::SHADOW LISP::NRECONC
         LISP::++ LISP::LIST* LISP::STRING< LISP::SOFTWARE-VERSION
         LISP::*GENSYM-COUNTER* LISP::REMOVE-DUPLICATES
         LISP::PARSE-NAMESTRING LISP::UPPER-CASE-P
         LISP::MAKE-CONCATENATED-STREAM LISP::DO-EXTERNAL-SYMBOLS
         LISP::CONCATENATE LISP::CHAR-CONTROL-BIT LISP::WARN
         LISP::BIGNUM LISP::SIMPLE-VECTOR-P LISP::DELETE-DUPLICATES
         LISP::NAMESTRING LISP::BIT-ORC1 LISP::SAFETY LISP::MEMBER-IF
         LISP::COPY-SEQ LISP::ECHO-STREAM LISP::Y-OR-N-P LISP::COMPLEX
         LISP::COUNT-IF-NOT LISP::REDUCE LISP::ASSOC-IF
         LISP::MACRO-FUNCTION LISP::MAKE-SYNONYM-STREAM LISP::NUMBERP
         LISP::SXHASH LISP::CAR LISP::LOGORC2 LISP::UNSIGNED-CHAR
         LISP::BYTE-POSITION LISP::UNIX LISP::DEFLA
         LISP::ENCODE-UNIVERSAL-TIME LISP::LOWER-CASE-P LISP::EVAL-WHEN
         LISP::ARRAY-TOTAL-SIZE LISP::DO* LISP::TRUENAME
         LISP::RANDOM-STATE LISP::WARNING LISP::FTYPE
         LISP::FLOATING-POINT-INVALID-OPERATION LISP::PARSE-ERROR
         LISP::INT-CHAR LISP::LAMBDA-PARAMETERS-LIMIT
         LISP::GET-INTERNAL-RUN-TIME LISP::GET-INTERNAL-REAL-TIME
         LISP::SIGNED-BYTE LISP::VECTOR LISP::PACKAGE-ERROR
         LISP::DESCRIBE LISP::UNREAD-CHAR LISP::WRITE-STRING
         LISP::OTHERWISE LISP::SPECIFIC-CORRECTABLE-ERROR
         LISP::ARRAY-HAS-FILL-POINTER-P LISP::LOGORC1 LISP::PROVIDE
         LISP::THROW LISP::TYPE-ERROR LISP::FORMAT LISP::DEFPARAMETER
         LISP::REMF LISP::DEFINE-MODIFY-MACRO
         LISP::MOST-NEGATIVE-LONG-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-SHORT-FLOAT LISP::MULTIPLE-VALUE-CALL
         LISP::TYPE-OF LISP::TAG LISP::&AUX LISP::TAGBODY
         LISP::SIMPLE-STRING-P LISP::READTABLEP LISP::READTABLE
         LISP::ARRAY-DIMENSION LISP::FILE-ERROR LISP::SLEEP
         LISP::SYNONYM-STREAM LISP::MINUSP LISP::DELETE-FILE
         LISP::CELL-ERROR LISP::COPY-READTABLE LISP::NUMBER
         LISP::WRITE-CHAR LISP::RENAME-FILE LISP::UNSIGNED-SHORT
         LISP::STRUCTURE-OBJECT LISP::QUOTE LISP::CADR LISP::BOOLE-IOR
         LISP::LISTP LISP::CHARACTERP LISP::CHARACTER
         LISP::LISP-IMPLEMENTATION-TYPE LISP::LOGICAL-PATHNAME
         LISP::CDADDR LISP::TAILP LISP::CAADDR LISP::PATHNAME-TYPE
         LISP::PLUSP LISP::CASE LISP::MACHINE-TYPE LISP::LOAD
         LISP::ENDP LISP::FRESH-LINE LISP::DEFCONSTANT LISP::SYMBOL
         LISP::VALUES LISP::SET-DIFFERENCE LISP::*PRINT-ARRAY*
         LISP::SET-EXCLUSIVE-OR LISP::PROG2 LISP::DIVISION-BY-ZERO
         LISP::PHASE LISP::CAAAR LISP::ETYPECASE LISP::CTYPECASE
         LISP::NOT LISP::BOOLE-C2 LISP::NTH LISP::SPECIAL-OPERATOR-P
         LISP::STREAM-ELEMENT-TYPE LISP::IDENTITY LISP::*PRINT-RADIX*
         LISP::MEMBER LISP::SHORT-FLOAT LISP::NIL LISP::ACONS LISP::MOD
         LISP::EQL LISP::CADDR LISP::/// LISP::KEYWORDP LISP::COERCE
         LISP::BSD LISP::CHAR-FONT LISP::*PRINT-LEVEL* LISP::PROBE-FILE
         LISP::PATHNAME-DIRECTORY LISP::PROG1 LISP::STABLE-SORT
         LISP::SIMPLE-WARNING LISP::CONDITION LISP::SQRT LISP::REQUIRE
         LISP::GCD LISP::GETHASH LISP::ISQRT LISP::DEFVAR
         LISP::LAMBDA-CLOSURE LISP::STREAM LISP::REMOVE-IF
         LISP::DECLARATION LISP::APROPOS LISP::READ-LINE
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-SHORT-FLOAT LISP::LONG-SITE-NAME
         LISP::NSTRING-UPCASE LISP::LONG-FLOAT-NEGATIVE-EPSILON
         LISP::LONG-FLOAT-EPSILON LISP::*BREAK-ENABLE* LISP::BIT-NAND
         LISP::ALPHANUMERICP LISP::FROUND LISP::LAMBDA-LIST-KEYWORDS
         LISP::CDADAR LISP::LENGTH LISP::OR
         WALKER::VARIABLE-GLOBALLY-SPECIAL-P LISP::TWO-WAY-STREAM
         LISP::COSH LISP::CAADAR LISP::WRITE-BYTE LISP::RATIONALP
         LISP::FIND LISP::SUBSTITUTE-IF-NOT LISP::DEPOSIT-FIELD
         LISP::FLOATING-POINT-UNDERFLOW LISP::FLOATING-POINT-OVERFLOW
         LISP::WITH-OPEN-FILE LISP::BOOLE-ANDC2 LISP::IF LISP::RATIONAL
         LISP::PARSE-INTEGER LISP::SFUN LISP::MOST-POSITIVE-LONG-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-SHORT-FLOAT LISP::PSETQ LISP::COMPILE
         LISP::VALUES-LIST LISP::GRAPHIC-CHAR-P LISP::LOCALLY
         LISP::SIGNED-CHAR LISP::BOOLE-C1 LISP::FLOATP
         LISP::DOUBLE-FLOAT LISP::DEFTYPE LISP::UNEXPORT LISP::SYSTEM
         LISP::GFUN LISP::MAKE-ARRAY LISP::ROOM LISP::APROPOS-LIST
         LISP::ASIN LISP::SETQ LISP::CFUN LISP::CHAR>= LISP::SYMBOLP
         LISP::PATHNAMEP LISP::TIME LISP::VECTOR-POP LISP::LABELS
         LISP::TENTH LISP::SET-SYNTAX-FROM-CHAR LISP::TYPECASE
         LISP::NINTH LISP::WITH-PACKAGE-ITERATOR LISP::SYMBOL-PACKAGE
         LISP::FLOAT-RADIX LISP::*LINK-ARRAY* LISP::VECTORP
         LISP::REMOVE LISP::EVAL LISP::**
         WALKER::*VARIABLE-DECLARATIONS* LISP::CHAR-CODE
         LISP::YES-OR-NO-P LISP::INTEGER-DECODE-FLOAT LISP::APPEND
         LISP::DRIBBLE LISP::USER-HOMEDIR-PATHNAME LISP::RETURN-FROM
         LISP::CHAR-UPCASE LISP::STREAMP LISP::DOTIMES LISP::CHAR<=
         LISP::POSITIVE-FIXNUM LISP::UNBOUND-VARIABLE
         LISP::SIGNED-SHORT LISP::CONSTANTP LISP::COMPILER-LET
         LISP::FLOAT-PRECISION LISP::IMPORT LISP::*TRACE-OUTPUT*
         LISP::TERPRI LISP::&ALLOW-OTHER-KEYS LISP::PATHNAME-DEVICE
         LISP::CHAR-INT LISP::STRING-STREAM WALKER::WALK-FORM
         LISP::STRING LISP::DPB LISP::LDB LISP::CDR LISP::DOLIST
         LISP::DEFCFUN LISP::BOOLE-ANDC1 LISP::STYLE-WARNING
         LISP::BREAK LISP::CHAR-NOT-EQUAL LISP::PROGV
         LISP::*STANDARD-OUTPUT* LISP::FIXNUM LISP::NUNION
         LISP::*PRINT-READABLY* LISP::MULTIPLE-VALUE-SETQ LISP::PRIN1
         LISP::PACKAGE-USED-BY-LIST LISP::PACKAGE-USE-LIST LISP::SUBLIS
         LISP::SCHAR LISP::MAKE-ECHO-STREAM LISP::INLINE LISP::DECLAIM
         LISP::SCALE-FLOAT LISP::*PRINT-LENGTH* LISP::PROG
         LISP::SHORT-FLOAT-NEGATIVE-EPSILON LISP::SHORT-FLOAT-EPSILON
         LISP::&WHOLE LISP::INPUT-STREAM-P LISP::SIMPLE-BASE-STRING
         LISP::PROG* LISP::DECODE-UNIVERSAL-TIME
         LISP::WITH-OUTPUT-TO-STRING LISP::COMMONP LISP::EVENP
         LISP::DELETE LISP::SUBST LISP::FUNCALL LISP::CHAR-NOT-LESSP
         LISP::SGC LISP::COS LISP::PATHNAME LISP::NTHCDR
         LISP::COMPILATION-SPEED LISP::*BREAK-ON-WARNINGS*
         LISP::CLRHASH LISP::*PRINT-GENSYM* LISP::SIXTH
         LISP::MAKE-RANDOM-STATE LISP::FIRST LISP::LOGNOT LISP::ROUND
         LISP::AREF LISP::DIGIT-CHAR LISP::*** LISP::LOGNAND LISP::CDDR
         LISP::SEVENTH LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::DOUBLE-FLOAT-EPSILON LISP::VARIABLE
         LISP::LISP-IMPLEMENTATION-VERSION LISP::BIT-XOR LISP::RPLACD
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-SHORT-FLOAT LISP::FINISH-OUTPUT
         LISP::PROCLAIM LISP::MAKE-STRING LISP::BASE-STRING
         LISP::BSD386 LISP::MACHINE-VERSION LISP::*APPLYHOOK*
         LISP::LOGCOUNT LISP::REMOVE-IF-NOT LISP::LOGBITP LISP::SPEED
         LISP::BOOLE-AND LISP::STANDARD-METHOD LISP::STRINGP
         LISP::GET-SETF-METHOD LISP::SVREF LISP::DELETE-IF-NOT
         LISP::LISTEN LISP::FUNCTION LISP::CHAR-HYPER-BIT
         LISP::MEMBER-IF-NOT LISP::CHAR-SUPER-BIT LISP::SPACE
         LISP::CDAAR LISP::STANDARD-CHAR-P LISP::MERGE LISP::CHAR-NAME
         LISP::EXPORT LISP::CEILING LISP::SINGLE-FLOAT LISP::INT
         LISP::CHAR-META-BIT LISP::ACOS LISP::DESTRUCTURING-BIND
         LISP::CDDDR LISP::GMP LISP::ECASE LISP::MAP LISP::CCASE
         LISP::LAMBDA LISP::ALPHA-CHAR-P LISP::ASH LISP::BIT-AND
         WALKER::NESTED-WALK-FORM LISP::SOFTWARE-TYPE LISP::AND
         LISP::FIND-ALL-SYMBOLS LISP::SECOND LISP::LOGEQV
         LISP::CHAR-BITS-LIMIT LISP::SHADOWING-IMPORT LISP::DOUBLE
         LISP::STEP LISP::FCEILING LISP::NULL LISP::REVERSE LISP::MACRO
         LISP::MOST-NEGATIVE-FIXNUM LISP::PACKAGEP LISP::NBUTLAST
         LISP::REVAPPEND LISP::STANDARD-CLASS LISP::FILL
         LISP::NSUBST-IF LISP::PI LISP::BY LISP::INTEGER
         LISP::NSTRING-CAPITALIZE LISP::EQ LISP::CHAR-BIT
         LISP::STRING-EQUAL LISP::REMPROP LISP::LAMBDA-BLOCK
         LISP::LDIFF LISP::&KEY LISP::RATIONALIZE LISP::FLOAT-SIGN
         LISP::READ-PRESERVING-WHITESPACE LISP::PUSHNEW
         LISP::GET-PROPERTIES LISP::CHAR> LISP::READ-FROM-STRING
         LISP::STRING-GREATERP LISP::DIRECTORY-NAMESTRING LISP::PSETF
         LISP::PPRINT LISP::DISASSEMBLE LISP::>= LISP::NSUBSTITUTE
         LISP::IN-PACKAGE LISP::BYE LISP::LCM LISP::<= LISP::DEFUN
         LISP::LONG-FLOAT LISP::ATAN LISP::MACROEXPAND-1
         LISP::DIRECTORY LISP::ARRAY-RANK LISP::SYMBOL-PLIST
         LISP::HASH-TABLE-P LISP::UNION LISP::MC68020 LISP::PRINT
         LISP::PROGN LISP::PATHNAME-HOST LISP::/= LISP::CHAR=
         LISP::*READ-BASE* LISP::FLOATING-POINT-INEXACT
         LISP::MAKE-SEQUENCE LISP::SIGNUM LISP::STREAM-ERROR
         LISP::LOGNOR LISP::1- LISP::RASSOC-IF-NOT LISP::SIMPLE-ARRAY
         LISP::NTH-VALUE LISP::RATIO LISP::STRING-LESSP
         LISP::CONCATENATED-STREAM LISP::REAL LISP::SUBSTITUTE
         LISP::DIGIT-CHAR-P LISP::CHAR< LISP::INTEGER-LENGTH
         LISP::EQUAL LISP::COPY-SYMBOL LISP::CHAR-DOWNCASE
         LISP::DECODE-FLOAT LISP::NCONC LISP::ROTATEF
         LISP::ARRAY-ROW-MAJOR-INDEX LISP::WITH-HASH-TABLE-ITERATOR
         LISP::CLOSE LISP::RANDOM LISP::ARRAY LISP::CATCH
         LISP::MERGE-PATHNAMES LISP::GET-OUTPUT-STREAM-STRING
         LISP::OBJECT LISP::PROGRAM-ERROR LISP::NINTERSECTION
         LISP::ASINH LISP::IGNORE LISP::BOOLE-CLR LISP::SET-CHAR-BIT
         LISP::BIT-NOT WALKER::MACROEXPAND-ALL
         LISP::SINGLE-FLOAT-NEGATIVE-EPSILON LISP::SINGLE-FLOAT-EPSILON
         LISP::MULTIPLE-VALUE-LIST LISP::POSITION-IF-NOT LISP::SAVE
         LISP::BIT-VECTOR-P LISP::BIT-EQV LISP::FLOAT-DIGITS
         LISP::ARRAY-DISPLACEMENT LISP::FILE-POSITION LISP::BOTH-CASE-P
         LISP::RETURN LISP::MAPHASH LISP::MOST-POSITIVE-FIXNUM
         LISP::READ-BYTE LISP::COPY-TREE LISP::CHAR-GREATERP
         LISP::CHECK-TYPE LISP::MACHINE-INSTANCE LISP::CONSTANTLY
         LISP::FUNCTIONP LISP::EVERY LISP::STRING/= LISP::STRING>=
         LISP::STRING<= LISP::MAKE-HASH-TABLE
         LISP::*DEFAULT-PATHNAME-DEFAULTS* LISP::SIMPLE-CONDITION
         LISP::&REST LISP::SYMBOL-FUNCTION LISP::RPLACA
         LISP::*TERMINAL-IO* LISP::CHAR/= LISP::PRINT-NOT-READABLE
         LISP::CONS LISP::*EVAL-WHEN-COMPILE* LISP::CADAR
         LISP::SIMPLE-BIT-VECTOR LISP::READ-CHAR-NO-HANG LISP::CDDADR
         LISP::BIT-ANDC2 LISP::NSTRING-DOWNCASE LISP::CADADR
         LISP::BOOLE-NAND LISP::LOG LISP::STANDARD-CHAR
         LISP::DOCUMENTATION LISP::GET-UNIVERSAL-TIME LISP::BIT-NOR
         LISP::SPECIFIC-ERROR LISP::APPLYHOOK LISP::ARRAY-RANK-LIMIT
         LISP::ABS LISP::GBC LISP::&ENVIRONMENT LISP::PATHNAME-NAME
         LISP::BOOLEAN LISP::*READ-SUPPRESS* LISP::VOID
         LISP::PACKAGE-NAME LISP::COMPILE-FILE-PATHNAME LISP::SINH
         LISP::SYMBOL-VALUE LISP::STRING-RIGHT-TRIM LISP::SBIT
         LISP::REALP LISP::TANH LISP::MAKE-PATHNAME LISP::ASSOC
         LISP::DEFSETF LISP::ODDP LISP::UNWIND-PROTECT LISP::READ
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::COUNT-IF
         LISP::OUTPUT-STREAM-P LISP::BLOCK LISP::AKCL LISP::COPY-LIST
         LISP::ARRAY-IN-BOUNDS-P LISP::UNBOUND-SLOT LISP::SET
         LISP::HASH-TABLE-TEST LISP::PACKAGE-SHADOWING-SYMBOLS
         LISP::ADJUST-ARRAY LISP::EXP LISP::TYPE LISP::FILE-WRITE-DATE
         LISP::MAKE-LIST LISP::LET LISP::FORCE-OUTPUT LISP::CDDAAR
         LISP::BIT-ANDC1 LISP::GET LISP::ARITHMETIC-ERROR LISP::CADAAR
         LISP::BIT LISP::KCL LISP::&OPTIONAL LISP::GCL
         LISP::FILE-AUTHOR LISP::NSUBLIS LISP::*PRINT-CIRCLE*
         LISP::*MODULES* LISP::BUILT-IN-CLASS LISP::*READTABLE*
         LISP::SORT LISP::MAPCON LISP::*MACROEXPAND-HOOK* LISP::PUSH
         LISP::POSITION-IF LISP::SUBSETP LISP::CAAR LISP::BOOLE-SET
         LISP::STRING-CHAR-P LISP::*LOAD-VERBOSE* LISP::STRING-DOWNCASE
         LISP::STRING-UPCASE LISP::DELETE-IF LISP::HOST-NAMESTRING
         LISP::STRING-LEFT-TRIM LISP::CALL-ARGUMENTS-LIMIT
         LISP::DEFENTRY LISP::CLEAR-INPUT LISP::DO-SYMBOLS
         LISP::STRUCTURE-CLASS LISP::MISMATCH LISP::MAPL
         LISP::MULTIPLE-VALUE-PROG1 LISP::REALPART LISP::NSUBSTITUTE-IF
         LISP::COND LISP::PACKAGE-NICKNAMES LISP::COMPILED-FUNCTION-P
         LISP::CONSP WALKER::WALK-FORM-EXPAND-MACROS-P LISP::SATISFIES
         LISP::&BODY LISP::MAP-INTO LISP::FLOAT LISP::SIMPLE-TYPE-ERROR
         LISP::ED LISP::ERROR LISP::ACOSH
         WALKER::DEFINE-WALKER-TEMPLATE LISP::WHEN LISP::OPEN LISP::THE
         LISP::BIT-IOR LISP::MAPCAR LISP::PATHNAME-VERSION
         LISP::*RANDOM-STATE* LISP::SEQUENCE LISP::CAADR LISP::SUBTYPEP
         LISP::MASK-FIELD LISP::FIND-SYMBOL LISP::INCF LISP::SOME
         LISP::SIMPLE-BIT-VECTOR-P LISP::FIND-PACKAGE LISP::*DEBUG-IO*
         LISP::POSITION LISP::GET-DECODED-TIME LISP::ARRAY-ELEMENT-TYPE
         LISP::LET* LISP::TRUNCATE_USE_C LISP::COMPLEMENT
         LISP::EVALHOOK LISP::COMPILED-FUNCTION LISP::ARRAY-DIMENSIONS
         LISP::BOOLE-EQV LISP::*ERROR-OUTPUT* LISP::EXTENDED-CHAR
         LISP::STRUCTURE LISP::NREVERSE LISP::ADJOIN
         LISP::NSET-EXCLUSIVE-OR LISP::METHOD LISP::T LISP::COMMON
         LISP::BOOLE-ORC2 LISP::BOOLE-ORC1 LISP::ARRAY-TOTAL-SIZE-LIMIT
         LISP::LOGIOR LISP::CERROR LISP::FIFTH LISP::ASSERT
         LISP::CLEAR-OUTPUT LISP::HASH-TABLE LISP::CLINES LISP::BOOLE
         LISP::BOOLE-XOR LISP::ARRAY-DIMENSION-LIMIT
         LISP::DO-ALL-SYMBOLS LISP::COMPILE-FILE LISP::*FEATURES*
         LISP::LOGAND LISP::REPLACE LISP::> LISP::= LISP::<
         LISP::LOGANDC2 LISP::MAKE-TWO-WAY-STREAM LISP::PROCLAMATION
         LISP::TYPEP LISP::SIN LISP::BUTLAST LISP::MACROEXPAND
         LISP::SETF LISP::FLOOR LISP::STRING-NOT-EQUAL LISP::TAN
         LISP::SPECIAL LISP::MIN LISP::CODE-CHAR LISP::/ LISP::-
         LISP::ATANH LISP::+ LISP::* LISP::MAKUNBOUND LISP::*PACKAGE*
         LISP::GETF LISP::PEEK-CHAR LISP::READ-CHAR
         LISP::STRING-NOT-GREATERP LISP::ENOUGH-NAMESTRING LISP::SUBSEQ
         LISP::NAME-CHAR LISP::MAKE-CHAR LISP::BASE-CHAR
         LISP::FTRUNCATE LISP::UNUSE-PACKAGE LISP::THIRD LISP::PAIRLIS
         LISP::EXPT LISP::GENTEMP LISP::LAMBDA-BLOCK-CLOSURE
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::LOOP LISP::KEYWORD
         LISP::GET-SETF-METHOD-MULTIPLE-VALUE LISP::NSUBSTITUTE-IF-NOT
         LISP::*PRINT-CASE* LISP::*PRINT-BASE* LISP::*PRINT-ESCAPE*
         LISP::BYTE-SIZE LISP::EIGHTH LISP::CHAR-LESSP
         WALKER::VARIABLE-SPECIAL-P LISP::CLX-LITTLE-ENDIAN
         LISP::HASH-TABLE-COUNT LISP::INTERNAL-TIME-UNITS-PER-SECOND
         LISP::TREE-EQUAL LISP::WRITE-TO-STRING
         LISP::STANDARD-GENERIC-FUNCTION LISP::FILL-POINTER
         LISP::STRING-NOT-LESSP LISP::CLASS LISP::PRINC-TO-STRING
         LISP::PRIN1-TO-STRING))

;;; Definitions for package PCL of type SHADOW
(LISP::IN-PACKAGE "PCL")
(LISP::SHADOW '( PCL::DOTIMES PCL::DOCUMENTATION PCL::DOCUMENTATION))
(LISP::SHADOWING-IMPORT
    '( LISP::DOTIMES LISP::DOTIMES))
(LISP::IMPORT
    '(LISP::STANDARD-CLASS LISP::STRUCTURE-CLASS LISP::STANDARD-METHOD
         LISP::GENERIC-FUNCTION LISP::STANDARD-GENERIC-FUNCTION
         LISP::STANDARD-OBJECT LISP::BUILT-IN-CLASS
         LISP::METHOD-COMBINATION LISP::METHOD LISP::OTHERWISE
         LISP::SIMPLE-CONDITION LISP::FLOOR LISP::NSUBLIS
         LISP::YES-OR-NO-P LISP::CLOSE LISP::WITH-INPUT-FROM-STRING
         LISP::EQL LISP::*APPLYHOOK* LISP::MASK-FIELD LISP::*DEBUG-IO*
         LISP::VOID LISP::RANDOM-STATE-P LISP::DELETE-FILE
         LISP::WITH-HASH-TABLE-ITERATOR LISP::FLOAT LISP::RENAME-FILE
         LISP::LAMBDA-BLOCK LISP::RANDOM-STATE LISP::UPPER-CASE-P
         LISP::GO LISP::GRAPHIC-CHAR-P LISP::DO LISP::PATHNAME-TYPE
         LISP::STANDARD-CHAR LISP::PROCLAIM LISP::BLOCK
         LISP::LOWER-CASE-P LISP::// LISP::UNIX LISP::*PRINT-READABLY*
         LISP::CEILING LISP::SIMPLE-BASE-STRING LISP::NOT
         LISP::PATHNAME-NAME LISP::MULTIPLE-VALUE-BIND
         LISP::*TRACE-OUTPUT* LISP::USE-PACKAGE LISP::PATHNAME-DEVICE
         LISP::SUBSEQ LISP::SET-EXCLUSIVE-OR LISP::GENSYM
         LISP::REALPART LISP::CODE-CHAR LISP::FLOAT-RADIX
         LISP::READ-CHAR LISP::PEEK-CHAR LISP::BASE-CHAR
         LISP::MAKE-CHAR LISP::NAME-CHAR LISP::GBC LISP::COS
         LISP::SET-MACRO-CHARACTER LISP::GET-MACRO-CHARACTER
         LISP::*BREAK-ON-WARNINGS* LISP::INPUT-STREAM-P
         LISP::*PRINT-PRETTY* LISP::*QUERY-IO* LISP::*PRINT-ARRAY*
         LISP::DEFCFUN LISP::*LOAD-VERBOSE* LISP::FIND-IF
         LISP::POSITION LISP::MAKE-SEQUENCE LISP::TAG LISP::BOOLE-C2
         LISP::SET-DISPATCH-MACRO-CHARACTER
         LISP::GET-DISPATCH-MACRO-CHARACTER LISP::COMPLEMENT
         LISP::PAIRLIS LISP::STANDARD-CHAR-P LISP::*PRINT-LEVEL*
         LISP::ALPHA-CHAR-P LISP::SIXTH LISP::*PRINT-RADIX*
         LISP::ARRAY-IN-BOUNDS-P LISP::DEPOSIT-FIELD
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::RATIONAL LISP::NOTANY
         LISP::POP LISP::PPRINT LISP::CONDITION LISP::READTABLE
         LISP::READTABLEP LISP::TWO-WAY-STREAM LISP::SPECIFIC-ERROR
         LISP::BIT-VECTOR-P WALKER::VARIABLE-DECLARATION LISP::DECLARE
         LISP::SPECIAL LISP::DIGIT-CHAR-P LISP::GET-UNIVERSAL-TIME
         LISP::SHADOWING-IMPORT LISP::INT
         LISP::SPECIFIC-CORRECTABLE-ERROR LISP::CLEAR-INPUT
         LISP::SOFTWARE-VERSION LISP::LOAD LISP::ENDP LISP::DOUBLE
         LISP::LAMBDA LISP::MAKE-SYNONYM-STREAM LISP::LISTP
         LISP::TERPRI LISP::SATISFIES LISP::BOOLE-ORC1 LISP::BOOLE-ORC2
         LISP::GET-SETF-METHOD-MULTIPLE-VALUE LISP::NUNION LISP::SLEEP
         LISP::NSUBSTITUTE LISP::FIRST LISP::COMPLEX LISP::UNTRACE
         LISP::FMAKUNBOUND LISP::RPLACA LISP::INSPECT
         LISP::MULTIPLE-VALUE-PROG1 LISP::LOGICAL-PATHNAME LISP::CLASS
         LISP::INCF LISP::*ERROR-OUTPUT* LISP::DO-SYMBOLS LISP::>=
         LISP::<= LISP::BOTH-CASE-P LISP::/= LISP::1- LISP::KEYWORDP
         LISP::ROTATEF LISP::KYOTO LISP::REMPROP LISP::LONG-SITE-NAME
         LISP::LIST* LISP::PACKAGEP LISP::UNBOUND-VARIABLE LISP::LOGIOR
         LISP::INTERNAL-TIME-UNITS-PER-SECOND
         LISP::CALL-ARGUMENTS-LIMIT LISP::APROPOS LISP::TYPEP LISP::DPB
         LISP::CHECK-TYPE LISP::LOG LISP::*READ-SUPPRESS*
         LISP::*DEFAULT-PATHNAME-DEFAULTS* LISP::NINTH LISP::THROW
         LISP::DEFPARAMETER LISP::&OPTIONAL LISP::WRITE-CHAR
         LISP::FLOAT-PRECISION LISP::DOLIST LISP::*PACKAGE* LISP::GMP
         LISP::STRUCTURE-OBJECT WALKER::*VARIABLE-DECLARATIONS*
         LISP::*BREAK-ENABLE* LISP::SET-CHAR-BIT LISP::FLET
         LISP::WITH-PACKAGE-ITERATOR ITERATE::GATHER LISP::MOD
         LISP::ELT LISP::MACHINE-INSTANCE LISP::REMOVE LISP::FLOAT-SIGN
         LISP::*EVAL-WHEN-COMPILE* LISP::LOGANDC1 LISP::COERCE
         LISP::PACKAGE-NICKNAMES LISP::CHAR-CONTROL-BIT
         LISP::FIND-PACKAGE LISP::LIST LISP::UNEXPORT LISP::LOGXOR
         LISP::BIT-ANDC1 LISP::CCLOSURE LISP::ARRAY-RANK-LIMIT
         LISP::POSITION-IF-NOT LISP::STYLE-WARNING LISP::UNUSE-PACKAGE
         LISP::PRINT-NOT-READABLE LISP::VECTOR-POP
         LISP::MERGE-PATHNAMES LISP::BYTE LISP::HASH-TABLE-SIZE
         LISP::KEYWORD LISP::DIGIT-CHAR LISP::LENGTH LISP::CHAR>=
         LISP::DO-EXTERNAL-SYMBOLS LISP::CHAR<= LISP::&KEY
         LISP::*READ-BASE* LISP::CHAR-CODE-LIMIT LISP::CHAR-FONT-LIMIT
         LISP::1+ LISP::++ LISP::*GENSYM-COUNTER* LISP::BYTE-SIZE
         LISP::FIFTH LISP::&ENVIRONMENT LISP::AND LISP::STABLE-SORT
         LISP::CHAR-NOT-LESSP LISP::BIT-EQV LISP::CHAR/=
         LISP::POSITIVE-FIXNUM LISP::CHAR-UPCASE LISP::BIT-NOT
         LISP::IGNORE ITERATE::INTERVAL LISP::BIT-XOR
         LISP::MAKE-PACKAGE LISP::EIGHTH LISP::MAKE-HASH-TABLE
         LISP::IN-PACKAGE LISP::TYPE LISP::WITH-OUTPUT-TO-STRING
         LISP::RETURN LISP::SHIFTF LISP::SIGNUM LISP::FIXNUM
         LISP::BIT-NOR LISP::THIRD LISP::BIT-IOR LISP::AKCL LISP::SINH
         LISP::STRING-LESSP LISP::CHAR-NOT-EQUAL ITERATE::WHILE
         LISP::COMPILED-FUNCTION LISP::LISP-IMPLEMENTATION-VERSION
         LISP::FIND LISP::EXPT LISP::FILL LISP::TIME LISP::STRING-CHAR
         LISP::NSUBST-IF-NOT LISP::** WALKER::WALK-FORM-EXPAND-MACROS-P
         LISP::UNSIGNED-SHORT LISP::READ-CHAR-NO-HANG LISP::MACROEXPAND
         LISP::SHORT-FLOAT LISP::NOTINLINE LISP::IDENTITY
         LISP::SYMBOL-VALUE LISP::TRUNCATE LISP::BIT-ORC1
         LISP::IMAGPART LISP::CHAR-DOWNCASE LISP::STRING-EQUAL
         SYSTEM::ALLOCATE LISP::SYMBOL-PACKAGE LISP::SVREF
         LISP::FBOUNDP LISP::BUTLAST LISP::MOST-NEGATIVE-FIXNUM
         LISP::MOST-NEGATIVE-SHORT-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-LONG-FLOAT LISP::INTERSECTION
         LISP::SEVENTH LISP::CHAR-LESSP LISP::DENOMINATOR
         LISP::OUTPUT-STREAM-P LISP::INTERN LISP::MINUSP
         LISP::MAKE-TWO-WAY-STREAM LISP::CONCATENATED-STREAM
         LISP::LAMBDA-LIST-KEYWORDS LISP::INTEGERP LISP::STRING-CHAR-P
         LISP::MAPLIST LISP::FILE-AUTHOR LISP::SCALE-FLOAT LISP::FTYPE
         LISP::READ-DELIMITED-LIST LISP::COPY-TREE LISP::UNREAD-CHAR
         LISP::ZEROP LISP::STRING-UPCASE LISP::STRING-DOWNCASE
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::FTRUNCATE
         LISP::ARRAY-ELEMENT-TYPE LISP::ALPHANUMERICP LISP::PI
         LISP::MAP-INTO LISP::ARITHMETIC-ERROR LISP::PROVIDE LISP::BY
         LISP::SIMPLE-VECTOR LISP::OBJECT LISP::MACRO-FUNCTION
         LISP::PHASE LISP::NBUTLAST LISP::BIT LISP::SFUN
         LISP::READ-LINE LISP::HASH-TABLE-COUNT LISP::CHAR-NAME
         LISP::GFUN LISP::TYPE-ERROR LISP::*MODULES*
         LISP::&ALLOW-OTHER-KEYS LISP::CONCATENATE LISP::CFUN
         LISP::TREE-EQUAL LISP::CHAR-EQUAL LISP::FILE-ERROR
         LISP::SUBSTITUTE WALKER::WALK-FORM LISP::LOGEQV
         LISP::CELL-ERROR LISP::ARRAY-ROW-MAJOR-INDEX
         LISP::DEFINE-MODIFY-MACRO LISP::CIS LISP::SIGNED-CHAR
         LISP::MERGE LISP::CHAR> LISP::CHAR= LISP::NSTRING-CAPITALIZE
         LISP::CHAR< LISP::IEEE-FLOATING-POINT
         LISP::MULTIPLE-VALUE-SETQ LISP::QUOTE LISP::READ-BYTE
         LISP::COMPILE-FILE LISP::REQUIRE LISP::MEMBER-IF
         LISP::UNSIGNED-BYTE LISP::ASSERT LISP::VECTOR LISP::CLINES
         LISP::TENTH LISP::LISTEN LISP::MULTIPLE-VALUES-LIMIT
         LISP::CHAR-BITS LISP::BIGNUM LISP::LIST-LENGTH
         LISP::WRITE-TO-STRING LISP::FROUND LISP::PRIN1-TO-STRING
         LISP::PRINC-TO-STRING LISP::FILE-LENGTH LISP::APROPOS-LIST
         LISP::REMOVE-IF-NOT LISP::PARSE-ERROR ITERATE::LIST-ELEMENTS
         LISP::DOUBLE-FLOAT-EPSILON LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::STRING-NOT-LESSP LISP::PACKAGE-ERROR LISP::DELETE-IF-NOT
         LISP::MEMBER-IF-NOT LISP::LONG-FLOAT LISP::SIMPLE-VECTOR-P
         LISP::ARRAY-RANK LISP::LAMBDA-PARAMETERS-LIMIT LISP::DEFVAR
         LISP::DEFSTRUCT LISP::BOOLEAN LISP::SUBTYPEP LISP::EVERY
         LISP::MAKE-ARRAY LISP::REMOVE-DUPLICATES LISP::SUBLIS
         LISP::DELETE-DUPLICATES LISP::FUNCTIONP LISP::FUNCTION
         LISP::REMOVE-IF LISP::WHEN LISP::ADJUSTABLE-ARRAY-P LISP::///
         LISP::APPEND LISP::SIN LISP::RASSOC-IF-NOT LISP::FRESH-LINE
         LISP::MIN LISP::SET-SYNTAX-FROM-CHAR LISP::SETQ
         LISP::NAMESTRING ITERATE::COLLECTING LISP::VECTORP
         LISP::BROADCAST-STREAM LISP::*EVALHOOK* LISP::EVENP LISP::REST
         LISP::STRING-NOT-EQUAL LISP::MULTIPLE-VALUE-CALL
         LISP::SINGLE-FLOAT-EPSILON LISP::SINGLE-FLOAT-NEGATIVE-EPSILON
         ITERATE::ELEMENTS LISP::LIST-ALL-PACKAGES LISP::MAPCON
         LISP::FILE-STREAM LISP::CONSTANTP LISP::NIL LISP::SETF
         LISP::WRITE-STRING LISP::MAKE-STRING-INPUT-STREAM
         LISP::MAKE-STRING-OUTPUT-STREAM LISP::COPY-ALIST LISP::GETF
         LISP::CONSTANTLY LISP::MACROEXPAND-1 LISP::NSUBST LISP::PUSH
         LISP::STORAGE-CONDITION LISP::*TERMINAL-IO* LISP::MAPCAR
         LISP::ISQRT LISP::CHAR LISP::HELP* LISP::DELETE-PACKAGE
         LISP::LOGORC2 LISP::RENAME-PACKAGE LISP::EXP LISP::MAPCAN
         LISP::MACHINE-TYPE LISP::LAMBDA-CLOSURE LISP::DEFUN
         LISP::LOGORC1 LISP::ASSOC LISP::PATHNAME-VERSION LISP::DO*
         LISP::NSUBSTITUTE-IF-NOT LISP::SYMBOL LISP::NINTERSECTION
         LISP::REPLACE LISP::TAGBODY LISP::CHAR-CODE LISP::DEFCONSTANT
         LISP::DEFMACRO LISP::PACKAGE-NAME LISP::LOGCOUNT LISP::FUNCALL
         LISP::DECLAIM LISP::NSUBST-IF LISP::DEFTYPE LISP::ECHO-STREAM
         LISP::NTHCDR LISP::SYMBOLP LISP::ACONS
         LISP::LONG-FLOAT-EPSILON LISP::LONG-FLOAT-NEGATIVE-EPSILON
         LISP::ACOSH LISP::DESTRUCTURING-BIND LISP::SUBSETP
         LISP::NUMBERP LISP::SUBST LISP::DEFLA LISP::DOTIMES
         LISP::BOOLE-C1 LISP::LET* LISP::GET-SETF-METHOD
         LISP::READ-FROM-STRING LISP::STRING LISP::SUBST-IF-NOT
         LISP::*PRINT-GENSYM* LISP::CLX-LITTLE-ENDIAN LISP::NCONC
         LISP::COMPILATION-SPEED LISP::EVALHOOK LISP::MAKE-ECHO-STREAM
         LISP::NUMBER LISP::ERROR LISP::HELP LISP::BASE-STRING
         LISP::MAKE-STRING LISP::WRITE-BYTE LISP::IF LISP::FOURTH
         LISP::*RANDOM-STATE* WALKER::VARIABLE-SPECIAL-P LISP::NULL
         LISP::CHAR-GREATERP LISP::REMF LISP::BYE LISP::ASSOC-IF-NOT
         LISP::MEMBER LISP::LOGBITP LISP::MAKE-DISPATCH-MACRO-CHARACTER
         LISP::*PRINT-LENGTH* LISP::INTEGER-LENGTH LISP::STRINGP
         LISP::LDIFF LISP::REALP LISP::CDDDDR LISP::CADDDR
         LISP::DELETE-IF LISP::PUSHNEW LISP::SOFTWARE-TYPE LISP::ARRAY
         LISP::*PRINT-CIRCLE* LISP::CDDDAR LISP::SHORT-SITE-NAME
         LISP::CADDAR LISP::QUIT LISP::*PRINT-ESCAPE*
         LISP::*PRINT-BASE* LISP::*PRINT-CASE* LISP::OPTIMIZE
         WALKER::VARIABLE-GLOBALLY-SPECIAL-P LISP::BOOLE-XOR
         LISP::&WHOLE LISP::LOCALLY LISP::GET-DECODED-TIME LISP::ATOM
         LISP::CDADDR LISP::LAMBDA-BLOCK-CLOSURE LISP::CAADDR
         LISP::SUBST-IF LISP::COUNT-IF-NOT LISP::CDADAR LISP::DEFSETF
         LISP::CAADAR LISP::SXHASH LISP::BOOLE-EQV LISP::PROGV
         LISP::NSET-EXCLUSIVE-OR LISP::CERROR LISP::STRING<=
         LISP::STRING>= LISP::STRING/= LISP::SIMPLE-BIT-VECTOR
         LISP::BOOLE-NOR LISP::COMPILE-FILE-PATHNAME LISP::SEARCH
         LISP::COPY-SYMBOL LISP::BOOLE-IOR LISP::RATIO LISP::PROGN
         LISP::LEAST-POSITIVE-SHORT-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LISP::RPLACD
         LISP::&BODY LISP::DIVISION-BY-ZERO LISP::CHAR-NOT-GREATERP
         LISP::NRECONC LISP::ASINH LISP::ROW-MAJOR-AREF LISP::CDDDR
         LISP::MC68020 LISP::MACROLET LISP::GET-INTERNAL-REAL-TIME
         LISP::GET-INTERNAL-RUN-TIME LISP::EQUAL LISP::NUMERATOR
         LISP::THE WALKER::VARIABLE-LEXICAL-P LISP::CDDAR
         LISP::MOST-POSITIVE-FIXNUM LISP::CHAR-BITS-LIMIT
         LISP::MOST-POSITIVE-SHORT-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-LONG-FLOAT LISP::EVAL
         LISP::HOST-NAMESTRING LISP::NSUBSTITUTE-IF LISP::PSETQ
         LISP::EQUALP LISP::SET LISP::BOOLE-CLR LISP::CATCH LISP::LET
         LISP::BYTE-POSITION LISP::FILE-WRITE-DATE LISP::SCHAR
         LISP::GET LISP::ACOS LISP::GET-OUTPUT-STREAM-STRING
         LISP::BOOLE-AND LISP::NSET-DIFFERENCE LISP::WRITE-LINE
         LISP::PACKAGE LISP::APPLYHOOK LISP::ATANH LISP::PSETF
         LISP::SIMPLE-BIT-VECTOR-P LISP::FLOATP LISP::BOOLE-SET
         LISP::PATHNAME LISP::PROG2 LISP::PROG1 LISP::PROBE-FILE
         LISP::CDADR LISP::MAKE-BROADCAST-STREAM LISP::FIND-SYMBOL
         LISP::PRINT LISP::CHAR-HYPER-BIT LISP::HASH-TABLE-TEST
         LISP::PACKAGE-USE-LIST LISP::PACKAGE-USED-BY-LIST
         LISP::READ-PRESERVING-WHITESPACE LISP::DRIBBLE LISP::CDAAR
         LISP::ARRAYP LISP::PROG* LISP::*STANDARD-OUTPUT* LISP::WRITE
         LISP::INLINE LISP::DECLARATION LISP::FORCE-OUTPUT LISP::LOGAND
         ITERATE::ITERATE LISP::REVAPPEND LISP::BOOLE-2 LISP::VARIABLE
         ITERATE::WITH-GATHERING LISP::PRINC LISP::FILE-NAMESTRING
         LISP::SPECIAL-OPERATOR-P LISP::MAKE-RANDOM-STATE LISP::DECF
         LISP::ED LISP::BOOLE-1 LISP::BOOLE-NAND LISP::BSD386
         LISP::REAL LISP::&AUX LISP::GETHASH LISP::CLEAR-OUTPUT
         LISP::COMPLEXP LISP::STEP LISP::*STANDARD-INPUT* LISP::APPLY
         LISP::WITH-OPEN-STREAM LISP::ECASE LISP::&REST LISP::CCASE
         LISP::FCEILING LISP::CLRHASH LISP::PARSE-INTEGER
         LISP::LOGANDC2 LISP::COUNT LISP::DIRECTORY-NAMESTRING
         LISP::PRIN1 LISP::READ LISP::CDDR LISP::SGC LISP::SAVE
         LISP::PACKAGE-SHADOWING-SYMBOLS LISP::ODDP LISP::STRING>
         LISP::USER-HOMEDIR-PATHNAME LISP::LAST LISP::BIT-ANDC2
         ITERATE::ITERATE* LISP::REM LISP::MAPHASH LISP::MAKE-SYMBOL
         LISP::STRING= LISP::ASIN LISP::SQRT LISP::CDR LISP::PROG
         LISP::ROUND LISP::STRING< LISP::STRING-LEFT-TRIM LISP::TAILP
         LISP::CHARACTER LISP::CHARACTERP LISP::SYMBOL-PLIST
         LISP::Y-OR-N-P LISP::SERIOUS-CONDITION
         LISP::ENCODE-UNIVERSAL-TIME LISP::REMHASH LISP::WARN
         ITERATE::EACHTIME ITERATE::*ITERATE-WARNINGS* LISP::IMPORT
         LISP::CDAR LISP::RATIONALIZE LISP::HASH-TABLE-P
         LISP::FLOATING-POINT-OVERFLOW LISP::FLOATING-POINT-UNDERFLOW
         LISP::NSTRING-UPCASE LISP::BREAK LISP::CASE
         LISP::MAKE-CONCATENATED-STREAM LISP::COMPILE LISP::+++
         LISP::ATAN LISP::STRING-RIGHT-TRIM LISP::SHORT-FLOAT-EPSILON
         LISP::SHORT-FLOAT-NEGATIVE-EPSILON LISP::FILL-POINTER
         LISP::COUNT-IF LISP::RATIONALP LISP::NOTEVERY LISP::CDDADR
         LISP::FLOATING-POINT-INEXACT LISP::FILE-POSITION
         LISP::MAKE-PATHNAME LISP::CADADR LISP::SYMBOL-FUNCTION
         LISP::CDDAAR LISP::ARRAY-HAS-FILL-POINTER-P LISP::MAPL
         LISP::CADAAR LISP::SBIT LISP::SECOND LISP::COPY-SEQ
         LISP::WITH-OPEN-FILE LISP::EXPORT LISP::POSITION-IF
         LISP::BOOLE-ANDC2 LISP::CDAADR LISP::CAAADR LISP::STREAM-ERROR
         LISP::BOOLE-ANDC1 LISP::FLOATING-POINT-INVALID-OPERATION
         LISP::CDAAAR LISP::CONSP LISP::GET-PROPERTIES LISP::CAAAAR
         LISP::INTEGER-DECODE-FLOAT LISP::STRING-GREATERP
         LISP::EXTENDED-CHAR LISP::MAPC LISP::SYNONYM-STREAM
         LISP::MACRO LISP::PROGRAM-ERROR LISP::TRACE LISP::TANH
         LISP::UNLESS LISP::FFLOOR ITERATE::UNTIL
         LISP::ARRAY-TOTAL-SIZE-LIMIT LISP::SIMPLE-TYPE-ERROR
         LISP::BOOLE LISP::DECODE-UNIVERSAL-TIME LISP::CADDR
         LISP::INTEGER LISP::OR LISP::UNINTERN LISP::ASSOC-IF
         LISP::STREAM LISP::*LINK-ARRAY* WALKER::NESTED-WALK-FORM
         LISP::VALUES LISP::*READTABLE* LISP::CADAR
         LISP::LEAST-NEGATIVE-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LISP::STRING-TRIM
         LISP::PROCLAMATION WALKER::MACROEXPAND-ALL LISP::***
         LISP::SYMBOL-NAME LISP::TRUENAME LISP::SPICE
         LISP::FIND-ALL-SYMBOLS LISP::BIT-ORC2 LISP::STRING-STREAM
         LISP::UNWIND-PROTECT LISP::FIND-IF-NOT LISP::WARNING
         LISP::STREAMP LISP::UNDEFINED-FUNCTION LISP::DOUBLE-FLOAT
         LISP::ARRAY-DIMENSIONS LISP::DO-ALL-SYMBOLS
         LISP::ARRAY-DIMENSION-LIMIT LISP::ARRAY-DISPLACEMENT
         LISP::CHAR-INT LISP::ABS LISP::NTH LISP::LOGNOT LISP::BIT-NAND
         LISP::MAX ITERATE::PLIST-ELEMENTS ITERATE::GATHERING
         LISP::LOGNOR LISP::COPY-LIST LISP::CAADR LISP::COMMONP
         LISP::BIT-VECTOR LISP::FINISH-OUTPUT LISP::SIMPLE-ARRAY
         LISP::LCM LISP::SAFETY LISP::EVAL-WHEN LISP::MAKE-LIST
         LISP::MAKUNBOUND LISP::SORT LISP::AREF LISP::CHAR-BIT
         LISP::CAAAR LISP::COMPILED-FUNCTION-P
         WALKER::DEFINE-WALKER-TEMPLATE LISP::ARRAY-TOTAL-SIZE
         LISP::KCL LISP::BOUNDP LISP::GCL
         LISP::LISP-IMPLEMENTATION-TYPE LISP::SYSTEM LISP::SIGNED-SHORT
         LISP::COMPILER-LET ITERATE::LIST-TAILS LISP::NTH-VALUE
         LISP::STREAM-ELEMENT-TYPE LISP::UNSIGNED-CHAR LISP::ADJOIN
         LISP::COSH LISP::REVERSE LISP::SPEED LISP::EQ
         LISP::UNBOUND-SLOT LISP::ENOUGH-NAMESTRING LISP::INT-CHAR
         LISP::CONTROL-ERROR LISP::ARRAY-DIMENSION LISP::ADJUST-ARRAY
         LISP::SINGLE-FLOAT ITERATE::JOINING LISP::NSTRING-DOWNCASE
         LISP::PLUSP LISP::RANDOM LISP::MISMATCH LISP::LOOP
         LISP::SEQUENCE LISP::STRING-CAPITALIZE LISP::DIRECTORY
         LISP::CADR LISP::DEFENTRY LISP::READER-ERROR
         LISP::MULTIPLE-VALUE-LIST LISP::ROOM SYSTEM::STRUCTURE-DEF
         SYSTEM::STRUCTURE-REF LISP::CONS LISP::CONJUGATE
         LISP::HASH-TABLE LISP::RASSOC-IF LISP::*FEATURES* LISP::ASH
         LISP::FLOAT-DIGITS LISP::FORMAT ITERATE::MINIMIZING
         LISP::STRUCTURE SYSTEM::STRUCTUREP ITERATE::MAXIMIZING
         LISP::CHAR-SUPER-BIT LISP::CHAR-META-BIT LISP::REDUCE
         LISP::LDB LISP::CHAR-FONT LISP::DECODE-FLOAT
         LISP::STRING-NOT-GREATERP LISP::PATHNAME-DIRECTORY LISP::UNION
         LISP::CAR LISP::COPY-READTABLE LISP::VALUES-LIST LISP::GENTEMP
         LISP::NREVERSE LISP::LOGTEST LISP::DEFINE-SETF-METHOD
         LISP::BIT-AND LISP::TRUNCATE_USE_C ITERATE::SUMMING
         LISP::PATHNAME-HOST LISP::SPACE LISP::LDB-TEST
         LISP::SUBSTITUTE-IF LISP::END-OF-FILE LISP::VECTOR-PUSH-EXTEND
         LISP::LOGNAND LISP::TYPECASE LISP::SIMPLE-STRING-P
         LISP::SIMPLE-STRING LISP::SUBSTITUTE-IF-NOT LISP::CAAR
         LISP::RASSOC LISP::PARSE-NAMESTRING LISP::*MACROEXPAND-HOOK*
         LISP::MAP LISP::COND LISP::SIMPLE-WARNING LISP::T
         LISP::SPECIAL-FORM-P LISP::DESCRIBE LISP::RETURN-FROM
         LISP::CTYPECASE LISP::ETYPECASE LISP::SOME LISP::LABELS
         LISP::> LISP::= LISP::< LISP::COMMON LISP::SHADOW LISP::/
         LISP::- LISP::+ LISP::* LISP::DELETE LISP::PATHNAMEP
         LISP::SET-DIFFERENCE LISP::TYPE-OF LISP::VECTOR-PUSH
         LISP::MACHINE-VERSION LISP::GCD LISP::BSD LISP::SIGNED-BYTE
         LISP::OPEN LISP::DISASSEMBLE LISP::TAN))

;;; Definitions for package SLOT-ACCESSOR-NAME of type SHADOW
(LISP::IN-PACKAGE "SLOT-ACCESSOR-NAME")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT 'LISP::NIL)

;;; Definitions for package TK of type SHADOW
(LISP::IN-PACKAGE "TK")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::EXP LISP::DEFVAR LISP::DISASSEMBLE LISP::DELETE-IF
         LISP::UNSIGNED-SHORT LISP::GFUN LISP::NSUBST-IF-NOT LISP::CIS
         LISP::LOGAND LISP::BIT-EQV LISP::UNIX LISP::RANDOM
         LISP::COPY-LIST SYSTEM::*DEFAULT-INFO-FILES* LISP::KEYWORDP
         LISP::CADAR LISP::MERGE-PATHNAMES LISP::BOOLE-C2 LISP::BIT-NOT
         LISP::CFUN LISP::STANDARD-OBJECT LISP::STRINGP
         LISP::METHOD-COMBINATION LISP::NSET-EXCLUSIVE-OR LISP::CLOSE
         LISP::INTEGER-DECODE-FLOAT LISP::CHAR-NOT-EQUAL LISP::COSH
         LISP::NTHCDR LISP::GET-UNIVERSAL-TIME LISP::YES-OR-NO-P
         LISP::READ-LINE LISP::LET* LISP::PATHNAME-TYPE
         LISP::FLOAT-PRECISION LISP::PROG* SYSTEM::HEADER
         LISP::SYMBOL-NAME LISP::LOG LISP::OR
         LISP::PACKAGE-SHADOWING-SYMBOLS LISP::BREAK
         LISP::STRUCTURE-OBJECT LISP::ROTATEF LISP::SQRT LISP::CONS
         LISP::NSUBST-IF LISP::UNWIND-PROTECT LISP::CONSP
         SLOOP::DEF-LOOP-MACRO LISP::FLOAT-SIGN LISP::*EVALHOOK*
         LISP::CHAR-BIT LISP::SOME LISP::MAPC SYSTEM::*TK-CONNECTION*
         LISP::SETF LISP::CEILING LISP::&BODY LISP::CDAR
         LISP::MAKE-LIST LISP::MAKE-HASH-TABLE LISP::STRING-UPCASE
         LISP::STRING-DOWNCASE LISP::STYLE-WARNING LISP::ASINH
         LISP::NRECONC LISP::NSTRING-DOWNCASE LISP::SECOND
         LISP::RATIONALP LISP::SET-DISPATCH-MACRO-CHARACTER
         LISP::GET-DISPATCH-MACRO-CHARACTER LISP::CHECK-TYPE
         LISP::MAKE-STRING-INPUT-STREAM LISP::MAKE-STRING-OUTPUT-STREAM
         LISP::*BREAK-ON-WARNINGS* LISP::BYE LISP::SAFETY
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::*LOAD-VERBOSE*
         LISP::OTHERWISE LISP::NBUTLAST LISP::SORT LISP::WARNING
         LISP::DEFLA LISP::PROGN LISP::PUSHNEW LISP::SYSTEM
         SYSTEM::INFO-AUX LISP::CHAR= LISP::SIGNED-SHORT
         LISP::MAKE-ECHO-STREAM LISP::BIT-AND LISP::EXPORT LISP::EQ
         LISP::SOFTWARE-TYPE LISP::LOGTEST LISP::LIST-ALL-PACKAGES
         LISP::DEFTYPE LISP::GETF LISP::ROW-MAJOR-AREF LISP::TYPECASE
         LISP::CHAR-CONTROL-BIT SYSTEM::STRING-MATCH
         LISP::HASH-TABLE-TEST LISP::USER-HOMEDIR-PATHNAME
         LISP::SYMBOL-PACKAGE LISP::BOOLEAN LISP::HOST-NAMESTRING
         LISP::IN-PACKAGE LISP::CAAR SYSTEM::SHOW-INFO LISP::INTERN
         LISP::CONDITION LISP::IEEE-FLOATING-POINT LISP::LOGNOT
         LISP::SUBST-IF-NOT LISP::COPY-READTABLE LISP::REVAPPEND
         LISP::SYMBOL LISP::BIT-VECTOR LISP::SEARCH
         LISP::STREAM-ELEMENT-TYPE LISP::POP LISP::GO LISP::LIST
         LISP::SET-MACRO-CHARACTER LISP::GET-MACRO-CHARACTER
         LISP::PARSE-ERROR LISP::VALUES LISP::DESTRUCTURING-BIND
         LISP::RANDOM-STATE LISP::LISTP LISP::CHAR/= LISP::REMPROP
         LISP::DO LISP::HELP* LISP::ABS LISP::&KEY
         LISP::VECTOR-PUSH-EXTEND LISP::PACKAGE-NICKNAMES
         LISP::MULTIPLE-VALUE-PROG1 SLOOP::LOOP-RETURN
         LISP::END-OF-FILE LISP::*DEFAULT-PATHNAME-DEFAULTS*
         SYSTEM::OFFER-CHOICES LISP::EXPT SYSTEM::PRINT-NODE
         LISP::READER-ERROR LISP::REMHASH LISP::BLOCK
         LISP::PACKAGE-ERROR LISP::LAMBDA-CLOSURE LISP::PARSE-INTEGER
         LISP::TIME LISP::COERCE LISP::FIND-IF LISP::UNREAD-CHAR
         LISP::DOUBLE-FLOAT-EPSILON LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::BOOLE-IOR LISP::ASSERT LISP::ADJUSTABLE-ARRAY-P
         LISP::COPY-TREE LISP::CLEAR-OUTPUT LISP::CODE-CHAR
         LISP::STRING-CAPITALIZE LISP::/// LISP::WITH-OPEN-STREAM
         SYSTEM::*INFO-WINDOW* LISP::REST LISP::ACOS LISP::MACHINE-TYPE
         LISP::DENOMINATOR LISP::TRACE LISP::FLOATING-POINT-INEXACT
         LISP::*READ-BASE* LISP::CDR SYSTEM::BEGIN LISP::STRING-EQUAL
         LISP::GMP LISP::DELETE-FILE LISP::SPECIFIC-ERROR LISP::FIRST
         LISP::ALPHANUMERICP LISP::WITH-HASH-TABLE-ITERATOR
         LISP::SCALE-FLOAT LISP::CONCATENATED-STREAM
         LISP::CONTROL-ERROR LISP::FINISH-OUTPUT
         LISP::LAMBDA-PARAMETERS-LIMIT LISP::PRINC LISP::ADJOIN
         LISP::PI LISP::DOUBLE-FLOAT LISP::READTABLE LISP::READTABLEP
         LISP::ARRAY-RANK-LIMIT SYSTEM::INFO-SUBFILE LISP::RENAME-FILE
         LISP::READ-CHAR LISP::PEEK-CHAR LISP::REMOVE-DUPLICATES
         LISP::BYTE LISP::*MODULES* LISP::GET-OUTPUT-STREAM-STRING
         LISP::MULTIPLE-VALUE-BIND LISP::VECTORP LISP::RASSOC-IF-NOT
         LISP::UNINTERN SLOOP::LOOP-FINISH
         LISP::SPECIFIC-CORRECTABLE-ERROR LISP::CDADAR LISP::FUNCTION
         LISP::LOGORC2 LISP::*PACKAGE* LISP::STRING-NOT-GREATERP
         LISP::INTERSECTION LISP::SPACE LISP::SEVENTH LISP::BASE-CHAR
         LISP::MAKE-CHAR LISP::NAME-CHAR LISP::SBIT LISP::CAADAR
         LISP::TAILP LISP::*TERMINAL-IO* LISP::STREAM-ERROR
         LISP::BOOLE-ANDC1 LISP::DO-ALL-SYMBOLS LISP::MAKUNBOUND
         LISP::PROVIDE LISP::THROW LISP::LENGTH LISP::CDAAR LISP::&AUX
         LISP::ARRAY-DISPLACEMENT LISP::PAIRLIS LISP::*PRINT-GENSYM*
         LISP::COMPILE-FILE-PATHNAME LISP::CAR LISP::FTRUNCATE
         LISP::DELETE-DUPLICATES LISP::NREVERSE LISP::APROPOS
         LISP::STRING-RIGHT-TRIM LISP::STEP LISP::BIT-NOR
         LISP::ARRAY-TOTAL-SIZE LISP::ECHO-STREAM SYSTEM::*TK-LIBRARY*
         LISP::DEFINE-SETF-METHOD LISP::FMAKUNBOUND LISP::SUBST-IF
         LISP::GET-DECODED-TIME LISP::LONG-FLOAT LISP::SIMPLE-WARNING
         LISP::CHAR-HYPER-BIT LISP::TAG LISP::RATIO LISP::EVENP
         LISP::QUOTE SYSTEM::AUTOLOAD LISP::SIMPLE-STRING
         LISP::NSUBSTITUTE LISP::LAST LISP::NSET-DIFFERENCE LISP::COUNT
         LISP::CDAAAR LISP::SET-DIFFERENCE SLOOP::DEF-LOOP-FOR
         LISP::PPRINT LISP::SHORT-FLOAT-EPSILON
         LISP::SHORT-FLOAT-NEGATIVE-EPSILON LISP::SET-CHAR-BIT
         LISP::ACOSH LISP::LISTEN LISP::GENTEMP LISP::ERROR LISP::BSD
         LISP::ADJUST-ARRAY LISP::CLINES LISP::IF LISP::CAAAAR
         LISP::SET-SYNTAX-FROM-CHAR LISP::STRING-TRIM LISP::DIGIT-CHAR
         LISP::BOOLE-AND LISP::STRING> LISP::CAAAR LISP::GETHASH
         LISP::FILL-POINTER SLOOP::DEF-LOOP-MAP LISP::CDADDR
         LISP::DIRECTORY-NAMESTRING LISP::DEFUN LISP::TRUNCATE
         SYSTEM::FILE LISP::DEFENTRY LISP::ALPHA-CHAR-P
         LISP::SYMBOL-FUNCTION LISP::SUBSTITUTE-IF-NOT LISP::LDB-TEST
         LISP::FLOAT-DIGITS LISP::BIT-VECTOR-P LISP::CAADDR
         LISP::VARIABLE LISP::NUMERATOR LISP::NOTINLINE
         LISP::CHAR-LESSP LISP::WARN LISP::CHAR-NOT-LESSP
         LISP::ARRAY-DIMENSION-LIMIT LISP::MOD LISP::SXHASH
         LISP::PACKAGE-USE-LIST LISP::PACKAGE-USED-BY-LIST
         LISP::MACHINE-INSTANCE LISP::ARRAYP LISP::*GENSYM-COUNTER*
         LISP::UPPER-CASE-P LISP::*PRINT-CIRCLE* LISP::FTYPE LISP::THE
         SLOOP::LOCAL-FINISH SYSTEM::NAME LISP::COMPILER-LET
         LISP::WRITE-TO-STRING LISP::ARRAY-TOTAL-SIZE-LIMIT
         LISP::SEQUENCE LISP::FILE-AUTHOR LISP::MULTIPLE-VALUE-CALL
         LISP::*MACROEXPAND-HOOK* LISP::PLUSP
         LISP::INTERNAL-TIME-UNITS-PER-SECOND LISP::LIST*
         LISP::*PRINT-ARRAY* LISP::FILE-WRITE-DATE LISP::LAMBDA
         LISP::ED LISP::OPEN LISP::AREF LISP::RASSOC-IF LISP::LOGORC1
         LISP::PROCLAIM LISP::CHAR-SUPER-BIT LISP::APPEND
         LISP::CONCATENATE LISP::WRITE-STRING LISP::MISMATCH
         LISP::SIMPLE-STRING-P LISP::PRINT LISP::MULTIPLE-VALUES-LIMIT
         LISP::PRIN1-TO-STRING LISP::PRINC-TO-STRING
         LISP::SIMPLE-CONDITION LISP::TERPRI LISP::CDAADR
         LISP::FLOATING-POINT-OVERFLOW LISP::FLOATING-POINT-UNDERFLOW
         LISP::CALL-ARGUMENTS-LIMIT LISP::COPY-SEQ LISP::FUNCALL
         SYSTEM::END LISP::CLRHASH LISP::SHORT-SITE-NAME
         LISP::LONG-FLOAT-EPSILON LISP::LONG-FLOAT-NEGATIVE-EPSILON
         LISP::ASSOC-IF-NOT LISP::CAAADR LISP::STRING-CHAR
         LISP::LOGANDC1 LISP::WITH-PACKAGE-ITERATOR LISP::NUMBERP
         LISP::COMPLEX LISP::AND LISP::EVAL-WHEN LISP::LOOP
         LISP::READ-FROM-STRING LISP::*STANDARD-OUTPUT* LISP::CHAR-NAME
         LISP::COMPILE-FILE LISP::FLOAT LISP::*ERROR-OUTPUT*
         LISP::TYPE-ERROR LISP::COMPILATION-SPEED LISP::LOGXOR
         LISP::LIST-LENGTH LISP::DRIBBLE LISP::EXTENDED-CHAR LISP::MAP
         SYSTEM::IDESCRIBE LISP::ARRAY-ELEMENT-TYPE LISP::ROUND
         LISP::STRING-LEFT-TRIM LISP::DECLAIM LISP::SAVE LISP::SIN
         LISP::*PRINT-LENGTH* LISP::DECLARATION LISP::DECODE-FLOAT
         LISP::PATHNAME-NAME LISP::STRING= LISP::PHASE LISP::SPICE
         LISP::RASSOC LISP::LISP-IMPLEMENTATION-TYPE LISP::UNTRACE
         LISP::PRINT-NOT-READABLE LISP::ARRAY-ROW-MAJOR-INDEX
         LISP::SUBSTITUTE-IF LISP::BOOLE LISP::TRUENAME
         LISP::DEFCONSTANT LISP::VALUES-LIST LISP::*LINK-ARRAY*
         LISP::&REST SYSTEM::TKCONNECT LISP::MAKE-RANDOM-STATE
         LISP::CHAR> SYSTEM::INFO-ERROR LISP::BYTE-SIZE LISP::MIN
         LISP::CDDDR LISP::BIT-IOR LISP::VECTOR LISP::UNSIGNED-BYTE
         LISP::SERIOUS-CONDITION LISP::SYMBOL-PLIST LISP::*READTABLE*
         LISP::SIMPLE-BIT-VECTOR-P LISP::LEAST-POSITIVE-SHORT-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LISP::LOWER-CASE-P
         SYSTEM::ALLOCATE LISP::EQUALP LISP::SUBSTITUTE LISP::SUBSEQ
         LISP::MINUSP LISP::MOST-NEGATIVE-SHORT-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-LONG-FLOAT LISP::FILE-LENGTH
         LISP::FILE-ERROR LISP::HASH-TABLE LISP::SPEED LISP::COMMON
         LISP::*PRINT-RADIX* LISP::POSITIVE-FIXNUM
         LISP::UNBOUND-VARIABLE LISP::RATIONAL
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::FRESH-LINE LISP::WHEN
         LISP::COMPILE LISP::FLET LISP::SPECIAL LISP::CLASS
         LISP::CELL-ERROR LISP::RPLACD LISP::TYPE-OF
         LISP::SPECIAL-OPERATOR-P LISP::DESCRIBE LISP::POSITION
         LISP::STABLE-SORT LISP::BOTH-CASE-P SYSTEM::*CASE-FOLD-SEARCH*
         LISP::SYMBOLP LISP::*PRINT-READABLY* LISP::SHADOW LISP::STREAM
         LISP::CHAR-BITS LISP::MAKE-ARRAY LISP::FUNCTIONP LISP::&WHOLE
         LISP::SUBST LISP::SCHAR LISP::ARRAY-DIMENSION LISP::COND
         LISP::DO-EXTERNAL-SYMBOLS LISP::CHAR-CODE-LIMIT
         LISP::CHAR-FONT-LIMIT LISP::SATISFIES LISP::MASK-FIELD
         LISP::ARITHMETIC-ERROR LISP::CADDR LISP::LAMBDA-LIST-KEYWORDS
         LISP::MACRO LISP::STRING-NOT-EQUAL LISP::STRING-LESSP
         LISP::USE-PACKAGE LISP::MULTIPLE-VALUE-SETQ LISP::>=
         LISP::LOGEQV LISP::*EVAL-WHEN-COMPILE* LISP::HASH-TABLE-P
         LISP::GRAPHIC-CHAR-P LISP::EQL LISP::MAPHASH
         SYSTEM::SETUP-INFO LISP::NINTERSECTION LISP::<=
         LISP::NAMESTRING LISP::MAKE-CONCATENATED-STREAM
         LISP::SHORT-FLOAT LISP::FILE-STREAM LISP::WRITE-LINE
         LISP::VECTOR-PUSH LISP::ENDP LISP::DIRECTORY LISP::TYPE
         LISP::ASSOC-IF LISP::DPB LISP::TYPEP LISP::FIFTH LISP::LOGNAND
         LISP::SIGNED-BYTE LISP::EVERY LISP::SUBLIS LISP::NULL
         LISP::FLOATP LISP::STRING< LISP::*TRACE-OUTPUT*
         LISP::WRITE-CHAR LISP::SGC LISP::STANDARD-GENERIC-FUNCTION
         LISP::MAPL LISP::PROG1 LISP::COMPLEXP LISP::PROCLAMATION
         LISP::INSPECT LISP::MACROEXPAND-1 LISP::BIT-ANDC1 LISP::SETQ
         LISP::CHAR>= LISP::REALPART LISP::LDIFF LISP::SINH
         LISP::BROADCAST-STREAM LISP::BASE-STRING LISP::MAKE-STRING
         SYSTEM::GET-MATCH LISP::CDDDAR LISP::INTEGER-LENGTH
         LISP::OUTPUT-STREAM-P LISP::NUNION LISP::/= LISP::PACKAGE-NAME
         LISP::ECASE LISP::PATHNAME LISP::APPLY LISP::CHAR-INT
         LISP::TAN LISP::MOST-NEGATIVE-FIXNUM LISP::MAKE-SYNONYM-STREAM
         LISP::MACROEXPAND LISP::CADDAR LISP::ISQRT LISP::CCASE
         LISP::GCD LISP::KEYWORD LISP::UNLESS LISP::MAP-INTO
         LISP::SYNONYM-STREAM LISP::SUBSETP LISP::POSITION-IF
         LISP::INCF LISP::SHIFTF LISP::BOOLE-XOR LISP::REM LISP::LOGNOR
         LISP::FIND LISP::MAX LISP::SIMPLE-VECTOR-P LISP::IMPORT
         LISP::MACHINE-VERSION LISP::SHADOWING-IMPORT LISP::BOOLE-EQV
         LISP::CONJUGATE LISP::READ-CHAR-NO-HANG LISP::WRITE-BYTE
         LISP::STRING LISP::WITH-OUTPUT-TO-STRING LISP::BYTE-POSITION
         LISP::STANDARD-CHAR LISP::MEMBER-IF LISP::CHAR-BITS-LIMIT
         LISP::NSTRING-UPCASE LISP::DEFMACRO LISP::BUTLAST LISP::CDDAAR
         LISP::IMAGPART LISP::LOGANDC2 LISP::HASH-TABLE-SIZE
         LISP::FFLOOR LISP::*PRINT-LEVEL* LISP::DEFSTRUCT
         LISP::DELETE-PACKAGE LISP::BOOLE-CLR LISP::DO-SYMBOLS
         LISP::INTEGERP LISP::NUMBER LISP::CADAAR LISP::NIL LISP::T
         LISP::DELETE LISP::DEFCFUN LISP::DEFINE-MODIFY-MACRO
         LISP::COMPILED-FUNCTION LISP::NOTEVERY LISP::BOOLE-2
         LISP::STRUCTURE LISP::UNBOUND-SLOT LISP::RENAME-PACKAGE
         LISP::SIGNUM LISP::CDDDDR LISP::GET-SETF-METHOD-MULTIPLE-VALUE
         LISP::FILE-POSITION LISP::LOGBITP LISP::LAMBDA-BLOCK
         LISP::STANDARD-METHOD LISP::UNSIGNED-CHAR LISP::PSETQ
         LISP::EVAL LISP::CERROR LISP::CHAR-GREATERP
         LISP::GET-SETF-METHOD LISP::SYMBOL-VALUE LISP::+++ LISP::LCM
         LISP::BOOLE-NAND LISP::SIMPLE-ARRAY LISP::CADDDR
         LISP::SIMPLE-BIT-VECTOR LISP::CHAR-META-BIT LISP::PRIN1
         LISP::BIT-ORC1 LISP::PSETF LISP::RETURN LISP::MAKE-PATHNAME
         LISP::DOTIMES LISP::DEPOSIT-FIELD LISP::*QUERY-IO*
         LISP::&ENVIRONMENT LISP::ARRAY-DIMENSIONS LISP::BSD386
         LISP::MAKE-BROADCAST-STREAM LISP::BOOLE-ANDC2
         LISP::MAKE-TWO-WAY-STREAM LISP::INPUT-STREAM-P
         LISP::DIGIT-CHAR-P LISP::*STANDARD-INPUT* LISP::BOUNDP
         LISP::ODDP LISP::READ-DELIMITED-LIST LISP::SIXTH
         LISP::SUBTYPEP LISP::NSTRING-CAPITALIZE LISP::DECLARE
         LISP::AKCL LISP::FLOOR LISP::GBC LISP::GENSYM
         LISP::ARRAY-HAS-FILL-POINTER-P LISP::LOGIOR LISP::Y-OR-N-P
         LISP::CHAR-FONT LISP::PARSE-NAMESTRING LISP::ARRAY-RANK
         LISP::NINTH LISP::EVALHOOK LISP::WITH-INPUT-FROM-STRING
         LISP::INTEGER LISP::MAKE-SEQUENCE SYSTEM::*MATCH-DATA*
         LISP::SET-EXCLUSIVE-OR LISP::CHAR< LISP::INLINE LISP::CDDADR
         LISP::REMOVE-IF-NOT LISP::TANH SYSTEM::END-WAITING LISP::ATAN
         LISP::NOT LISP::STRING-CHAR-P LISP::LONG-SITE-NAME
         LISP::PATHNAME-VERSION LISP::MAPCAN LISP::REQUIRE LISP::RPLACA
         LISP::TAGBODY LISP::COPY-ALIST LISP::CADADR LISP::MAPCAR
         LISP::> LISP::FIND-PACKAGE LISP::FBOUNDP
         LISP::CLX-LITTLE-ENDIAN LISP::= LISP::DEFSETF LISP::ZEROP
         LISP::MC68020 LISP::UNUSE-PACKAGE
         LISP::MOST-POSITIVE-SHORT-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-LONG-FLOAT LISP::LOGICAL-PATHNAME
         LISP::APPLYHOOK LISP::< LISP::LOGCOUNT LISP::ENOUGH-NAMESTRING
         LISP::MULTIPLE-VALUE-LIST SYSTEM::MATCH-END
         LISP::TWO-WAY-STREAM LISP::CDDR LISP::ASSOC LISP::REMF
         LISP::LDB LISP::MACROLET LISP::CDADR
         SYSTEM::*CURRENT-INFO-DATA* LISP::UNION LISP::FIND-ALL-SYMBOLS
         LISP::MAKE-PACKAGE LISP::&OPTIONAL LISP::THIRD LISP::LABELS
         LISP::BOOLE-C1 LISP::FIND-IF-NOT LISP::LOAD
         LISP::DELETE-IF-NOT LISP::ACONS LISP::UNDEFINED-FUNCTION
         LISP::SIGNED-CHAR LISP::INT LISP::PACKAGEP
         LISP::ENCODE-UNIVERSAL-TIME LISP::FORMAT LISP::TENTH
         LISP::STRUCTURE-CLASS LISP::MEMBER-IF-NOT
         LISP::LEAST-NEGATIVE-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LISP::KCL
         LISP::BOOLE-1 LISP::REDUCE LISP::SVREF LISP::NTH-VALUE
         LISP::FORCE-OUTPUT LISP::NSUBSTITUTE-IF-NOT LISP::CATCH
         LISP::STORAGE-CONDITION LISP::MERGE LISP::CASE
         LISP::CLEAR-INPUT LISP::REPLACE LISP::***
         LISP::GENERIC-FUNCTION LISP::GCL LISP::/ LISP::BOOLE-SET
         LISP::SOFTWARE-VERSION LISP::APROPOS-LIST
         LISP::POSITION-IF-NOT LISP::READ-BYTE LISP::FLOAT-RADIX
         SYSTEM::INFO-DATA LISP::DECF LISP::PROG LISP::- LISP::MAPCON
         LISP::CADR LISP::EQUAL LISP::CAADR LISP::+
         LISP::PATHNAME-DEVICE LISP::MACRO-FUNCTION LISP::MAPLIST
         LISP::REVERSE LISP::FIND-SYMBOL LISP::* LISP::LOCALLY
         LISP::BIT-ANDC2 LISP::COMMONP LISP::*FEATURES*
         LISP::DIVISION-BY-ZERO LISP::ARRAY SYSTEM::INFO LISP::DOUBLE
         LISP::DEFPARAMETER LISP::PATHNAME-DIRECTORY
         LISP::STRING-NOT-LESSP LISP::ELT LISP::NTH LISP::RETURN-FROM
         LISP::BIGNUM LISP::MAKE-SYMBOL LISP::FILL LISP::CHAR-CODE
         LISP::*PRINT-ESCAPE* LISP::*PRINT-BASE* LISP::*PRINT-CASE*
         LISP::FLOATING-POINT-INVALID-OPERATION LISP::NSUBST
         LISP::SIMPLE-VECTOR LISP::ARRAY-IN-BOUNDS-P
         LISP::READ-PRESERVING-WHITESPACE LISP::ATANH LISP::ATOM
         LISP::BIT-NAND LISP::VECTOR-POP LISP::MEMBER LISP::REMOVE
         LISP::CHAR<= LISP::PUSH LISP::PROGRAM-ERROR LISP::KYOTO
         LISP::CHAR-UPCASE LISP::*PRINT-PRETTY*
         LISP::MOST-POSITIVE-FIXNUM LISP::PATHNAME-HOST
         LISP::DOCUMENTATION LISP::// LISP::UNEXPORT LISP::PROBE-FILE
         LISP::STANDARD-CLASS LISP::GET-INTERNAL-REAL-TIME
         LISP::GET-INTERNAL-RUN-TIME LISP::NOTANY LISP::QUIT LISP::ROOM
         LISP::*APPLYHOOK* LISP::COS LISP::CHAR-DOWNCASE
         LISP::CONSTANTLY LISP::RATIONALIZE
         LISP::LISP-IMPLEMENTATION-VERSION LISP::CONSTANTP
         LISP::HASH-TABLE-COUNT LISP::STREAMP SYSTEM::*INFO-PATHS*
         LISP::*BREAK-ENABLE* LISP::1- LISP::BIT-XOR
         LISP::STRING-STREAM LISP::GET-PROPERTIES LISP::COUNT-IF-NOT
         LISP::BIT LISP::ASH LISP::NSUBLIS LISP::FOURTH LISP::STRING<=
         LISP::STRING>= LISP::STRING/= LISP::SLEEP
         LISP::LAMBDA-BLOCK-CLOSURE LISP::HELP LISP::TREE-EQUAL
         LISP::SET LISP::INT-CHAR LISP::STRING-GREATERP
         LISP::SINGLE-FLOAT-EPSILON LISP::SINGLE-FLOAT-NEGATIVE-EPSILON
         LISP::SPECIAL-FORM-P LISP::COMPLEMENT LISP::WRITE LISP::NCONC
         LISP::DECODE-UNIVERSAL-TIME LISP::BUILT-IN-CLASS
         LISP::*RANDOM-STATE* LISP::BOOLE-ORC1 LISP::BOOLE-ORC2
         LISP::FILE-NAMESTRING LISP::VOID LISP::BIT-ORC2 LISP::1+
         LISP::PROG2 SLOOP::SLOOP SYSTEM::MATCH-BEGINNING
         LISP::*READ-SUPPRESS* LISP::DOLIST LISP::SIMPLE-BASE-STRING
         LISP::LET LISP::CHAR-NOT-GREATERP LISP::PATHNAMEP LISP::READ
         LISP::RANDOM-STATE-P SYSTEM::TAGS LISP::CDDAR LISP::BY
         LISP::SFUN LISP::REMOVE-IF LISP::&ALLOW-OTHER-KEYS
         LISP::FROUND LISP::CHAR-EQUAL
         LISP::MAKE-DISPATCH-MACRO-CHARACTER LISP::EIGHTH
         LISP::OPTIMIZE LISP::++ LISP::DO* LISP::SIMPLE-TYPE-ERROR
         LISP::ASIN LISP::SINGLE-FLOAT LISP::CCLOSURE LISP::REAL
         LISP::CHARACTER LISP::CHARACTERP LISP::GET SYSTEM::NODE
         LISP::OBJECT LISP::REALP LISP::FCEILING LISP::COPY-SYMBOL
         LISP::CHAR LISP::STANDARD-CHAR-P LISP::*DEBUG-IO* LISP::FIXNUM
         LISP::COMPILED-FUNCTION-P LISP::COUNT-IF LISP::** LISP::METHOD
         LISP::WITH-OPEN-FILE LISP::PACKAGE LISP::TRUNCATE_USE_C
         LISP::IGNORE LISP::IDENTITY LISP::CTYPECASE LISP::ETYPECASE
         LISP::PROGV LISP::NSUBSTITUTE-IF LISP::BOOLE-NOR
         SLOOP::DEF-LOOP-COLLECT))

;;; Definitions for package DEFPACKAGE of type SHADOW
(LISP::IN-PACKAGE "DEFPACKAGE")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::EXP LISP::DEFVAR LISP::DISASSEMBLE LISP::DELETE-IF
         LISP::UNSIGNED-SHORT LISP::GFUN LISP::NSUBST-IF-NOT LISP::CIS
         LISP::LOGAND LISP::BIT-EQV LISP::UNIX LISP::RANDOM
         LISP::COPY-LIST LISP::KEYWORDP LISP::CADAR
         LISP::MERGE-PATHNAMES LISP::BOOLE-C2 LISP::BIT-NOT LISP::CFUN
         LISP::STANDARD-OBJECT LISP::STRINGP LISP::METHOD-COMBINATION
         LISP::NSET-EXCLUSIVE-OR LISP::CLOSE LISP::INTEGER-DECODE-FLOAT
         LISP::CHAR-NOT-EQUAL LISP::COSH LISP::NTHCDR
         LISP::GET-UNIVERSAL-TIME LISP::YES-OR-NO-P LISP::READ-LINE
         LISP::LET* LISP::PATHNAME-TYPE LISP::FLOAT-PRECISION
         LISP::PROG* LISP::SYMBOL-NAME LISP::LOG LISP::OR
         LISP::PACKAGE-SHADOWING-SYMBOLS LISP::BREAK
         LISP::STRUCTURE-OBJECT LISP::ROTATEF LISP::SQRT LISP::CONS
         LISP::NSUBST-IF LISP::UNWIND-PROTECT LISP::CONSP
         SLOOP::DEF-LOOP-MACRO LISP::FLOAT-SIGN LISP::*EVALHOOK*
         LISP::CHAR-BIT LISP::SOME LISP::MAPC LISP::SETF LISP::CEILING
         LISP::&BODY LISP::CDAR LISP::MAKE-LIST LISP::MAKE-HASH-TABLE
         LISP::STRING-UPCASE LISP::STRING-DOWNCASE LISP::STYLE-WARNING
         LISP::ASINH LISP::NRECONC LISP::NSTRING-DOWNCASE LISP::SECOND
         LISP::RATIONALP LISP::SET-DISPATCH-MACRO-CHARACTER
         LISP::GET-DISPATCH-MACRO-CHARACTER LISP::CHECK-TYPE
         LISP::MAKE-STRING-INPUT-STREAM LISP::MAKE-STRING-OUTPUT-STREAM
         LISP::*BREAK-ON-WARNINGS* LISP::BYE LISP::SAFETY
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::*LOAD-VERBOSE*
         LISP::OTHERWISE LISP::NBUTLAST LISP::SORT LISP::WARNING
         LISP::DEFLA LISP::PROGN LISP::PUSHNEW LISP::SYSTEM LISP::CHAR=
         LISP::SIGNED-SHORT LISP::MAKE-ECHO-STREAM LISP::BIT-AND
         LISP::EXPORT LISP::EQ LISP::SOFTWARE-TYPE LISP::LOGTEST
         LISP::LIST-ALL-PACKAGES LISP::DEFTYPE LISP::GETF
         LISP::ROW-MAJOR-AREF LISP::TYPECASE LISP::CHAR-CONTROL-BIT
         LISP::HASH-TABLE-TEST LISP::USER-HOMEDIR-PATHNAME
         LISP::SYMBOL-PACKAGE LISP::BOOLEAN LISP::HOST-NAMESTRING
         LISP::IN-PACKAGE LISP::CAAR LISP::INTERN LISP::CONDITION
         LISP::IEEE-FLOATING-POINT LISP::LOGNOT LISP::SUBST-IF-NOT
         LISP::COPY-READTABLE LISP::REVAPPEND LISP::SYMBOL
         LISP::BIT-VECTOR LISP::SEARCH LISP::STREAM-ELEMENT-TYPE
         LISP::POP LISP::GO LISP::LIST LISP::SET-MACRO-CHARACTER
         LISP::GET-MACRO-CHARACTER LISP::PARSE-ERROR LISP::VALUES
         LISP::DESTRUCTURING-BIND LISP::RANDOM-STATE LISP::LISTP
         LISP::CHAR/= LISP::REMPROP LISP::DO LISP::HELP* LISP::ABS
         LISP::&KEY LISP::VECTOR-PUSH-EXTEND LISP::PACKAGE-NICKNAMES
         LISP::MULTIPLE-VALUE-PROG1 SLOOP::LOOP-RETURN
         LISP::END-OF-FILE LISP::*DEFAULT-PATHNAME-DEFAULTS* LISP::EXPT
         LISP::READER-ERROR LISP::REMHASH LISP::BLOCK
         LISP::PACKAGE-ERROR LISP::LAMBDA-CLOSURE LISP::PARSE-INTEGER
         LISP::TIME LISP::COERCE LISP::FIND-IF LISP::UNREAD-CHAR
         LISP::DOUBLE-FLOAT-EPSILON LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::BOOLE-IOR LISP::ASSERT LISP::ADJUSTABLE-ARRAY-P
         LISP::COPY-TREE LISP::CLEAR-OUTPUT LISP::CODE-CHAR
         LISP::STRING-CAPITALIZE LISP::/// LISP::WITH-OPEN-STREAM
         LISP::REST LISP::ACOS LISP::MACHINE-TYPE LISP::DENOMINATOR
         LISP::TRACE LISP::FLOATING-POINT-INEXACT LISP::*READ-BASE*
         LISP::CDR LISP::STRING-EQUAL LISP::GMP LISP::DELETE-FILE
         LISP::SPECIFIC-ERROR LISP::FIRST LISP::ALPHANUMERICP
         LISP::WITH-HASH-TABLE-ITERATOR LISP::SCALE-FLOAT
         LISP::CONCATENATED-STREAM LISP::CONTROL-ERROR
         LISP::FINISH-OUTPUT LISP::LAMBDA-PARAMETERS-LIMIT LISP::PRINC
         LISP::ADJOIN LISP::PI LISP::DOUBLE-FLOAT LISP::READTABLE
         LISP::READTABLEP LISP::ARRAY-RANK-LIMIT LISP::RENAME-FILE
         LISP::READ-CHAR LISP::PEEK-CHAR LISP::REMOVE-DUPLICATES
         LISP::BYTE LISP::*MODULES* LISP::GET-OUTPUT-STREAM-STRING
         LISP::MULTIPLE-VALUE-BIND LISP::VECTORP LISP::RASSOC-IF-NOT
         LISP::UNINTERN SLOOP::LOOP-FINISH
         LISP::SPECIFIC-CORRECTABLE-ERROR LISP::CDADAR LISP::FUNCTION
         LISP::LOGORC2 LISP::*PACKAGE* LISP::STRING-NOT-GREATERP
         LISP::INTERSECTION LISP::SPACE LISP::SEVENTH LISP::BASE-CHAR
         LISP::MAKE-CHAR LISP::NAME-CHAR LISP::SBIT LISP::CAADAR
         LISP::TAILP LISP::*TERMINAL-IO* LISP::STREAM-ERROR
         LISP::BOOLE-ANDC1 LISP::DO-ALL-SYMBOLS LISP::MAKUNBOUND
         LISP::PROVIDE LISP::THROW LISP::LENGTH LISP::CDAAR LISP::&AUX
         LISP::ARRAY-DISPLACEMENT LISP::PAIRLIS LISP::*PRINT-GENSYM*
         LISP::COMPILE-FILE-PATHNAME LISP::CAR LISP::FTRUNCATE
         LISP::DELETE-DUPLICATES LISP::NREVERSE LISP::APROPOS
         LISP::STRING-RIGHT-TRIM LISP::STEP LISP::BIT-NOR
         LISP::ARRAY-TOTAL-SIZE LISP::ECHO-STREAM
         LISP::DEFINE-SETF-METHOD LISP::FMAKUNBOUND LISP::SUBST-IF
         LISP::GET-DECODED-TIME LISP::LONG-FLOAT LISP::SIMPLE-WARNING
         LISP::CHAR-HYPER-BIT LISP::TAG LISP::RATIO LISP::EVENP
         LISP::QUOTE LISP::SIMPLE-STRING LISP::NSUBSTITUTE LISP::LAST
         LISP::NSET-DIFFERENCE LISP::COUNT LISP::CDAAAR
         LISP::SET-DIFFERENCE SLOOP::DEF-LOOP-FOR LISP::PPRINT
         LISP::SHORT-FLOAT-EPSILON LISP::SHORT-FLOAT-NEGATIVE-EPSILON
         LISP::SET-CHAR-BIT LISP::ACOSH LISP::LISTEN LISP::GENTEMP
         LISP::ERROR LISP::BSD LISP::ADJUST-ARRAY LISP::CLINES LISP::IF
         LISP::CAAAAR LISP::SET-SYNTAX-FROM-CHAR LISP::STRING-TRIM
         LISP::DIGIT-CHAR LISP::BOOLE-AND LISP::STRING> LISP::CAAAR
         LISP::GETHASH LISP::FILL-POINTER SLOOP::DEF-LOOP-MAP
         LISP::CDADDR LISP::DIRECTORY-NAMESTRING LISP::DEFUN
         LISP::TRUNCATE LISP::DEFENTRY LISP::ALPHA-CHAR-P
         LISP::SYMBOL-FUNCTION LISP::SUBSTITUTE-IF-NOT LISP::LDB-TEST
         LISP::FLOAT-DIGITS LISP::BIT-VECTOR-P LISP::CAADDR
         LISP::VARIABLE LISP::NUMERATOR LISP::NOTINLINE
         LISP::CHAR-LESSP LISP::WARN LISP::CHAR-NOT-LESSP
         LISP::ARRAY-DIMENSION-LIMIT LISP::MOD LISP::SXHASH
         LISP::PACKAGE-USE-LIST LISP::PACKAGE-USED-BY-LIST
         LISP::MACHINE-INSTANCE LISP::ARRAYP LISP::*GENSYM-COUNTER*
         LISP::UPPER-CASE-P LISP::*PRINT-CIRCLE* LISP::FTYPE LISP::THE
         SLOOP::LOCAL-FINISH LISP::COMPILER-LET LISP::WRITE-TO-STRING
         LISP::ARRAY-TOTAL-SIZE-LIMIT LISP::SEQUENCE LISP::FILE-AUTHOR
         LISP::MULTIPLE-VALUE-CALL LISP::*MACROEXPAND-HOOK* LISP::PLUSP
         LISP::INTERNAL-TIME-UNITS-PER-SECOND LISP::LIST*
         LISP::*PRINT-ARRAY* LISP::FILE-WRITE-DATE LISP::LAMBDA
         LISP::ED LISP::OPEN LISP::AREF LISP::RASSOC-IF LISP::LOGORC1
         LISP::PROCLAIM LISP::CHAR-SUPER-BIT LISP::APPEND
         LISP::CONCATENATE LISP::WRITE-STRING LISP::MISMATCH
         LISP::SIMPLE-STRING-P LISP::PRINT LISP::MULTIPLE-VALUES-LIMIT
         LISP::PRIN1-TO-STRING LISP::PRINC-TO-STRING
         LISP::SIMPLE-CONDITION LISP::TERPRI LISP::CDAADR
         LISP::FLOATING-POINT-OVERFLOW LISP::FLOATING-POINT-UNDERFLOW
         LISP::CALL-ARGUMENTS-LIMIT LISP::COPY-SEQ LISP::FUNCALL
         LISP::CLRHASH LISP::SHORT-SITE-NAME LISP::LONG-FLOAT-EPSILON
         LISP::LONG-FLOAT-NEGATIVE-EPSILON LISP::ASSOC-IF-NOT
         LISP::CAAADR LISP::STRING-CHAR LISP::LOGANDC1
         LISP::WITH-PACKAGE-ITERATOR LISP::NUMBERP LISP::COMPLEX
         LISP::AND LISP::EVAL-WHEN LISP::LOOP LISP::READ-FROM-STRING
         LISP::*STANDARD-OUTPUT* LISP::CHAR-NAME LISP::COMPILE-FILE
         LISP::FLOAT LISP::*ERROR-OUTPUT* LISP::TYPE-ERROR
         LISP::COMPILATION-SPEED LISP::LOGXOR LISP::LIST-LENGTH
         LISP::DRIBBLE LISP::EXTENDED-CHAR LISP::MAP
         LISP::ARRAY-ELEMENT-TYPE LISP::ROUND LISP::STRING-LEFT-TRIM
         LISP::DECLAIM LISP::SAVE LISP::SIN LISP::*PRINT-LENGTH*
         LISP::DECLARATION LISP::DECODE-FLOAT LISP::PATHNAME-NAME
         LISP::STRING= LISP::PHASE LISP::SPICE LISP::RASSOC
         LISP::LISP-IMPLEMENTATION-TYPE LISP::UNTRACE
         LISP::PRINT-NOT-READABLE LISP::ARRAY-ROW-MAJOR-INDEX
         LISP::SUBSTITUTE-IF LISP::BOOLE LISP::TRUENAME
         LISP::DEFCONSTANT LISP::VALUES-LIST LISP::*LINK-ARRAY*
         LISP::&REST LISP::MAKE-RANDOM-STATE LISP::CHAR>
         LISP::BYTE-SIZE LISP::MIN LISP::CDDDR LISP::BIT-IOR
         LISP::VECTOR LISP::UNSIGNED-BYTE LISP::SERIOUS-CONDITION
         LISP::SYMBOL-PLIST LISP::*READTABLE* LISP::SIMPLE-BIT-VECTOR-P
         LISP::LEAST-POSITIVE-SHORT-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LISP::LOWER-CASE-P
         SYSTEM::ALLOCATE LISP::EQUALP LISP::SUBSTITUTE LISP::SUBSEQ
         LISP::MINUSP LISP::MOST-NEGATIVE-SHORT-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-LONG-FLOAT LISP::FILE-LENGTH
         LISP::FILE-ERROR LISP::HASH-TABLE LISP::SPEED LISP::COMMON
         LISP::*PRINT-RADIX* LISP::POSITIVE-FIXNUM
         LISP::UNBOUND-VARIABLE LISP::RATIONAL
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::FRESH-LINE LISP::WHEN
         LISP::COMPILE LISP::FLET LISP::SPECIAL LISP::CLASS
         LISP::CELL-ERROR LISP::RPLACD LISP::TYPE-OF
         LISP::SPECIAL-OPERATOR-P LISP::DESCRIBE LISP::POSITION
         LISP::STABLE-SORT LISP::BOTH-CASE-P LISP::SYMBOLP
         LISP::*PRINT-READABLY* LISP::SHADOW LISP::STREAM
         LISP::CHAR-BITS LISP::MAKE-ARRAY LISP::FUNCTIONP LISP::&WHOLE
         LISP::SUBST LISP::SCHAR LISP::ARRAY-DIMENSION LISP::COND
         LISP::DO-EXTERNAL-SYMBOLS LISP::CHAR-CODE-LIMIT
         LISP::CHAR-FONT-LIMIT LISP::SATISFIES LISP::MASK-FIELD
         LISP::ARITHMETIC-ERROR LISP::CADDR LISP::LAMBDA-LIST-KEYWORDS
         LISP::MACRO LISP::STRING-NOT-EQUAL LISP::STRING-LESSP
         LISP::USE-PACKAGE LISP::MULTIPLE-VALUE-SETQ LISP::>=
         LISP::LOGEQV LISP::*EVAL-WHEN-COMPILE* LISP::HASH-TABLE-P
         LISP::GRAPHIC-CHAR-P LISP::EQL LISP::MAPHASH
         LISP::NINTERSECTION LISP::<= LISP::NAMESTRING
         LISP::MAKE-CONCATENATED-STREAM LISP::SHORT-FLOAT
         LISP::FILE-STREAM LISP::WRITE-LINE LISP::VECTOR-PUSH
         LISP::ENDP LISP::DIRECTORY LISP::TYPE LISP::ASSOC-IF LISP::DPB
         LISP::TYPEP LISP::FIFTH LISP::LOGNAND LISP::SIGNED-BYTE
         LISP::EVERY LISP::SUBLIS LISP::NULL LISP::FLOATP LISP::STRING<
         LISP::*TRACE-OUTPUT* LISP::WRITE-CHAR LISP::SGC
         LISP::STANDARD-GENERIC-FUNCTION LISP::MAPL LISP::PROG1
         LISP::COMPLEXP LISP::PROCLAMATION LISP::INSPECT
         LISP::MACROEXPAND-1 LISP::BIT-ANDC1 LISP::SETQ LISP::CHAR>=
         LISP::REALPART LISP::LDIFF LISP::SINH LISP::BROADCAST-STREAM
         LISP::BASE-STRING LISP::MAKE-STRING LISP::CDDDAR
         LISP::INTEGER-LENGTH LISP::OUTPUT-STREAM-P LISP::NUNION
         LISP::/= LISP::PACKAGE-NAME LISP::ECASE LISP::PATHNAME
         LISP::APPLY LISP::CHAR-INT LISP::TAN
         LISP::MOST-NEGATIVE-FIXNUM LISP::MAKE-SYNONYM-STREAM
         LISP::MACROEXPAND LISP::CADDAR LISP::ISQRT LISP::CCASE
         LISP::GCD LISP::KEYWORD LISP::UNLESS LISP::MAP-INTO
         LISP::SYNONYM-STREAM LISP::SUBSETP LISP::POSITION-IF
         LISP::INCF LISP::SHIFTF LISP::BOOLE-XOR LISP::REM LISP::LOGNOR
         LISP::FIND LISP::MAX LISP::SIMPLE-VECTOR-P LISP::IMPORT
         LISP::MACHINE-VERSION LISP::SHADOWING-IMPORT LISP::BOOLE-EQV
         LISP::CONJUGATE LISP::READ-CHAR-NO-HANG LISP::WRITE-BYTE
         LISP::WITH-OUTPUT-TO-STRING LISP::BYTE-POSITION
         LISP::STANDARD-CHAR LISP::STRING LISP::MEMBER-IF
         LISP::CHAR-BITS-LIMIT LISP::NSTRING-UPCASE LISP::DEFMACRO
         LISP::BUTLAST LISP::CDDAAR LISP::IMAGPART LISP::LOGANDC2
         LISP::HASH-TABLE-SIZE LISP::FFLOOR LISP::*PRINT-LEVEL*
         LISP::DEFSTRUCT LISP::DELETE-PACKAGE LISP::BOOLE-CLR
         LISP::DO-SYMBOLS LISP::INTEGERP LISP::NUMBER LISP::CADAAR
         LISP::NIL LISP::T LISP::DELETE LISP::DEFCFUN
         LISP::DEFINE-MODIFY-MACRO LISP::COMPILED-FUNCTION
         LISP::NOTEVERY LISP::BOOLE-2 LISP::STRUCTURE
         LISP::UNBOUND-SLOT LISP::RENAME-PACKAGE LISP::SIGNUM
         LISP::CDDDDR LISP::GET-SETF-METHOD-MULTIPLE-VALUE
         LISP::FILE-POSITION LISP::LOGBITP LISP::LAMBDA-BLOCK
         LISP::STANDARD-METHOD LISP::UNSIGNED-CHAR LISP::PSETQ
         LISP::EVAL LISP::CERROR LISP::CHAR-GREATERP
         LISP::GET-SETF-METHOD LISP::SYMBOL-VALUE LISP::+++ LISP::LCM
         LISP::BOOLE-NAND LISP::SIMPLE-ARRAY LISP::CADDDR
         LISP::SIMPLE-BIT-VECTOR LISP::CHAR-META-BIT LISP::PRIN1
         LISP::BIT-ORC1 LISP::PSETF LISP::RETURN LISP::MAKE-PATHNAME
         LISP::DOTIMES LISP::DEPOSIT-FIELD LISP::*QUERY-IO*
         LISP::&ENVIRONMENT LISP::ARRAY-DIMENSIONS LISP::BSD386
         LISP::MAKE-BROADCAST-STREAM LISP::BOOLE-ANDC2
         LISP::MAKE-TWO-WAY-STREAM LISP::INPUT-STREAM-P
         LISP::DIGIT-CHAR-P LISP::*STANDARD-INPUT* LISP::BOUNDP
         LISP::ODDP LISP::READ-DELIMITED-LIST LISP::SIXTH
         LISP::SUBTYPEP LISP::NSTRING-CAPITALIZE LISP::DECLARE
         LISP::AKCL LISP::FLOOR LISP::GBC LISP::GENSYM
         LISP::ARRAY-HAS-FILL-POINTER-P LISP::LOGIOR LISP::Y-OR-N-P
         LISP::CHAR-FONT LISP::PARSE-NAMESTRING LISP::ARRAY-RANK
         LISP::NINTH LISP::EVALHOOK LISP::WITH-INPUT-FROM-STRING
         LISP::INTEGER LISP::MAKE-SEQUENCE LISP::SET-EXCLUSIVE-OR
         LISP::CHAR< LISP::INLINE LISP::CDDADR LISP::REMOVE-IF-NOT
         LISP::TANH LISP::ATAN LISP::NOT LISP::STRING-CHAR-P
         LISP::LONG-SITE-NAME LISP::PATHNAME-VERSION LISP::MAPCAN
         LISP::REQUIRE LISP::RPLACA LISP::TAGBODY LISP::COPY-ALIST
         LISP::CADADR LISP::MAPCAR LISP::> LISP::FIND-PACKAGE
         LISP::FBOUNDP LISP::CLX-LITTLE-ENDIAN LISP::= LISP::DEFSETF
         LISP::ZEROP LISP::MC68020 LISP::UNUSE-PACKAGE
         LISP::MOST-POSITIVE-SHORT-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-LONG-FLOAT LISP::LOGICAL-PATHNAME
         LISP::APPLYHOOK LISP::< LISP::LOGCOUNT LISP::ENOUGH-NAMESTRING
         LISP::MULTIPLE-VALUE-LIST LISP::TWO-WAY-STREAM LISP::CDDR
         LISP::ASSOC LISP::REMF LISP::LDB LISP::MACROLET LISP::CDADR
         LISP::UNION LISP::FIND-ALL-SYMBOLS LISP::MAKE-PACKAGE
         LISP::&OPTIONAL LISP::THIRD LISP::LABELS LISP::BOOLE-C1
         LISP::FIND-IF-NOT LISP::LOAD LISP::DELETE-IF-NOT LISP::ACONS
         LISP::UNDEFINED-FUNCTION LISP::SIGNED-CHAR LISP::INT
         LISP::PACKAGEP LISP::ENCODE-UNIVERSAL-TIME LISP::FORMAT
         LISP::TENTH LISP::STRUCTURE-CLASS LISP::MEMBER-IF-NOT
         LISP::LEAST-NEGATIVE-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LISP::KCL
         LISP::BOOLE-1 LISP::REDUCE LISP::SVREF LISP::NTH-VALUE
         LISP::FORCE-OUTPUT LISP::NSUBSTITUTE-IF-NOT LISP::CATCH
         LISP::STORAGE-CONDITION LISP::MERGE LISP::CASE
         LISP::CLEAR-INPUT LISP::REPLACE LISP::***
         LISP::GENERIC-FUNCTION LISP::GCL LISP::/ LISP::BOOLE-SET
         LISP::SOFTWARE-VERSION LISP::APROPOS-LIST
         LISP::POSITION-IF-NOT LISP::READ-BYTE LISP::FLOAT-RADIX
         LISP::DECF LISP::PROG LISP::- LISP::MAPCON LISP::CADR
         LISP::EQUAL LISP::CAADR LISP::+ LISP::PATHNAME-DEVICE
         LISP::MACRO-FUNCTION LISP::MAPLIST LISP::REVERSE
         LISP::FIND-SYMBOL LISP::* LISP::LOCALLY LISP::BIT-ANDC2
         LISP::COMMONP LISP::*FEATURES* LISP::DIVISION-BY-ZERO
         LISP::ARRAY LISP::DOUBLE LISP::DEFPARAMETER
         LISP::PATHNAME-DIRECTORY LISP::STRING-NOT-LESSP LISP::ELT
         LISP::NTH LISP::RETURN-FROM LISP::BIGNUM LISP::MAKE-SYMBOL
         LISP::FILL LISP::CHAR-CODE LISP::*PRINT-ESCAPE*
         LISP::*PRINT-BASE* LISP::*PRINT-CASE*
         LISP::FLOATING-POINT-INVALID-OPERATION LISP::NSUBST
         LISP::SIMPLE-VECTOR LISP::ARRAY-IN-BOUNDS-P
         LISP::READ-PRESERVING-WHITESPACE LISP::ATANH LISP::ATOM
         LISP::BIT-NAND LISP::VECTOR-POP LISP::MEMBER LISP::REMOVE
         LISP::CHAR<= LISP::PUSH LISP::PROGRAM-ERROR LISP::KYOTO
         LISP::CHAR-UPCASE LISP::*PRINT-PRETTY*
         LISP::MOST-POSITIVE-FIXNUM LISP::PATHNAME-HOST
         LISP::DOCUMENTATION LISP::// LISP::UNEXPORT LISP::PROBE-FILE
         LISP::STANDARD-CLASS LISP::GET-INTERNAL-REAL-TIME
         LISP::GET-INTERNAL-RUN-TIME LISP::NOTANY LISP::QUIT LISP::ROOM
         LISP::*APPLYHOOK* LISP::COS LISP::CHAR-DOWNCASE
         LISP::CONSTANTLY LISP::RATIONALIZE
         LISP::LISP-IMPLEMENTATION-VERSION LISP::CONSTANTP
         LISP::HASH-TABLE-COUNT LISP::STREAMP LISP::*BREAK-ENABLE*
         LISP::1- LISP::BIT-XOR LISP::STRING-STREAM
         LISP::GET-PROPERTIES LISP::COUNT-IF-NOT LISP::BIT LISP::ASH
         LISP::NSUBLIS LISP::FOURTH LISP::STRING<= LISP::STRING>=
         LISP::STRING/= LISP::SLEEP LISP::LAMBDA-BLOCK-CLOSURE
         LISP::HELP LISP::TREE-EQUAL LISP::SET LISP::INT-CHAR
         LISP::STRING-GREATERP LISP::SINGLE-FLOAT-EPSILON
         LISP::SINGLE-FLOAT-NEGATIVE-EPSILON LISP::SPECIAL-FORM-P
         LISP::COMPLEMENT LISP::WRITE LISP::NCONC
         LISP::DECODE-UNIVERSAL-TIME LISP::BUILT-IN-CLASS
         LISP::*RANDOM-STATE* LISP::BOOLE-ORC1 LISP::BOOLE-ORC2
         LISP::FILE-NAMESTRING LISP::VOID LISP::BIT-ORC2 LISP::1+
         LISP::PROG2 SLOOP::SLOOP LISP::*READ-SUPPRESS* LISP::DOLIST
         LISP::SIMPLE-BASE-STRING LISP::LET LISP::CHAR-NOT-GREATERP
         LISP::PATHNAMEP LISP::READ LISP::RANDOM-STATE-P LISP::CDDAR
         LISP::BY LISP::SFUN LISP::REMOVE-IF LISP::&ALLOW-OTHER-KEYS
         LISP::FROUND LISP::CHAR-EQUAL
         LISP::MAKE-DISPATCH-MACRO-CHARACTER LISP::EIGHTH
         LISP::OPTIMIZE LISP::++ LISP::DO* LISP::SIMPLE-TYPE-ERROR
         LISP::ASIN LISP::SINGLE-FLOAT LISP::CCLOSURE LISP::REAL
         LISP::CHARACTER LISP::CHARACTERP LISP::GET LISP::OBJECT
         LISP::REALP LISP::FCEILING LISP::COPY-SYMBOL LISP::CHAR
         LISP::STANDARD-CHAR-P LISP::*DEBUG-IO* LISP::FIXNUM
         LISP::COMPILED-FUNCTION-P LISP::COUNT-IF LISP::** LISP::METHOD
         LISP::WITH-OPEN-FILE LISP::PACKAGE LISP::TRUNCATE_USE_C
         LISP::IGNORE LISP::IDENTITY LISP::CTYPECASE LISP::ETYPECASE
         LISP::PROGV LISP::NSUBSTITUTE-IF LISP::BOOLE-NOR
         SLOOP::DEF-LOOP-COLLECT))

;;; Definitions for package ANSI-LOOP of type SHADOW
(LISP::IN-PACKAGE "ANSI-LOOP")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::LOOP
       LISP::EXP
       LISP::DEFVAR
       LISP::DISASSEMBLE
       LISP::DELETE-IF
       LISP::UNSIGNED-SHORT
       LISP::GFUN
       LISP::NSUBST-IF-NOT
       LISP::CIS
       LISP::LOGAND
       LISP::BIT-EQV
       LISP::UNIX
       LISP::RANDOM
       LISP::COPY-LIST
       LISP::KEYWORDP
       LISP::CADAR
       LISP::MERGE-PATHNAMES
       LISP::BOOLE-C2
       LISP::BIT-NOT
       LISP::CFUN
       LISP::STANDARD-OBJECT
       LISP::STRINGP
       LISP::METHOD-COMBINATION
       LISP::NSET-EXCLUSIVE-OR
       LISP::CLOSE
       LISP::INTEGER-DECODE-FLOAT
       LISP::CHAR-NOT-EQUAL
       LISP::COSH
       LISP::NTHCDR
       LISP::GET-UNIVERSAL-TIME
       LISP::YES-OR-NO-P
       LISP::READ-LINE
       LISP::LET*
       LISP::PATHNAME-TYPE
       LISP::FLOAT-PRECISION
       LISP::PROG*
       LISP::SYMBOL-NAME
       LISP::LOG
       LISP::OR
       LISP::PACKAGE-SHADOWING-SYMBOLS
       LISP::BREAK
       LISP::STRUCTURE-OBJECT
       LISP::ROTATEF
       LISP::SQRT
       LISP::CONS
       LISP::NSUBST-IF
       LISP::UNWIND-PROTECT
       LISP::CONSP
       LISP::FLOAT-SIGN
       LISP::*EVALHOOK*
       LISP::CHAR-BIT
       LISP::SOME
       LISP::MAPC
       LISP::SETF
       LISP::CEILING
       LISP::&BODY
       LISP::CDAR
       LISP::MAKE-LIST
       LISP::MAKE-HASH-TABLE
       LISP::STRING-UPCASE
       LISP::STRING-DOWNCASE
       LISP::STYLE-WARNING
       LISP::ASINH
       LISP::NRECONC
       LISP::NSTRING-DOWNCASE
       LISP::SECOND
       LISP::RATIONALP
       LISP::SET-DISPATCH-MACRO-CHARACTER
       LISP::GET-DISPATCH-MACRO-CHARACTER
       LISP::CHECK-TYPE
       LISP::MAKE-STRING-INPUT-STREAM
       LISP::MAKE-STRING-OUTPUT-STREAM
       LISP::*BREAK-ON-WARNINGS*
       LISP::BYE
       LISP::SAFETY
       LISP::*READ-DEFAULT-FLOAT-FORMAT*
       LISP::*LOAD-VERBOSE*
       LISP::OTHERWISE
       LISP::NBUTLAST
       LISP::SORT
       LISP::WARNING
       LISP::DEFLA
       LISP::PROGN
       LISP::PUSHNEW
       LISP::SYSTEM
       LISP::CHAR=
       LISP::SIGNED-SHORT
       LISP::MAKE-ECHO-STREAM
       LISP::BIT-AND
       LISP::EXPORT
       LISP::EQ
       LISP::SOFTWARE-TYPE
       LISP::LOGTEST
       LISP::LIST-ALL-PACKAGES
       LISP::DEFTYPE
       LISP::GETF
       LISP::ROW-MAJOR-AREF
       LISP::TYPECASE
       LISP::CHAR-CONTROL-BIT
       LISP::HASH-TABLE-TEST
       LISP::USER-HOMEDIR-PATHNAME
       LISP::SYMBOL-PACKAGE
       LISP::BOOLEAN
       LISP::HOST-NAMESTRING
       LISP::IN-PACKAGE
       LISP::CAAR
       LISP::INTERN
       LISP::CONDITION
       LISP::IEEE-FLOATING-POINT
       LISP::LOGNOT
       LISP::SUBST-IF-NOT
       LISP::COPY-READTABLE
       LISP::REVAPPEND
       LISP::SYMBOL
       LISP::BIT-VECTOR
       LISP::SEARCH
       LISP::STREAM-ELEMENT-TYPE
       LISP::POP
       LISP::GO
       LISP::LIST
       LISP::SET-MACRO-CHARACTER
       LISP::GET-MACRO-CHARACTER
       LISP::PARSE-ERROR
       LISP::VALUES
       LISP::DESTRUCTURING-BIND
       LISP::RANDOM-STATE
       LISP::LISTP
       LISP::CHAR/=
       LISP::REMPROP
       LISP::DO
       LISP::HELP*
       LISP::ABS
       LISP::&KEY
       LISP::VECTOR-PUSH-EXTEND
       LISP::PACKAGE-NICKNAMES
       LISP::MULTIPLE-VALUE-PROG1
       LISP::END-OF-FILE
       LISP::*DEFAULT-PATHNAME-DEFAULTS*
       LISP::EXPT
       LISP::READER-ERROR
       LISP::REMHASH
       LISP::BLOCK
       LISP::PACKAGE-ERROR
       LISP::LAMBDA-CLOSURE
       LISP::PARSE-INTEGER
       LISP::TIME
       LISP::COERCE
       LISP::FIND-IF
       LISP::UNREAD-CHAR
       LISP::DOUBLE-FLOAT-EPSILON
       LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
       LISP::BOOLE-IOR
       LISP::ASSERT
       LISP::ADJUSTABLE-ARRAY-P
       LISP::COPY-TREE
       LISP::CLEAR-OUTPUT
       LISP::CODE-CHAR
       LISP::STRING-CAPITALIZE
       LISP::///
       LISP::WITH-OPEN-STREAM
       LISP::REST
       LISP::ACOS
       LISP::MACHINE-TYPE
       LISP::DENOMINATOR
       LISP::TRACE
       LISP::FLOATING-POINT-INEXACT
       LISP::*READ-BASE*
       LISP::CDR
       LISP::STRING-EQUAL
       LISP::GMP
       LISP::DELETE-FILE
       LISP::SPECIFIC-ERROR
       LISP::FIRST
       LISP::ALPHANUMERICP
       LISP::WITH-HASH-TABLE-ITERATOR
       LISP::SCALE-FLOAT
       LISP::CONCATENATED-STREAM
       LISP::CONTROL-ERROR
       LISP::FINISH-OUTPUT
       LISP::LAMBDA-PARAMETERS-LIMIT
       LISP::PRINC
       LISP::ADJOIN
       LISP::PI
       LISP::DOUBLE-FLOAT
       LISP::READTABLE
       LISP::READTABLEP
       LISP::ARRAY-RANK-LIMIT
       LISP::RENAME-FILE
       LISP::READ-CHAR
       LISP::PEEK-CHAR
       LISP::REMOVE-DUPLICATES
       LISP::BYTE
       LISP::*MODULES*
       LISP::GET-OUTPUT-STREAM-STRING
       LISP::MULTIPLE-VALUE-BIND
       LISP::VECTORP
       LISP::RASSOC-IF-NOT
       LISP::UNINTERN
       LISP::SPECIFIC-CORRECTABLE-ERROR
       LISP::CDADAR
       LISP::FUNCTION
       LISP::LOGORC2
       LISP::*PACKAGE*
       LISP::STRING-NOT-GREATERP
       LISP::INTERSECTION
       LISP::SPACE
       LISP::SEVENTH
       LISP::BASE-CHAR
       LISP::MAKE-CHAR
       LISP::NAME-CHAR
       LISP::SBIT
       LISP::CAADAR
       LISP::TAILP
       LISP::*TERMINAL-IO*
       LISP::STREAM-ERROR
       LISP::BOOLE-ANDC1
       LISP::DO-ALL-SYMBOLS
       LISP::MAKUNBOUND
       LISP::PROVIDE
       LISP::THROW
       LISP::LENGTH
       LISP::CDAAR
       LISP::&AUX
       LISP::ARRAY-DISPLACEMENT
       LISP::PAIRLIS
       LISP::*PRINT-GENSYM*
       LISP::COMPILE-FILE-PATHNAME
       LISP::CAR
       LISP::FTRUNCATE
       LISP::DELETE-DUPLICATES
       LISP::NREVERSE
       LISP::APROPOS
       LISP::STRING-RIGHT-TRIM
       LISP::STEP
       LISP::BIT-NOR
       LISP::ARRAY-TOTAL-SIZE
       LISP::ECHO-STREAM
       LISP::DEFINE-SETF-METHOD
       LISP::FMAKUNBOUND
       LISP::SUBST-IF
       LISP::GET-DECODED-TIME
       LISP::LONG-FLOAT
       LISP::SIMPLE-WARNING
       LISP::CHAR-HYPER-BIT
       LISP::TAG
       LISP::RATIO
       LISP::EVENP
       LISP::QUOTE
       LISP::SIMPLE-STRING
       LISP::NSUBSTITUTE
       LISP::LAST
       LISP::NSET-DIFFERENCE
       LISP::COUNT
       LISP::CDAAAR
       LISP::SET-DIFFERENCE
       LISP::PPRINT
       LISP::SHORT-FLOAT-EPSILON
       LISP::SHORT-FLOAT-NEGATIVE-EPSILON
       LISP::SET-CHAR-BIT
       LISP::ACOSH
       LISP::LISTEN
       LISP::GENTEMP
       LISP::ERROR
       LISP::BSD
       LISP::ADJUST-ARRAY
       LISP::CLINES
       LISP::IF
       LISP::CAAAAR
       LISP::SET-SYNTAX-FROM-CHAR
       LISP::STRING-TRIM
       LISP::DIGIT-CHAR
       LISP::BOOLE-AND
       LISP::STRING>
       LISP::CAAAR
       LISP::GETHASH
       LISP::FILL-POINTER
       LISP::CDADDR
       LISP::DIRECTORY-NAMESTRING
       LISP::DEFUN
       LISP::TRUNCATE
       LISP::DEFENTRY
       LISP::ALPHA-CHAR-P
       LISP::SYMBOL-FUNCTION
       LISP::SUBSTITUTE-IF-NOT
       LISP::LDB-TEST
       LISP::FLOAT-DIGITS
       LISP::BIT-VECTOR-P
       LISP::CAADDR
       LISP::VARIABLE
       LISP::NUMERATOR
       LISP::NOTINLINE
       LISP::CHAR-LESSP
       LISP::WARN
       LISP::CHAR-NOT-LESSP
       LISP::ARRAY-DIMENSION-LIMIT
       LISP::MOD
       LISP::SXHASH
       LISP::PACKAGE-USE-LIST
       LISP::PACKAGE-USED-BY-LIST
       LISP::MACHINE-INSTANCE
       LISP::ARRAYP
       LISP::*GENSYM-COUNTER*
       LISP::UPPER-CASE-P
       LISP::*PRINT-CIRCLE*
       LISP::FTYPE
       LISP::THE
       LISP::COMPILER-LET
       LISP::WRITE-TO-STRING
       LISP::ARRAY-TOTAL-SIZE-LIMIT
       LISP::SEQUENCE
       LISP::FILE-AUTHOR
       LISP::MULTIPLE-VALUE-CALL
       LISP::*MACROEXPAND-HOOK*
       LISP::PLUSP
       LISP::INTERNAL-TIME-UNITS-PER-SECOND
       LISP::LIST*
       LISP::*PRINT-ARRAY*
       LISP::FILE-WRITE-DATE
       LISP::LAMBDA
       LISP::ED
       LISP::OPEN
       LISP::AREF
       LISP::RASSOC-IF
       LISP::LOGORC1
       LISP::PROCLAIM
       LISP::CHAR-SUPER-BIT
       LISP::APPEND
       LISP::CONCATENATE
       LISP::WRITE-STRING
       LISP::MISMATCH
       LISP::SIMPLE-STRING-P
       LISP::PRINT
       LISP::MULTIPLE-VALUES-LIMIT
       LISP::PRIN1-TO-STRING
       LISP::PRINC-TO-STRING
       LISP::SIMPLE-CONDITION
       LISP::TERPRI
       LISP::CDAADR
       LISP::FLOATING-POINT-OVERFLOW
       LISP::FLOATING-POINT-UNDERFLOW
       LISP::CALL-ARGUMENTS-LIMIT
       LISP::COPY-SEQ
       LISP::FUNCALL
       LISP::CLRHASH
       LISP::SHORT-SITE-NAME
       LISP::LONG-FLOAT-EPSILON
       LISP::LONG-FLOAT-NEGATIVE-EPSILON
       LISP::ASSOC-IF-NOT
       LISP::CAAADR
       LISP::STRING-CHAR
       LISP::LOGANDC1
       LISP::WITH-PACKAGE-ITERATOR
       LISP::NUMBERP
       LISP::COMPLEX
       LISP::AND
       LISP::EVAL-WHEN
       LISP::READ-FROM-STRING
       LISP::*STANDARD-OUTPUT*
       LISP::CHAR-NAME
       LISP::COMPILE-FILE
       LISP::FLOAT
       LISP::*ERROR-OUTPUT*
       LISP::TYPE-ERROR
       LISP::COMPILATION-SPEED
       LISP::LOGXOR
       LISP::LIST-LENGTH
       LISP::DRIBBLE
       LISP::EXTENDED-CHAR
       LISP::MAP
       LISP::ARRAY-ELEMENT-TYPE
       LISP::ROUND
       LISP::STRING-LEFT-TRIM
       LISP::DECLAIM
       LISP::SAVE
       LISP::SIN
       LISP::*PRINT-LENGTH*
       LISP::DECLARATION
       LISP::DECODE-FLOAT
       LISP::PATHNAME-NAME
       LISP::STRING=
       LISP::PHASE
       LISP::SPICE
       LISP::RASSOC
       LISP::LISP-IMPLEMENTATION-TYPE
       LISP::UNTRACE
       LISP::PRINT-NOT-READABLE
       LISP::ARRAY-ROW-MAJOR-INDEX
       LISP::SUBSTITUTE-IF
       LISP::BOOLE
       LISP::TRUENAME
       LISP::DEFCONSTANT
       LISP::VALUES-LIST
       LISP::*LINK-ARRAY*
       LISP::&REST
       LISP::MAKE-RANDOM-STATE
       LISP::CHAR>
       LISP::BYTE-SIZE
       LISP::MIN
       LISP::CDDDR
       LISP::BIT-IOR
       LISP::VECTOR
       LISP::UNSIGNED-BYTE
       LISP::SERIOUS-CONDITION
       LISP::SYMBOL-PLIST
       LISP::*READTABLE*
       LISP::SIMPLE-BIT-VECTOR-P
       LISP::LEAST-POSITIVE-SHORT-FLOAT
       LISP::LEAST-POSITIVE-SINGLE-FLOAT
       LISP::LEAST-POSITIVE-DOUBLE-FLOAT
       LISP::LEAST-POSITIVE-LONG-FLOAT
       LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
       LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
       LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
       LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT
       LISP::LOWER-CASE-P
       SYSTEM::ALLOCATE
       LISP::EQUALP
       LISP::SUBSTITUTE
       LISP::SUBSEQ
       LISP::MINUSP
       LISP::MOST-NEGATIVE-SHORT-FLOAT
       LISP::MOST-NEGATIVE-SINGLE-FLOAT
       LISP::MOST-NEGATIVE-DOUBLE-FLOAT
       LISP::MOST-NEGATIVE-LONG-FLOAT
       LISP::FILE-LENGTH
       LISP::FILE-ERROR
       LISP::HASH-TABLE
       LISP::SPEED
       LISP::COMMON
       LISP::*PRINT-RADIX*
       LISP::POSITIVE-FIXNUM
       LISP::UNBOUND-VARIABLE
       LISP::RATIONAL
       LISP::UPGRADED-ARRAY-ELEMENT-TYPE
       LISP::FRESH-LINE
       LISP::WHEN
       LISP::COMPILE
       LISP::FLET
       LISP::SPECIAL
       LISP::CLASS
       LISP::CELL-ERROR
       LISP::RPLACD
       LISP::TYPE-OF
       LISP::SPECIAL-OPERATOR-P
       LISP::DESCRIBE
       LISP::POSITION
       LISP::STABLE-SORT
       LISP::BOTH-CASE-P
       LISP::SYMBOLP
       LISP::*PRINT-READABLY*
       LISP::SHADOW
       LISP::STREAM
       LISP::CHAR-BITS
       LISP::MAKE-ARRAY
       LISP::FUNCTIONP
       LISP::&WHOLE
       LISP::SUBST
       LISP::SCHAR
       LISP::ARRAY-DIMENSION
       LISP::COND
       LISP::DO-EXTERNAL-SYMBOLS
       LISP::CHAR-CODE-LIMIT
       LISP::CHAR-FONT-LIMIT
       LISP::SATISFIES
       LISP::MASK-FIELD
       LISP::ARITHMETIC-ERROR
       LISP::CADDR
       LISP::LAMBDA-LIST-KEYWORDS
       LISP::MACRO
       LISP::STRING-NOT-EQUAL
       LISP::STRING-LESSP
       LISP::USE-PACKAGE
       LISP::MULTIPLE-VALUE-SETQ
       LISP::>=
       LISP::LOGEQV
       LISP::*EVAL-WHEN-COMPILE*
       LISP::HASH-TABLE-P
       LISP::GRAPHIC-CHAR-P
       LISP::EQL
       LISP::MAPHASH
       LISP::NINTERSECTION
       LISP::<=
       LISP::NAMESTRING
       LISP::MAKE-CONCATENATED-STREAM
       LISP::SHORT-FLOAT
       LISP::FILE-STREAM
       LISP::WRITE-LINE
       LISP::VECTOR-PUSH
       LISP::ENDP
       LISP::DIRECTORY
       LISP::TYPE
       LISP::ASSOC-IF
       LISP::DPB
       LISP::TYPEP
       LISP::FIFTH
       LISP::LOGNAND
       LISP::SIGNED-BYTE
       LISP::EVERY
       LISP::SUBLIS
       LISP::NULL
       LISP::FLOATP
       LISP::STRING<
       LISP::*TRACE-OUTPUT*
       LISP::WRITE-CHAR
       LISP::SGC
       LISP::STANDARD-GENERIC-FUNCTION
       LISP::MAPL
       LISP::PROG1
       LISP::COMPLEXP
       LISP::PROCLAMATION
       LISP::INSPECT
       LISP::MACROEXPAND-1
       LISP::BIT-ANDC1
       LISP::SETQ
       LISP::CHAR>=
       LISP::REALPART
       LISP::LDIFF
       LISP::SINH
       LISP::BROADCAST-STREAM
       LISP::BASE-STRING
       LISP::MAKE-STRING
       LISP::CDDDAR
       LISP::INTEGER-LENGTH
       LISP::OUTPUT-STREAM-P
       LISP::NUNION
       LISP::/=
       LISP::PACKAGE-NAME
       LISP::ECASE
       LISP::PATHNAME
       LISP::APPLY
       LISP::CHAR-INT
       LISP::TAN
       LISP::MOST-NEGATIVE-FIXNUM
       LISP::MAKE-SYNONYM-STREAM
       LISP::MACROEXPAND
       LISP::CADDAR
       LISP::ISQRT
       LISP::CCASE
       LISP::GCD
       LISP::KEYWORD
       LISP::UNLESS
       LISP::MAP-INTO
       LISP::SYNONYM-STREAM
       LISP::SUBSETP
       LISP::POSITION-IF
       LISP::INCF
       LISP::SHIFTF
       LISP::BOOLE-XOR
       LISP::REM
       LISP::LOGNOR
       LISP::FIND
       LISP::MAX
       LISP::SIMPLE-VECTOR-P
       LISP::IMPORT
       LISP::MACHINE-VERSION
       LISP::SHADOWING-IMPORT
       LISP::BOOLE-EQV
       LISP::CONJUGATE
       LISP::READ-CHAR-NO-HANG
       LISP::WRITE-BYTE
       LISP::WITH-OUTPUT-TO-STRING
       LISP::BYTE-POSITION
       LISP::STANDARD-CHAR
       LISP::STRING
       LISP::MEMBER-IF
       LISP::CHAR-BITS-LIMIT
       LISP::NSTRING-UPCASE
       LISP::DEFMACRO
       LISP::BUTLAST
       LISP::CDDAAR
       LISP::IMAGPART
       LISP::LOGANDC2
       LISP::HASH-TABLE-SIZE
       LISP::FFLOOR
       LISP::*PRINT-LEVEL*
       LISP::DEFSTRUCT
       LISP::DELETE-PACKAGE
       LISP::BOOLE-CLR
       LISP::DO-SYMBOLS
       LISP::INTEGERP
       LISP::NUMBER
       LISP::CADAAR
       LISP::NIL
       LISP::T
       LISP::DELETE
       LISP::DEFCFUN
       LISP::DEFINE-MODIFY-MACRO
       LISP::COMPILED-FUNCTION
       LISP::NOTEVERY
       LISP::BOOLE-2
       LISP::STRUCTURE
       LISP::UNBOUND-SLOT
       LISP::RENAME-PACKAGE
       LISP::SIGNUM
       LISP::CDDDDR
       LISP::GET-SETF-METHOD-MULTIPLE-VALUE
       LISP::FILE-POSITION
       LISP::LOGBITP
       LISP::LAMBDA-BLOCK
       LISP::STANDARD-METHOD
       LISP::UNSIGNED-CHAR
       LISP::PSETQ
       LISP::EVAL
       LISP::CERROR
       LISP::CHAR-GREATERP
       LISP::GET-SETF-METHOD
       LISP::SYMBOL-VALUE
       LISP::+++
       LISP::LCM
       LISP::BOOLE-NAND
       LISP::SIMPLE-ARRAY
       LISP::CADDDR
       LISP::SIMPLE-BIT-VECTOR
       LISP::CHAR-META-BIT
       LISP::PRIN1
       LISP::BIT-ORC1
       LISP::PSETF
       LISP::RETURN
       LISP::MAKE-PATHNAME
       LISP::DOTIMES
       LISP::DEPOSIT-FIELD
       LISP::*QUERY-IO*
       LISP::&ENVIRONMENT
       LISP::ARRAY-DIMENSIONS
       LISP::BSD386
       LISP::MAKE-BROADCAST-STREAM
       LISP::BOOLE-ANDC2
       LISP::MAKE-TWO-WAY-STREAM
       LISP::INPUT-STREAM-P
       LISP::DIGIT-CHAR-P
       LISP::*STANDARD-INPUT*
       LISP::BOUNDP
       LISP::ODDP
       LISP::READ-DELIMITED-LIST
       LISP::SIXTH
       LISP::SUBTYPEP
       LISP::NSTRING-CAPITALIZE
       LISP::DECLARE
       LISP::AKCL
       LISP::FLOOR
       LISP::GBC
       LISP::GENSYM
       LISP::ARRAY-HAS-FILL-POINTER-P
       LISP::LOGIOR
       LISP::Y-OR-N-P
       LISP::CHAR-FONT
       LISP::PARSE-NAMESTRING
       LISP::ARRAY-RANK
       LISP::NINTH
       LISP::EVALHOOK
       LISP::WITH-INPUT-FROM-STRING
       LISP::INTEGER
       LISP::MAKE-SEQUENCE
       LISP::SET-EXCLUSIVE-OR
       LISP::CHAR<
       LISP::INLINE
       LISP::CDDADR
       LISP::REMOVE-IF-NOT
       LISP::TANH
       LISP::ATAN
       LISP::NOT
       LISP::STRING-CHAR-P
       LISP::LONG-SITE-NAME
       LISP::PATHNAME-VERSION
       LISP::MAPCAN
       LISP::REQUIRE
       LISP::RPLACA
       LISP::TAGBODY
       LISP::COPY-ALIST
       LISP::CADADR
       LISP::MAPCAR
       LISP::>
       LISP::FIND-PACKAGE
       LISP::FBOUNDP
       LISP::CLX-LITTLE-ENDIAN
       LISP::=
       LISP::DEFSETF
       LISP::ZEROP
       LISP::MC68020
       LISP::UNUSE-PACKAGE
       LISP::MOST-POSITIVE-SHORT-FLOAT
       LISP::MOST-POSITIVE-SINGLE-FLOAT
       LISP::MOST-POSITIVE-DOUBLE-FLOAT
       LISP::MOST-POSITIVE-LONG-FLOAT
       LISP::LOGICAL-PATHNAME
       LISP::APPLYHOOK
       LISP::<
       LISP::LOGCOUNT
       LISP::ENOUGH-NAMESTRING
       LISP::MULTIPLE-VALUE-LIST
       LISP::TWO-WAY-STREAM
       LISP::CDDR
       LISP::ASSOC
       LISP::REMF
       LISP::LDB
       LISP::MACROLET
       LISP::CDADR
       LISP::UNION
       LISP::FIND-ALL-SYMBOLS
       LISP::MAKE-PACKAGE
       LISP::&OPTIONAL
       LISP::THIRD
       LISP::LABELS
       LISP::BOOLE-C1
       LISP::FIND-IF-NOT
       LISP::LOAD
       LISP::DELETE-IF-NOT
       LISP::ACONS
       LISP::UNDEFINED-FUNCTION
       LISP::SIGNED-CHAR
       LISP::INT
       LISP::PACKAGEP
       LISP::ENCODE-UNIVERSAL-TIME
       LISP::FORMAT
       LISP::TENTH
       LISP::STRUCTURE-CLASS
       LISP::MEMBER-IF-NOT
       LISP::LEAST-NEGATIVE-SHORT-FLOAT
       LISP::LEAST-NEGATIVE-SINGLE-FLOAT
       LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
       LISP::LEAST-NEGATIVE-LONG-FLOAT
       LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
       LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
       LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
       LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT
       LISP::KCL
       LISP::BOOLE-1
       LISP::REDUCE
       LISP::SVREF
       LISP::NTH-VALUE
       LISP::FORCE-OUTPUT
       LISP::NSUBSTITUTE-IF-NOT
       LISP::CATCH
       LISP::STORAGE-CONDITION
       LISP::MERGE
       LISP::CASE
       LISP::CLEAR-INPUT
       LISP::REPLACE
       LISP::***
       LISP::GENERIC-FUNCTION
       LISP::GCL
       LISP::/
       LISP::BOOLE-SET
       LISP::SOFTWARE-VERSION
       LISP::APROPOS-LIST
       LISP::POSITION-IF-NOT
       LISP::READ-BYTE
       LISP::FLOAT-RADIX
       LISP::DECF
       LISP::PROG
       LISP::-
       LISP::MAPCON
       LISP::CADR
       LISP::EQUAL
       LISP::CAADR
       LISP::+
       LISP::PATHNAME-DEVICE
       LISP::MACRO-FUNCTION
       LISP::MAPLIST
       LISP::REVERSE
       LISP::FIND-SYMBOL
       LISP::*
       LISP::LOCALLY
       LISP::BIT-ANDC2
       LISP::COMMONP
       LISP::*FEATURES*
       LISP::DIVISION-BY-ZERO
       LISP::ARRAY
       LISP::DOUBLE
       LISP::DEFPARAMETER
       LISP::PATHNAME-DIRECTORY
       LISP::STRING-NOT-LESSP
       LISP::ELT
       LISP::NTH
       LISP::RETURN-FROM
       LISP::BIGNUM
       LISP::MAKE-SYMBOL
       LISP::FILL
       LISP::CHAR-CODE
       LISP::*PRINT-ESCAPE*
       LISP::*PRINT-BASE*
       LISP::*PRINT-CASE*
       LISP::FLOATING-POINT-INVALID-OPERATION
       LISP::NSUBST
       LISP::SIMPLE-VECTOR
       LISP::ARRAY-IN-BOUNDS-P
       LISP::READ-PRESERVING-WHITESPACE
       LISP::ATANH
       LISP::ATOM
       LISP::BIT-NAND
       LISP::VECTOR-POP
       LISP::MEMBER
       LISP::REMOVE
       LISP::CHAR<=
       LISP::PUSH
       LISP::PROGRAM-ERROR
       LISP::KYOTO
       LISP::CHAR-UPCASE
       LISP::*PRINT-PRETTY*
       LISP::MOST-POSITIVE-FIXNUM
       LISP::PATHNAME-HOST
       LISP::DOCUMENTATION
       LISP:://
       LISP::UNEXPORT
       LISP::PROBE-FILE
       LISP::STANDARD-CLASS
       LISP::GET-INTERNAL-REAL-TIME
       LISP::GET-INTERNAL-RUN-TIME
       LISP::NOTANY
       LISP::QUIT
       LISP::ROOM
       LISP::*APPLYHOOK*
       LISP::COS
       LISP::CHAR-DOWNCASE
       LISP::CONSTANTLY
       LISP::RATIONALIZE
       LISP::LISP-IMPLEMENTATION-VERSION
       LISP::CONSTANTP
       LISP::HASH-TABLE-COUNT
       LISP::STREAMP
       LISP::*BREAK-ENABLE*
       LISP::1-
       LISP::BIT-XOR
       LISP::STRING-STREAM
       LISP::GET-PROPERTIES
       LISP::COUNT-IF-NOT
       LISP::BIT
       LISP::ASH
       LISP::NSUBLIS
       LISP::FOURTH
       LISP::STRING<=
       LISP::STRING>=
       LISP::STRING/=
       LISP::SLEEP
       LISP::LAMBDA-BLOCK-CLOSURE
       LISP::HELP
       LISP::TREE-EQUAL
       LISP::SET
       LISP::INT-CHAR
       LISP::STRING-GREATERP
       LISP::SINGLE-FLOAT-EPSILON
       LISP::SINGLE-FLOAT-NEGATIVE-EPSILON
       LISP::SPECIAL-FORM-P
       LISP::COMPLEMENT
       LISP::WRITE
       LISP::NCONC
       LISP::DECODE-UNIVERSAL-TIME
       LISP::BUILT-IN-CLASS
       LISP::*RANDOM-STATE*
       LISP::BOOLE-ORC1
       LISP::BOOLE-ORC2
       LISP::FILE-NAMESTRING
       LISP::VOID
       LISP::BIT-ORC2
       LISP::1+
       LISP::PROG2
       LISP::*READ-SUPPRESS*
       LISP::DOLIST
       LISP::SIMPLE-BASE-STRING
       LISP::LET
       LISP::CHAR-NOT-GREATERP
       LISP::PATHNAMEP
       LISP::READ
       LISP::RANDOM-STATE-P
       LISP::CDDAR
       LISP::BY
       LISP::SFUN
       LISP::REMOVE-IF
       LISP::&ALLOW-OTHER-KEYS
       LISP::FROUND
       LISP::CHAR-EQUAL
       LISP::MAKE-DISPATCH-MACRO-CHARACTER
       LISP::EIGHTH
       LISP::OPTIMIZE
       LISP::++
       LISP::DO*
       LISP::SIMPLE-TYPE-ERROR
       LISP::ASIN
       LISP::SINGLE-FLOAT
       LISP::CCLOSURE
       LISP::REAL
       LISP::CHARACTER
       LISP::CHARACTERP
       LISP::GET
       LISP::OBJECT
       LISP::REALP
       LISP::FCEILING
       LISP::COPY-SYMBOL
       LISP::CHAR
       LISP::STANDARD-CHAR-P
       LISP::*DEBUG-IO*
       LISP::FIXNUM
       LISP::COMPILED-FUNCTION-P
       LISP::COUNT-IF
       LISP::**
       LISP::METHOD
       LISP::WITH-OPEN-FILE
       LISP::PACKAGE
       LISP::TRUNCATE_USE_C
       LISP::IGNORE
       LISP::IDENTITY
       LISP::CTYPECASE
       LISP::ETYPECASE
       LISP::PROGV
       LISP::NSUBSTITUTE-IF
       LISP::BOOLE-NOR))

;;; Definitions for package SERROR of type SHADOW
(LISP::IN-PACKAGE "SERROR")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT
    '(LISP::EXP LISP::DEFVAR LISP::DISASSEMBLE LISP::DELETE-IF
         LISP::UNSIGNED-SHORT LISP::GFUN LISP::NSUBST-IF-NOT LISP::CIS
         LISP::LOGAND LISP::BIT-EQV LISP::UNIX LISP::RANDOM
         LISP::COPY-LIST LISP::KEYWORDP LISP::CADAR
         LISP::MERGE-PATHNAMES LISP::BOOLE-C2 LISP::BIT-NOT LISP::CFUN
         LISP::STANDARD-OBJECT LISP::STRINGP LISP::METHOD-COMBINATION
         LISP::NSET-EXCLUSIVE-OR LISP::CLOSE LISP::INTEGER-DECODE-FLOAT
         LISP::CHAR-NOT-EQUAL LISP::COSH LISP::NTHCDR
         LISP::GET-UNIVERSAL-TIME LISP::YES-OR-NO-P LISP::READ-LINE
         LISP::LET* LISP::PATHNAME-TYPE LISP::FLOAT-PRECISION
         LISP::PROG* LISP::SYMBOL-NAME LISP::LOG LISP::OR
         LISP::PACKAGE-SHADOWING-SYMBOLS LISP::BREAK
         LISP::STRUCTURE-OBJECT LISP::ROTATEF LISP::SQRT LISP::CONS
         LISP::NSUBST-IF LISP::UNWIND-PROTECT LISP::CONSP
         SLOOP::DEF-LOOP-MACRO LISP::FLOAT-SIGN LISP::*EVALHOOK*
         LISP::CHAR-BIT LISP::SOME LISP::MAPC LISP::SETF LISP::CEILING
         LISP::&BODY LISP::CDAR LISP::MAKE-LIST LISP::MAKE-HASH-TABLE
         LISP::STRING-UPCASE LISP::STRING-DOWNCASE LISP::STYLE-WARNING
         LISP::ASINH LISP::NRECONC LISP::NSTRING-DOWNCASE LISP::SECOND
         LISP::RATIONALP LISP::SET-DISPATCH-MACRO-CHARACTER
         LISP::GET-DISPATCH-MACRO-CHARACTER LISP::CHECK-TYPE
         LISP::MAKE-STRING-INPUT-STREAM LISP::MAKE-STRING-OUTPUT-STREAM
         LISP::*BREAK-ON-WARNINGS* LISP::BYE LISP::SAFETY
         LISP::*READ-DEFAULT-FLOAT-FORMAT* LISP::*LOAD-VERBOSE*
         LISP::OTHERWISE LISP::NBUTLAST LISP::SORT LISP::WARNING
         LISP::DEFLA LISP::PROGN LISP::PUSHNEW LISP::SYSTEM LISP::CHAR=
         LISP::SIGNED-SHORT LISP::MAKE-ECHO-STREAM LISP::BIT-AND
         LISP::EXPORT LISP::EQ LISP::SOFTWARE-TYPE LISP::LOGTEST
         LISP::LIST-ALL-PACKAGES LISP::DEFTYPE LISP::GETF
         LISP::ROW-MAJOR-AREF LISP::TYPECASE LISP::CHAR-CONTROL-BIT
         LISP::HASH-TABLE-TEST LISP::USER-HOMEDIR-PATHNAME
         LISP::SYMBOL-PACKAGE LISP::BOOLEAN LISP::HOST-NAMESTRING
         LISP::IN-PACKAGE LISP::CAAR LISP::INTERN LISP::CONDITION
         LISP::IEEE-FLOATING-POINT LISP::LOGNOT LISP::SUBST-IF-NOT
         LISP::COPY-READTABLE LISP::REVAPPEND LISP::SYMBOL
         LISP::BIT-VECTOR LISP::SEARCH LISP::STREAM-ELEMENT-TYPE
         LISP::POP LISP::GO LISP::LIST LISP::SET-MACRO-CHARACTER
         LISP::GET-MACRO-CHARACTER LISP::PARSE-ERROR LISP::VALUES
         LISP::DESTRUCTURING-BIND LISP::RANDOM-STATE LISP::LISTP
         LISP::CHAR/= LISP::REMPROP LISP::DO LISP::HELP* LISP::ABS
         LISP::&KEY LISP::VECTOR-PUSH-EXTEND LISP::PACKAGE-NICKNAMES
         LISP::MULTIPLE-VALUE-PROG1 SLOOP::LOOP-RETURN
         LISP::END-OF-FILE LISP::*DEFAULT-PATHNAME-DEFAULTS* LISP::EXPT
         LISP::READER-ERROR LISP::REMHASH LISP::BLOCK
         LISP::PACKAGE-ERROR LISP::LAMBDA-CLOSURE LISP::PARSE-INTEGER
         LISP::TIME LISP::COERCE LISP::FIND-IF LISP::UNREAD-CHAR
         LISP::DOUBLE-FLOAT-EPSILON LISP::DOUBLE-FLOAT-NEGATIVE-EPSILON
         LISP::BOOLE-IOR LISP::ASSERT LISP::ADJUSTABLE-ARRAY-P
         LISP::COPY-TREE LISP::CLEAR-OUTPUT LISP::CODE-CHAR
         LISP::STRING-CAPITALIZE LISP::/// LISP::WITH-OPEN-STREAM
         LISP::REST LISP::ACOS LISP::MACHINE-TYPE LISP::DENOMINATOR
         LISP::TRACE LISP::FLOATING-POINT-INEXACT LISP::*READ-BASE*
         LISP::CDR LISP::STRING-EQUAL LISP::GMP LISP::DELETE-FILE
         LISP::SPECIFIC-ERROR LISP::FIRST LISP::ALPHANUMERICP
         LISP::WITH-HASH-TABLE-ITERATOR LISP::SCALE-FLOAT
         LISP::CONCATENATED-STREAM LISP::CONTROL-ERROR
         LISP::FINISH-OUTPUT LISP::LAMBDA-PARAMETERS-LIMIT LISP::PRINC
         LISP::ADJOIN LISP::PI LISP::DOUBLE-FLOAT LISP::READTABLE
         LISP::READTABLEP LISP::ARRAY-RANK-LIMIT LISP::RENAME-FILE
         LISP::READ-CHAR LISP::PEEK-CHAR LISP::REMOVE-DUPLICATES
         LISP::BYTE LISP::*MODULES* LISP::GET-OUTPUT-STREAM-STRING
         LISP::MULTIPLE-VALUE-BIND LISP::VECTORP LISP::RASSOC-IF-NOT
         LISP::UNINTERN SLOOP::LOOP-FINISH
         LISP::SPECIFIC-CORRECTABLE-ERROR LISP::CDADAR LISP::FUNCTION
         LISP::LOGORC2 LISP::*PACKAGE* LISP::STRING-NOT-GREATERP
         LISP::INTERSECTION LISP::SPACE LISP::SEVENTH LISP::BASE-CHAR
         LISP::MAKE-CHAR LISP::NAME-CHAR LISP::SBIT LISP::CAADAR
         LISP::TAILP LISP::*TERMINAL-IO* LISP::STREAM-ERROR
         LISP::BOOLE-ANDC1 LISP::DO-ALL-SYMBOLS LISP::MAKUNBOUND
         LISP::PROVIDE LISP::THROW LISP::LENGTH LISP::CDAAR LISP::&AUX
         LISP::ARRAY-DISPLACEMENT LISP::PAIRLIS LISP::*PRINT-GENSYM*
         LISP::COMPILE-FILE-PATHNAME LISP::CAR LISP::FTRUNCATE
         LISP::DELETE-DUPLICATES LISP::NREVERSE LISP::APROPOS
         LISP::STRING-RIGHT-TRIM LISP::STEP LISP::BIT-NOR
         LISP::ARRAY-TOTAL-SIZE LISP::ECHO-STREAM
         LISP::DEFINE-SETF-METHOD LISP::FMAKUNBOUND LISP::SUBST-IF
         LISP::GET-DECODED-TIME LISP::LONG-FLOAT LISP::SIMPLE-WARNING
         LISP::CHAR-HYPER-BIT LISP::TAG LISP::RATIO LISP::EVENP
         LISP::QUOTE LISP::SIMPLE-STRING LISP::NSUBSTITUTE LISP::LAST
         LISP::NSET-DIFFERENCE LISP::COUNT LISP::CDAAAR
         LISP::SET-DIFFERENCE SLOOP::DEF-LOOP-FOR LISP::PPRINT
         LISP::SHORT-FLOAT-EPSILON LISP::SHORT-FLOAT-NEGATIVE-EPSILON
         LISP::SET-CHAR-BIT LISP::ACOSH LISP::LISTEN LISP::GENTEMP
         LISP::ERROR LISP::BSD LISP::ADJUST-ARRAY LISP::CLINES LISP::IF
         LISP::CAAAAR LISP::SET-SYNTAX-FROM-CHAR LISP::STRING-TRIM
         LISP::DIGIT-CHAR LISP::BOOLE-AND LISP::STRING> LISP::CAAAR
         LISP::GETHASH LISP::FILL-POINTER SLOOP::DEF-LOOP-MAP
         LISP::CDADDR LISP::DIRECTORY-NAMESTRING LISP::DEFUN
         LISP::TRUNCATE LISP::DEFENTRY LISP::ALPHA-CHAR-P
         LISP::SYMBOL-FUNCTION LISP::SUBSTITUTE-IF-NOT LISP::LDB-TEST
         LISP::FLOAT-DIGITS LISP::BIT-VECTOR-P LISP::CAADDR
         LISP::VARIABLE LISP::NUMERATOR LISP::NOTINLINE
         LISP::CHAR-LESSP LISP::WARN LISP::CHAR-NOT-LESSP
         LISP::ARRAY-DIMENSION-LIMIT LISP::MOD LISP::SXHASH
         LISP::PACKAGE-USE-LIST LISP::PACKAGE-USED-BY-LIST
         LISP::MACHINE-INSTANCE LISP::ARRAYP LISP::*GENSYM-COUNTER*
         LISP::UPPER-CASE-P LISP::*PRINT-CIRCLE* LISP::FTYPE LISP::THE
         SLOOP::LOCAL-FINISH LISP::COMPILER-LET LISP::WRITE-TO-STRING
         LISP::ARRAY-TOTAL-SIZE-LIMIT LISP::SEQUENCE LISP::FILE-AUTHOR
         LISP::MULTIPLE-VALUE-CALL LISP::*MACROEXPAND-HOOK* LISP::PLUSP
         LISP::INTERNAL-TIME-UNITS-PER-SECOND LISP::LIST*
         LISP::*PRINT-ARRAY* LISP::FILE-WRITE-DATE LISP::LAMBDA
         LISP::ED LISP::OPEN LISP::AREF LISP::RASSOC-IF LISP::LOGORC1
         LISP::PROCLAIM LISP::CHAR-SUPER-BIT LISP::APPEND
         LISP::CONCATENATE LISP::WRITE-STRING LISP::MISMATCH
         LISP::SIMPLE-STRING-P LISP::PRINT LISP::MULTIPLE-VALUES-LIMIT
         LISP::PRIN1-TO-STRING LISP::PRINC-TO-STRING
         LISP::SIMPLE-CONDITION LISP::TERPRI LISP::CDAADR
         LISP::FLOATING-POINT-OVERFLOW LISP::FLOATING-POINT-UNDERFLOW
         LISP::CALL-ARGUMENTS-LIMIT LISP::COPY-SEQ LISP::FUNCALL
         LISP::CLRHASH LISP::SHORT-SITE-NAME LISP::LONG-FLOAT-EPSILON
         LISP::LONG-FLOAT-NEGATIVE-EPSILON LISP::ASSOC-IF-NOT
         LISP::CAAADR LISP::STRING-CHAR LISP::LOGANDC1
         LISP::WITH-PACKAGE-ITERATOR LISP::NUMBERP LISP::COMPLEX
         LISP::AND LISP::EVAL-WHEN LISP::LOOP LISP::READ-FROM-STRING
         LISP::*STANDARD-OUTPUT* LISP::CHAR-NAME LISP::COMPILE-FILE
         LISP::FLOAT LISP::*ERROR-OUTPUT* LISP::TYPE-ERROR
         LISP::COMPILATION-SPEED LISP::LOGXOR LISP::LIST-LENGTH
         LISP::DRIBBLE LISP::EXTENDED-CHAR LISP::MAP
         LISP::ARRAY-ELEMENT-TYPE LISP::ROUND LISP::STRING-LEFT-TRIM
         LISP::DECLAIM LISP::SAVE LISP::SIN LISP::*PRINT-LENGTH*
         LISP::DECLARATION LISP::DECODE-FLOAT LISP::PATHNAME-NAME
         LISP::STRING= LISP::PHASE LISP::SPICE LISP::RASSOC
         LISP::LISP-IMPLEMENTATION-TYPE LISP::UNTRACE
         LISP::PRINT-NOT-READABLE LISP::ARRAY-ROW-MAJOR-INDEX
         LISP::SUBSTITUTE-IF LISP::BOOLE LISP::TRUENAME
         LISP::DEFCONSTANT LISP::VALUES-LIST LISP::*LINK-ARRAY*
         LISP::&REST LISP::MAKE-RANDOM-STATE LISP::CHAR>
         LISP::BYTE-SIZE LISP::MIN LISP::CDDDR LISP::BIT-IOR
         LISP::VECTOR LISP::UNSIGNED-BYTE LISP::SERIOUS-CONDITION
         LISP::SYMBOL-PLIST LISP::*READTABLE* LISP::SIMPLE-BIT-VECTOR-P
         LISP::LEAST-POSITIVE-SHORT-FLOAT
         LISP::LEAST-POSITIVE-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-LONG-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-POSITIVE-NORMALIZED-LONG-FLOAT LISP::LOWER-CASE-P
         SYSTEM::ALLOCATE LISP::EQUALP LISP::SUBSTITUTE LISP::SUBSEQ
         LISP::MINUSP LISP::MOST-NEGATIVE-SHORT-FLOAT
         LISP::MOST-NEGATIVE-SINGLE-FLOAT
         LISP::MOST-NEGATIVE-DOUBLE-FLOAT
         LISP::MOST-NEGATIVE-LONG-FLOAT LISP::FILE-LENGTH
         LISP::FILE-ERROR LISP::HASH-TABLE LISP::SPEED LISP::COMMON
         LISP::*PRINT-RADIX* LISP::POSITIVE-FIXNUM
         LISP::UNBOUND-VARIABLE LISP::RATIONAL
         LISP::UPGRADED-ARRAY-ELEMENT-TYPE LISP::FRESH-LINE LISP::WHEN
         LISP::COMPILE LISP::FLET LISP::SPECIAL LISP::CLASS
         LISP::CELL-ERROR LISP::RPLACD LISP::TYPE-OF
         LISP::SPECIAL-OPERATOR-P LISP::DESCRIBE LISP::POSITION
         LISP::STABLE-SORT LISP::BOTH-CASE-P LISP::SYMBOLP
         LISP::*PRINT-READABLY* LISP::SHADOW LISP::STREAM
         LISP::CHAR-BITS LISP::MAKE-ARRAY LISP::FUNCTIONP LISP::&WHOLE
         LISP::SUBST LISP::SCHAR LISP::ARRAY-DIMENSION LISP::COND
         LISP::DO-EXTERNAL-SYMBOLS LISP::CHAR-CODE-LIMIT
         LISP::CHAR-FONT-LIMIT LISP::SATISFIES LISP::MASK-FIELD
         LISP::ARITHMETIC-ERROR LISP::CADDR LISP::LAMBDA-LIST-KEYWORDS
         LISP::MACRO LISP::STRING-NOT-EQUAL LISP::STRING-LESSP
         LISP::USE-PACKAGE LISP::MULTIPLE-VALUE-SETQ LISP::>=
         LISP::LOGEQV LISP::*EVAL-WHEN-COMPILE* LISP::HASH-TABLE-P
         LISP::GRAPHIC-CHAR-P LISP::EQL LISP::MAPHASH
         LISP::NINTERSECTION LISP::<= LISP::NAMESTRING
         LISP::MAKE-CONCATENATED-STREAM LISP::SHORT-FLOAT
         LISP::FILE-STREAM LISP::WRITE-LINE LISP::VECTOR-PUSH
         LISP::ENDP LISP::DIRECTORY LISP::TYPE LISP::ASSOC-IF LISP::DPB
         LISP::TYPEP LISP::FIFTH LISP::LOGNAND LISP::SIGNED-BYTE
         LISP::EVERY LISP::SUBLIS LISP::NULL LISP::FLOATP LISP::STRING<
         LISP::*TRACE-OUTPUT* LISP::WRITE-CHAR LISP::SGC
         LISP::STANDARD-GENERIC-FUNCTION LISP::MAPL LISP::PROG1
         LISP::COMPLEXP LISP::PROCLAMATION LISP::INSPECT
         LISP::MACROEXPAND-1 LISP::BIT-ANDC1 LISP::SETQ LISP::CHAR>=
         LISP::REALPART LISP::LDIFF LISP::SINH LISP::BROADCAST-STREAM
         LISP::BASE-STRING LISP::MAKE-STRING LISP::CDDDAR
         LISP::INTEGER-LENGTH LISP::OUTPUT-STREAM-P LISP::NUNION
         LISP::/= LISP::PACKAGE-NAME LISP::ECASE LISP::PATHNAME
         LISP::APPLY LISP::CHAR-INT LISP::TAN
         LISP::MOST-NEGATIVE-FIXNUM LISP::MAKE-SYNONYM-STREAM
         LISP::MACROEXPAND LISP::CADDAR LISP::ISQRT LISP::CCASE
         LISP::GCD LISP::KEYWORD LISP::UNLESS LISP::MAP-INTO
         LISP::SYNONYM-STREAM LISP::SUBSETP LISP::POSITION-IF
         LISP::INCF LISP::SHIFTF LISP::BOOLE-XOR LISP::REM LISP::LOGNOR
         LISP::FIND LISP::MAX LISP::SIMPLE-VECTOR-P LISP::IMPORT
         LISP::MACHINE-VERSION LISP::SHADOWING-IMPORT LISP::BOOLE-EQV
         LISP::CONJUGATE LISP::READ-CHAR-NO-HANG LISP::WRITE-BYTE
         LISP::WITH-OUTPUT-TO-STRING LISP::BYTE-POSITION
         LISP::STANDARD-CHAR LISP::STRING LISP::MEMBER-IF
         LISP::CHAR-BITS-LIMIT LISP::NSTRING-UPCASE LISP::DEFMACRO
         LISP::BUTLAST LISP::CDDAAR LISP::IMAGPART LISP::LOGANDC2
         LISP::HASH-TABLE-SIZE LISP::FFLOOR LISP::*PRINT-LEVEL*
         LISP::DEFSTRUCT LISP::DELETE-PACKAGE LISP::BOOLE-CLR
         LISP::DO-SYMBOLS LISP::INTEGERP LISP::NUMBER LISP::CADAAR
         LISP::NIL LISP::T LISP::DELETE LISP::DEFCFUN
         LISP::DEFINE-MODIFY-MACRO LISP::COMPILED-FUNCTION
         LISP::NOTEVERY LISP::BOOLE-2 LISP::STRUCTURE
         LISP::UNBOUND-SLOT LISP::RENAME-PACKAGE LISP::SIGNUM
         LISP::CDDDDR LISP::GET-SETF-METHOD-MULTIPLE-VALUE
         LISP::FILE-POSITION LISP::LOGBITP LISP::LAMBDA-BLOCK
         LISP::STANDARD-METHOD LISP::UNSIGNED-CHAR LISP::PSETQ
         LISP::EVAL LISP::CERROR LISP::CHAR-GREATERP
         LISP::GET-SETF-METHOD LISP::SYMBOL-VALUE LISP::+++ LISP::LCM
         LISP::BOOLE-NAND LISP::SIMPLE-ARRAY LISP::CADDDR
         LISP::SIMPLE-BIT-VECTOR LISP::CHAR-META-BIT LISP::PRIN1
         LISP::BIT-ORC1 LISP::PSETF LISP::RETURN LISP::MAKE-PATHNAME
         LISP::DOTIMES LISP::DEPOSIT-FIELD LISP::*QUERY-IO*
         LISP::&ENVIRONMENT LISP::ARRAY-DIMENSIONS LISP::BSD386
         LISP::MAKE-BROADCAST-STREAM LISP::BOOLE-ANDC2
         LISP::MAKE-TWO-WAY-STREAM LISP::INPUT-STREAM-P
         LISP::DIGIT-CHAR-P LISP::*STANDARD-INPUT* LISP::BOUNDP
         LISP::ODDP LISP::READ-DELIMITED-LIST LISP::SIXTH
         LISP::SUBTYPEP LISP::NSTRING-CAPITALIZE LISP::DECLARE
         LISP::AKCL LISP::FLOOR LISP::GBC LISP::GENSYM
         LISP::ARRAY-HAS-FILL-POINTER-P LISP::LOGIOR LISP::Y-OR-N-P
         LISP::CHAR-FONT LISP::PARSE-NAMESTRING LISP::ARRAY-RANK
         LISP::NINTH LISP::EVALHOOK LISP::WITH-INPUT-FROM-STRING
         LISP::INTEGER LISP::MAKE-SEQUENCE LISP::SET-EXCLUSIVE-OR
         LISP::CHAR< LISP::INLINE LISP::CDDADR LISP::REMOVE-IF-NOT
         LISP::TANH LISP::ATAN LISP::NOT LISP::STRING-CHAR-P
         LISP::LONG-SITE-NAME LISP::PATHNAME-VERSION LISP::MAPCAN
         LISP::REQUIRE LISP::RPLACA LISP::TAGBODY LISP::COPY-ALIST
         LISP::CADADR LISP::MAPCAR LISP::> LISP::FIND-PACKAGE
         LISP::FBOUNDP LISP::CLX-LITTLE-ENDIAN LISP::= LISP::DEFSETF
         LISP::ZEROP LISP::MC68020 LISP::UNUSE-PACKAGE
         LISP::MOST-POSITIVE-SHORT-FLOAT
         LISP::MOST-POSITIVE-SINGLE-FLOAT
         LISP::MOST-POSITIVE-DOUBLE-FLOAT
         LISP::MOST-POSITIVE-LONG-FLOAT LISP::LOGICAL-PATHNAME
         LISP::APPLYHOOK LISP::< LISP::LOGCOUNT LISP::ENOUGH-NAMESTRING
         LISP::MULTIPLE-VALUE-LIST LISP::TWO-WAY-STREAM LISP::CDDR
         LISP::ASSOC LISP::REMF LISP::LDB LISP::MACROLET LISP::CDADR
         LISP::UNION LISP::FIND-ALL-SYMBOLS LISP::MAKE-PACKAGE
         LISP::&OPTIONAL LISP::THIRD LISP::LABELS LISP::BOOLE-C1
         LISP::FIND-IF-NOT LISP::LOAD LISP::DELETE-IF-NOT LISP::ACONS
         LISP::UNDEFINED-FUNCTION LISP::SIGNED-CHAR LISP::INT
         LISP::PACKAGEP LISP::ENCODE-UNIVERSAL-TIME LISP::FORMAT
         LISP::TENTH LISP::STRUCTURE-CLASS LISP::MEMBER-IF-NOT
         LISP::LEAST-NEGATIVE-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-LONG-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT
         LISP::LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT LISP::KCL
         LISP::BOOLE-1 LISP::REDUCE LISP::SVREF LISP::NTH-VALUE
         LISP::FORCE-OUTPUT LISP::NSUBSTITUTE-IF-NOT LISP::CATCH
         LISP::STORAGE-CONDITION LISP::MERGE LISP::CASE
         LISP::CLEAR-INPUT LISP::REPLACE LISP::***
         LISP::GENERIC-FUNCTION LISP::GCL LISP::/ LISP::BOOLE-SET
         LISP::SOFTWARE-VERSION LISP::APROPOS-LIST
         LISP::POSITION-IF-NOT LISP::READ-BYTE LISP::FLOAT-RADIX
         LISP::DECF LISP::PROG LISP::- LISP::MAPCON LISP::CADR
         LISP::EQUAL LISP::CAADR LISP::+ LISP::PATHNAME-DEVICE
         LISP::MACRO-FUNCTION LISP::MAPLIST LISP::REVERSE
         LISP::FIND-SYMBOL LISP::* LISP::LOCALLY LISP::BIT-ANDC2
         LISP::COMMONP LISP::*FEATURES* LISP::DIVISION-BY-ZERO
         LISP::ARRAY LISP::DOUBLE LISP::DEFPARAMETER
         LISP::PATHNAME-DIRECTORY LISP::STRING-NOT-LESSP LISP::ELT
         LISP::NTH LISP::RETURN-FROM LISP::BIGNUM LISP::MAKE-SYMBOL
         LISP::FILL LISP::CHAR-CODE LISP::*PRINT-ESCAPE*
         LISP::*PRINT-BASE* LISP::*PRINT-CASE*
         LISP::FLOATING-POINT-INVALID-OPERATION LISP::NSUBST
         LISP::SIMPLE-VECTOR LISP::ARRAY-IN-BOUNDS-P
         LISP::READ-PRESERVING-WHITESPACE LISP::ATANH LISP::ATOM
         LISP::BIT-NAND LISP::VECTOR-POP LISP::MEMBER LISP::REMOVE
         LISP::CHAR<= LISP::PUSH LISP::PROGRAM-ERROR LISP::KYOTO
         LISP::CHAR-UPCASE LISP::*PRINT-PRETTY*
         LISP::MOST-POSITIVE-FIXNUM LISP::PATHNAME-HOST
         LISP::DOCUMENTATION LISP::// LISP::UNEXPORT LISP::PROBE-FILE
         LISP::STANDARD-CLASS LISP::GET-INTERNAL-REAL-TIME
         LISP::GET-INTERNAL-RUN-TIME LISP::NOTANY LISP::QUIT LISP::ROOM
         LISP::*APPLYHOOK* LISP::COS LISP::CHAR-DOWNCASE
         LISP::CONSTANTLY LISP::RATIONALIZE
         LISP::LISP-IMPLEMENTATION-VERSION LISP::CONSTANTP
         LISP::HASH-TABLE-COUNT LISP::STREAMP LISP::*BREAK-ENABLE*
         LISP::1- LISP::BIT-XOR LISP::STRING-STREAM
         LISP::GET-PROPERTIES LISP::COUNT-IF-NOT LISP::BIT LISP::ASH
         LISP::NSUBLIS LISP::FOURTH LISP::STRING<= LISP::STRING>=
         LISP::STRING/= LISP::SLEEP LISP::LAMBDA-BLOCK-CLOSURE
         LISP::HELP LISP::TREE-EQUAL LISP::SET LISP::INT-CHAR
         LISP::STRING-GREATERP LISP::SINGLE-FLOAT-EPSILON
         LISP::SINGLE-FLOAT-NEGATIVE-EPSILON LISP::SPECIAL-FORM-P
         LISP::COMPLEMENT LISP::WRITE LISP::NCONC
         LISP::DECODE-UNIVERSAL-TIME LISP::BUILT-IN-CLASS
         LISP::*RANDOM-STATE* LISP::BOOLE-ORC1 LISP::BOOLE-ORC2
         LISP::FILE-NAMESTRING LISP::VOID LISP::BIT-ORC2 LISP::1+
         LISP::PROG2 SLOOP::SLOOP LISP::*READ-SUPPRESS* LISP::DOLIST
         LISP::SIMPLE-BASE-STRING LISP::LET LISP::CHAR-NOT-GREATERP
         LISP::PATHNAMEP LISP::READ LISP::RANDOM-STATE-P LISP::CDDAR
         LISP::BY LISP::SFUN LISP::REMOVE-IF LISP::&ALLOW-OTHER-KEYS
         LISP::FROUND LISP::CHAR-EQUAL
         LISP::MAKE-DISPATCH-MACRO-CHARACTER LISP::EIGHTH
         LISP::OPTIMIZE LISP::++ LISP::DO* LISP::SIMPLE-TYPE-ERROR
         LISP::ASIN LISP::SINGLE-FLOAT LISP::CCLOSURE LISP::REAL
         LISP::CHARACTER LISP::CHARACTERP LISP::GET LISP::OBJECT
         LISP::REALP LISP::FCEILING LISP::COPY-SYMBOL LISP::CHAR
         LISP::STANDARD-CHAR-P LISP::*DEBUG-IO* LISP::FIXNUM
         LISP::COMPILED-FUNCTION-P LISP::COUNT-IF LISP::** LISP::METHOD
         LISP::WITH-OPEN-FILE LISP::PACKAGE LISP::TRUNCATE_USE_C
         LISP::IGNORE LISP::IDENTITY LISP::CTYPECASE LISP::ETYPECASE
         LISP::PROGV LISP::NSUBSTITUTE-IF LISP::BOOLE-NOR
         SLOOP::DEF-LOOP-COLLECT))

;;; Definitions for package COMMON-LISP of type SHADOW
(LISP::IN-PACKAGE "COMMON-LISP")
(LISP::SHADOW 'LISP::NIL)
(LISP::SHADOWING-IMPORT 'LISP::NIL)
(LISP::IMPORT '(LISP::NIL LISP::T))

(lisp::in-package "SI")
(export '(%structure-name
          %compiled-function-name
          %set-compiled-function-name))
(in-package "PCL")

(in-package :pcl)
(defvar *the-pcl-package* (find-package :pcl))
(defun load-truename (&optional (errorp nil))
  (flet () si:*load-pathname* nil))

;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: ("CONDITIONS" :USE "LISP" :SHADOW ("BREAK" "ERROR" "CERROR" "WARN" "CHECK-TYPE" "ASSERT" "ETYPECASE" "CTYPECASE" "ECASE" "CCASE")); Base: 10 -*-
; From arisia.xerox.com:/cl/conditions/cond18.lisp
;;;
;;; CONDITIONS
;;;
;;; This is a sample implementation. It is not in any way intended as the definition
;;; of any aspect of the condition system. It is simply an existence proof that the
;;; condition system can be implemented.
;;;
;;; While this written to be "portable", this is not a portable condition system
;;; in that loading this file will not redefine your condition system. Loading this
;;; file will define a bunch of functions which work like a condition system. Redefining
;;; existing condition systems is beyond the goal of this implementation attempt.

(MAKE-PACKAGE "CONDITIONS" :USE '("LISP" #+lucid "LUCID-COMMON-LISP"))
(IN-PACKAGE "CONDITIONS" :USE '("LISP" #+lucid "LUCID-COMMON-LISP"))

#-(or lucid excl genera cmu )
(SHADOW '(BREAK ERROR CERROR WARN CHECK-TYPE ASSERT ETYPECASE
	  CTYPECASE ECASE CCASE))

#+gcl
(EXPORT '(;; Shadowed symbols
	    BREAK ERROR CERROR WARN CHECK-TYPE ASSERT ETYPECASE
	    CTYPECASE ECASE CCASE))

(EXPORT '(;; New symbols
	  *BREAK-ON-SIGNALS* *DEBUGGER-HOOK* SIGNAL
	  HANDLER-CASE HANDLER-BIND IGNORE-ERRORS DEFINE-CONDITION MAKE-CONDITION
	  WITH-SIMPLE-RESTART RESTART-CASE RESTART-BIND RESTART-NAME
	  RESTART-NAME FIND-RESTART COMPUTE-RESTARTS INVOKE-RESTART
	  INVOKE-RESTART-INTERACTIVELY ABORT CONTINUE MUFFLE-WARNING
	  STORE-VALUE USE-VALUE INVOKE-DEBUGGER RESTART CONDITION
	  WARNING SERIOUS-CONDITION SIMPLE-CONDITION SIMPLE-WARNING SIMPLE-ERROR
	  SIMPLE-CONDITION-FORMAT-STRING SIMPLE-CONDITION-FORMAT-ARGUMENTS
	  STORAGE-CONDITION STACK-OVERFLOW STORAGE-EXHAUSTED TYPE-ERROR
	  TYPE-ERROR-DATUM TYPE-ERROR-EXPECTED-TYPE SIMPLE-TYPE-ERROR
	  PROGRAM-ERROR CONTROL-ERROR STREAM-ERROR STREAM-ERROR-STREAM
	  END-OF-FILE FILE-ERROR FILE-ERROR-PATHNAME CELL-ERROR
	  UNBOUND-VARIABLE UNDEFINED-FUNCTION ARITHMETIC-ERROR
	  ARITHMETIC-ERROR-OPERATION ARITHMETIC-ERROR-OPERANDS
	  PACKAGE-ERROR PACKAGE-ERROR-PACKAGE
	  DIVISION-BY-ZERO FLOATING-POINT-OVERFLOW FLOATING-POINT-UNDERFLOW))

(DEFVAR *THIS-PACKAGE* (FIND-PACKAGE "CONDITIONS"))



(rename-package 'user 'common-lisp-user '(cl-user user))

(in-package "SYSTEM")

(defvar *command-args* nil)
 ;; if ANY header or license information is printed by the
 ;; program, then the following License and Enhancement notice
 ;; must be printed (see License).
(progn 

 (system:init-system) 
 (gbc t)

 (in-package "USER")

 (or lisp::*link-array*
     (setq lisp::*link-array*
	   (make-array (ash 1 11)  :element-type 'string-char :fill-pointer 0)))
 (si::use-fast-links t)

 (let* ((x (append (pathname-directory si::*system-directory*) (list :parent)))
	(lsp (append x (list "lsp")))
	(cmpnew (append x (list "cmpnew")))
	(h (append x (list "h")))
	(pcl (append x (list "pcl")))
	(clcs (append x (list "clcs")))
	(gtk (append x (list "gcl-tk"))))
   (dolist (d (list lsp cmpnew pcl clcs))
       (load (make-pathname :name "sys-proclaim" :type "lisp" :directory d)))
   (load (make-pathname :name "tk-package" :type "lsp" :directory gtk))
   (load (make-pathname :name "gcl_cmpmain" :type "lsp" :directory cmpnew))
   (load (make-pathname :name "gcl_lfun_list" :type "lsp" :directory cmpnew))
   (load (make-pathname :name "gcl_cmpopt" :type "lsp" :directory cmpnew))
   (load (make-pathname :name "gcl_auto_new" :type "lsp" :directory lsp))

   (gbc t)

   (setq compiler::*cmpinclude* "\"cmpinclude.h\"") 
 
   (when compiler::*cmpinclude-string*
     (with-open-file (st (make-pathname :directory h :name "cmpinclude" :type "h"))
		     (let
			 ((tem (make-array (file-length st) :element-type 'standard-char
					   :static t)))
		       (if (si::fread tem 0 (length tem) st)
			   (setq compiler::*cmpinclude-string* tem))))))
 
 (setf (symbol-function 'si:clear-compiler-properties)
       (symbol-function 'compiler::compiler-clear-compiler-properties))
 (setq system::*old-top-level* (symbol-function 'system:top-level))
 
 (defvar si::*lib-directory* (namestring (make-pathname :directory (list :parent))))
 
 (defun system::gcl-top-level (&aux tem)
   (si::set-up-top-level)
   
   (if (si::get-command-arg "-compile")
       (let (;(system::*quit-tag* (cons nil nil))
		;(system::*quit-tags* nil) (system::*break-level* '())
		;(system::*break-env* nil) (system::*ihs-base* 1)
		;(system::*ihs-top* 1) (system::*current-ihs* 1)
	     (*break-enable* nil) result)
	 (setq result
	       (system:error-set
		'(progn
		   (compile-file
		    (si::get-command-arg "-compile")
		    :output-file 
		    (or (si::get-command-arg "-o")
			(si::get-command-arg "-compile"))
		    :o-file
		    (cond ((equalp
			    (si::get-command-arg "-o-file")
			    "nil") nil)
			  ((si::get-command-arg "-o-file" t))
			  (t t))
		    :c-file (si::get-command-arg "-c-file" t)
		    :h-file (si::get-command-arg "-h-file" t)
		    :data-file (si::get-command-arg "-data-file" t)
		    :system-p (si::get-command-arg "-system-p" t)))))
	 (bye (if (or compiler::*error-p* (equal result '(nil))) 1 0))))
   (cond ((si::get-command-arg "-batch")
	  (setq si::*top-level-hook* 'bye))
	 ((si::get-command-arg "-f"))
	 (t (format t si::*system-banner*)))
   (setq si::*ihs-top* 1)
   (in-package 'system::user) (incf system::*ihs-top* 2)
   (funcall system::*old-top-level*))
 
 (terpri)
 (setq si:*inhibit-macro-special* t)
 (gbc t) (system:reset-gbc-count)
 
 (defun system:top-level nil (system::gcl-top-level))
 
 (setq compiler::*default-c-file* nil)
 (setq compiler::*default-h-file* nil)
 (setq compiler::*default-data-file* nil)
 (setq compiler::*default-system-p* nil)
 (setq compiler::*keep-gaz* nil)
 
 
 
 (setq clcs_shadow
       '(CONDITIONS::BREAK
	 CONDITIONS::ERROR
	 CONDITIONS::CERROR
	 CONDITIONS::WARN
	 CONDITIONS::CHECK-TYPE
	 CONDITIONS::ASSERT
	 CONDITIONS::ETYPECASE
	 CONDITIONS::CTYPECASE
	 CONDITIONS::ECASE
	 CONDITIONS::CCASE ))
 
 (setq lisp_unexport
       '(LISP::LAMBDA-BLOCK-CLOSURE
	 LISP::BYE
	 LISP::QUIT
	 LISP::EXIT
	 LISP::IEEE-FLOATING-POINT
	 LISP::DEFENTRY
	 LISP::VOID
	 LISP::ALLOCATE-CONTIGUOUS-PAGES
	 LISP::UNSIGNED-SHORT
	 LISP::DOUBLE
	 LISP::BY
	 LISP::GBC
	 LISP::DEFCFUN
	 LISP::SAVE
	 LISP::MAXIMUM-CONTIGUOUS-PAGES
	 LISP::SPICE
	 LISP::DEFLA
	 LISP::ALLOCATED-PAGES
	 LISP::SUN
	 LISP::INT
	 LISP::USE-FAST-LINKS
	 LISP::CFUN
	 LISP::UNSIGNED-CHAR
	 LISP::HELP
	 LISP::HELP*
	 LISP::MACRO
	 LISP::*BREAK-ENABLE*
	 LISP::CLINES
	 LISP::LAMBDA-CLOSURE
	 LISP::OBJECT
	 LISP::FAT-STRING
	 LISP::SIGNED-SHORT
	 LISP::MC68020
	 LISP::LAMBDA-BLOCK
	 LISP::TAG
	 LISP::PROCLAMATION
	 LISP::ALLOCATED-CONTIGUOUS-PAGES
	 LISP::*EVAL-WHEN-COMPILE*
	 LISP::SIGNED-CHAR
	 LISP::*IGNORE-MAXIMUM-PAGES*
	 LISP::*LINK-ARRAY*
	 LISP::KCL
	 LISP::BSD
	 LISP::ALLOCATE-RELOCATABLE-PAGES
	 LISP::ALLOCATE
	 LISP::UNIX
	 LISP::MAXIMUM-ALLOCATABLE-PAGES
	 LISP::ALLOCATED-RELOCATABLE-PAGES
	 LISP::SYSTEM
	 LISP::KYOTO
	 LISP::CCLOSURE))
 
;anything in "SYSTEM" which should go in "COMMON-LISP"
;can be added to shadow-system
 (setf shadow-system '(system::copy-structure))
 
 (do-external-symbols (s "SYSTEM")
		      (when (member s shadow-system)
			(shadowing-import (list s) "COMMON-LISP")
			(shadowing-import (list s) "USER")))
 
 
 (do-external-symbols (s "LISP")
		      (if (not(member s lisp_unexport))
			  (progn 
			    (import (list s) "COMMON-LISP")
			    (import (list s) "USER")) ))
 
 (do-external-symbols (s "PCL")
		      (import (list s) "COMMON-LISP")
		      (import (list s) "USER"))
 
;(shadowing-import (list 'pcl::classp) "SYSTEM")
 (setf (symbol-function 'si::classp) (symbol-function 'pcl::classp))
 (setf (symbol-function 'si::class-of) (symbol-function 'pcl::class-of))
 (setf (symbol-function 'si::class-precedence-list) 
       (symbol-function 'pcl::class-precedence-list))
 (setf (symbol-function 'si::find-class) 
       (symbol-function 'pcl::find-class))
 
 (do-external-symbols (s "CONDITIONS")
		      (if (member s clcs_shadow)
			  (progn 
			    (shadowing-import (list s) "COMMON-LISP")
			    (shadowing-import (list s) "USER"))
			(progn
			  (import (list s) "COMMON-LISP")
			  (import (list s) "USER"))))
 
 t)

(progn

  (dolist (s '(*compile-file-pathname* *compile-file-truename*
				       *compile-print* *compile-verbose* *load-pathname* *load-print*
				       *load-truename* *print-lines* *print-miser-width*
				       *print-pprint-dispatch* *print-right-margin* *read-eval*
				       lisp::arithmetic-error broadcast-stream-streams cell-error
				       cell-error-name compile compile-file compiler-macro
				       compiler-macro-function complement concatenated-stream-streams
				       condition control-error copy-pprint-dispatch copy-structure count
				       debug define-compiler-macro define-setf-expander define-symbol-macro
				       defpackage describe describe-object division-by-zero dynamic-extent
				       echo-stream-input-stream echo-stream-output-stream
				       ensure-directories-exist fdefinition file-string-length formatter
				       function-lambda-expression get-setf-expansion hash-table-rehash-size
				       hash-table-rehash-threshold ignorable interactive-stream-p
				       load-logical-pathname-translations load-time-value
				       logical-pathname-translations make-load-form
				       make-load-form-saving-slots make-method open-stream-p pathname-match-p
				       pprint-dispatch pprint-exit-if-list-exhausted pprint-fill
				       pprint-indent pprint-linear pprint-logical-block pprint-newline
				       pprint-pop pprint-tab pprint-tabular print-not-readable-object
				       print-unreadable-object read-sequence readtable-case row-major-aref
				       set-pprint-dispatch simple-condition-format-control
				       stream-external-format synonym-stream-symbol
				       translate-logical-pathname translate-pathname
				       two-way-stream-input-stream two-way-stream-output-stream
				       unbound-slot-instance 
				       upgraded-complex-part-type wild-pathname-p with-compilation-unit
				       with-condition-restarts with-package-iterator with-standard-io-syntax
				       write-sequence ))
    (shadowing-import (list s) "COMMON-LISP"))
  
  (use-package "ANSI-LOOP" "COMMON-LISP")
  (use-package "ANSI-LOOP" "USER")
  
  (do-symbols (s "COMMON-LISP")
	      (export (list s) "COMMON-LISP"))
  
  (rename-package 'common-lisp 'common-lisp '(cl))
  
  (unintern 'system)
  (unintern 'lisp)
  (unintern 'compiler)
  (unintern 'user)
  (fmakunbound 'si::init-cmp-anon)
  
  (makunbound 'clcs_shadow)
  (makunbound 'lisp_unexport)
  (makunbound 'shadow-system)
  (unintern 'clcs_shadow)
  (unintern 'lisp_unexport)
  (unintern 'int)
  (unintern 'shadow-system)
  
  (push :common-lisp *features*)
  (push :ansi-cl *features*)
  
  (eval-when (load)
	     (if (fboundp 'get-system-time-zone)
		 (setf system:*default-time-zone* (get-system-time-zone))
	       (setf system:*default-time-zone* 6)))
  
  (if (fboundp 'si::user-init) (si::user-init))
  (si::set-up-top-level)
  
  (setq si::*gcl-extra-version* 7
	si::*gcl-minor-version* 6 
	si::*gcl-major-version* 2)
  (setq compiler::*cc* "cc -c -O2 -fno-strict-aliasing -pipe -I/usr/local/include -Wall -DVOL=volatile -fsigned-char -pipe ")
  (setq compiler::*ld* "cc -o ")
  (setq compiler::*ld-libs* "   -lansi_gcl -lgclp -lreadline -lm -L/usr/local/lib -lgmp ")
  (setq compiler::*opt-three* "-O3 -fomit-frame-pointer")
  (setq compiler::*opt-two* "-O")
  (setq compiler::*init-lsp* "init_ansi_gcl.lsp")

  (defvar si::*system-banner* (si::default-system-banner))

  (in-package 'user)
  (import 'si::info)

  t)
