anchor.diff:  
   (defun find-variable (symbol env)
     "Locate SYMBOL in ENV. Returns a binding list or the symbol if there was no lexical binding."
  -  (dolist (e env symbol)
  -    (when (and (eql (first e) :symbol-macros)
  -               (assoc symbol (rest e)))
  -      (return (list :symbol-macro (second (assoc symbol (rest e))))))
  -    (when (and (eql (first e) :special) (member symbol (rest e)))
  -      (return symbol))
  -    (when (and (eql (first e) :binding) (eql (second e) symbol))
  -      (return e))))
  +  (sys.c::lookup-variable-in-environment symbol env))
   
   (defun find-function (name env)
  -  (dolist (e env (restart-case (fdefinition name)
  +  (let ((local-fn (sys.c::lookup-function-in-environment name env)))
  +    (cond ((functionp local-fn)
  +           ;; Macro function.
  +           (error "~S names a macro." name))
  +          ((typep local-fn 'lexical-variable)
  +           (variable-value local-fn))
  +          (t (restart-case (fdefinition name)
                      (use-value (v)
                        :interactive (lambda ()
                                       (format t "Enter a new value (evaluated): ")
  
positive.code:   (multiple-value-bind (body declares)
        (sys.int::parse-declares body)
      (eval-locally-body declares body
                         (cons (list* :macros
                                      (mapcar 'frob-macrolet-definition definitions))
                               env))))
  
  (defspecial symbol-macrolet (&environment env definitions &body body)
    (multiple-value-bind (body declares)
        (sys.int::parse-declares body)
      (eval-locally-body declares body
                         (cons (list* :symbol-macros definitions)
                               env))))
  
  (defspecial tagbody (&environment env &body body)
    (let ((current body))
      (tagbody
         (setf env (cons (list* :tagbody
                                (lambda (tag)
                                  (setf current (member tag body))
                                  (go loop))
                                (remove-if-not (lambda (x) (or (symbolp x) (integerp x))) body))
                         env))
       loop
         (cond
           ((null current)
  
negative.code: (defspecial quote (object)
    object)
  
  (defspecial setq (&environment env &rest pairs)
    (when (oddp (length pairs))
      (error "Odd number of arguments to SETQ."))
    (when pairs
      (flet ((set-one (symbol value)
               (let ((var (find-variable symbol env)))
                 (etypecase var
                   (sys.c::special-variable
                    (setf (symbol-value symbol) (eval-in-lexenv value env)))
                   (sys.c::symbol-macro
                    (eval-in-lexenv `(setf ,symbol ,value) env))
                   (lexical-variable
                    (setf (variable-value var) (eval-in-lexenv value env)))))))
      (do ((i pairs (cddr i)))
          ((null (cddr i))
           (set-one (first i) (second i)))
  