anchor.diff:       (write-char #\Space)
        (write-integer (sys.int::lisp-object-address object) 16)
        (write-char #\>))
  +    (simple-condition
  +     (write-char #\#)
  +     (write-char #\<)
  +     (write (class-name (class-of object)))
  +     (write-char #\Space)
  +     (write (simple-condition-format-control object))
  +     (write-char #\Space)
  +     (write-integer (sys.int::lisp-object-address object) 16)
  +     (write-char #\>))
       (t (write-char #\#)
          (write-char #\<)
          (write-string "Unknown-object ")
  
positive.code:   (prog1 (sys.int::%make-symbol *bump-pointer* (sys.int::simplify-string name))
      (incf *bump-pointer* (* 8 6))))
  
  (defun sys.int::raise-type-error (datum expected)
    (fresh-line)
    (write-string "Type error. Expected ")
    (write expected)
    (write-string " got ")
    (write datum)
    (terpri)
    (backtrace)
    (loop))
  
  (defun eval (form)
    (typecase form
  
negative.code:   (sys.int::%fmakunbound (sys.int::function-symbol name))
    name)
  
  (defparameter *debugger-depth* 0)
  (defvar *debug-io* nil)
  
  (defun sys.int::enter-debugger (condition)
    (let* ((*standard-input* *debug-io*)
  	 (*standard-output* *debug-io*)
  	 (debug-level *debugger-depth*)
  	 (*debugger-depth* (1+ *debugger-depth*))
  	 (restarts (compute-restarts))
  	 (restart-count (length restarts)))
      (fresh-line)
      (write condition :escape nil :readably nil)
      (write-char #\Space)
      (write-char #\()
      (write (class-name (class-of condition)))
      (write-char #\))
      (fresh-line)
      (show-restarts restarts)
      (loop
         (fresh-line)
         (write-string "Pick a restart# ")
         (let ((form (read)))
           (when (and (integerp form) (>= form 0) (< form restart-count))
             (invoke-restart-interactively (nth (- restart-count form 1) restarts)))))))
  
  (defun show-restarts (restarts)
    (let ((restart-count (length restarts)))
      (write-string "Available restarts:")(terpri)
      (do ((i 0 (1+ i))
  	 (r restarts (cdr r)))
  	((null r))
        (write i)
        (write-char #\Space)
        (write (restart-name (car r)))
        (terpri))))
  
  (defun sys.int::%invalid-argument-error (&rest args)
    (fresh-line)
    (write-string "Invalid arguments to function")
    (fresh-line)
    (backtrace)
    (loop))
  
  (defun copy-list (list)
    (when list
      (cons (car list) (copy-list (cdr list)))))
  
  (setf *package* (find-package "CL-USER"))
  (loop
     (with-simple-restart (continue "Carry on chaps.")
       (fresh-line)
       (write-char #\>)
       (let ((form (read)))
         (fresh-line)
         (let ((result (eval form)))
           (fresh-line)
           (write result)))))
  