anchor.diff:            ((:constant) +symbol-mode-constant+)
             ((:symbol-macro) +symbol-mode-symbol-macro+)))
     value)
  +
  +(setf (symbol-mode 'nil) :constant)
  +
  +(defun variable-information (symbol)
  +  (symbol-mode symbol))
   
   ;;; The compiler can only handle (apply function arg-list).
   (defun apply (function arg &rest more-args)
  
positive.code:                                    (declare (ignore r))
                                     (error 'undefined-function :name symbol))
          (get symbol '%macro-function) value))
  
  ;;; Calls to these functions are generated by the compiler to
  ;;; signal errors.
  
negative.code:        ;; Interpreted function. Second entry in the constant pool.
         (memref-t address 7)))))
  
  (defun function-lambda-expression (function)
    (check-type function function)
    (let* ((address (logand (lisp-object-address function) -16))
           (info (memref-unsigned-byte-64 address 0)))
      (ecase (logand info #xFF)
        (#.+function-type-function+ ;; Regular function. First entry in the constant pool.
         (values nil nil (* (logand (ash info -16) #xFFFF) 2)))
        (#.+function-type-closure+ ;; Closure.
         (values nil t (function-name (memref-t address 4))))
        (#.+function-type-interpreted-function+
         (values (memref-t address 5) (memref-t address 6) (memref-t address 7))))))
  
  (defun compiled-function-p (object)
    (when (functionp object)
      (let* ((address (logand (lisp-object-address object) -16))
             (info (memref-unsigned-byte-64 address 0)))
        (not (eql (logand info #xFF) +function-type-interpreted-function+)))))
  
  (defvar *gensym-counter* 0)
  (defun gensym (&optional (thing "G"))
    (make-symbol (format nil "~A~D" thing (prog1 *gensym-counter* (incf *gensym-counter*)))))
  