anchor.diff:      (cond (fn (funcall fn form env))
             #+nil((macro-function (first form) env)
              (eval-in-lexenv (macroexpand-1 form env) env))
  -          (t (apply (first form)
  +          (t (apply (find-function (first form) env)
                       (mapcar (lambda (f) (eval-in-lexenv f env))
                               (rest form)))))))
   
  
positive.code: 	(push (list :special v) env))))
    (eval-progn-body body env))
  
  (defspecial function (&environment env name)
    (if (sys.int::lambda-expression-p name)
        (eval-lambda name env)
        (fdefinition name)))
  
  (defspecial quote (object)
    object)
  
  (defspecial setq (&environment env symbol value)
    (setf (symbol-value symbol) (eval-in-lexenv value env)))
  
negative.code:   `(setf (gethash ',name *special-forms*)
           (lambda (,form-sym ,env-sym)
             (declare (ignorable ,form-sym ,env-sym)
                      (system:lambda-name (special-form ,name)))
             (block ,name
               (destructuring-bind ,lambda-list (cdr ,form-sym)
                 ,@body))))))
  
  (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) :special) (member symbol (rest e)))
        (return symbol))
      (when (and (eql (first e) :binding) (eql (second e) symbol))
        (return e))))
  
  (defun find-function (name env)
    (dolist (e env (fdefinition name))
      (when (eql (first e) :functions)
        (let ((fn (assoc name (rest e))))
  	(when fn
  	  (return (cdr fn)))))))
  
  (defun eval-lambda (lambda outer-env)
    (let ((lambda-list (second lambda))
  