anchor.diff:    passed a continutaion. This object may then be passed to the
     function KALL which will cause execution to resume around the
     call/cc form. "
  -  (let ((walk-env nil)
  +  (let ((walk-env (make-walk-env e))
           (evaluate-env nil))
  -    (assert (every (lambda (binding)
  -                     (and (consp binding)
  -                          (= 2 (length binding))))
  -                   initial-environment)
  -            (initial-environment)
  -            "Sorry, INITIAL-ENVIRONMENT must be a list of two element lists, not: ~S"
  -            initial-environment)
  -    (loop
  -       for (name value) in initial-environment
  -       do (setf walk-env (register walk-env :let name value)
  -                evaluate-env `(register ,evaluate-env :let ',name ,value)))
  +    (dolist* ((type name &rest data) walk-env)
  +      (declare (ignore data))
  +      (when (eql :lexical-let type)
  +        (push (list 'list
  +                    :lexical-let
  +                    `(quote ,name)
  +                    ;; NB: this makes the environment, and therefore
  +                    ;; contiunations, unserializable. we would need to
  +                    ;; change this to a regular :let and not allow the
  +                    ;; setting of lexical variables.
  +                    `(lambda () ,name)
  +                    (with-unique-names (v)
  +                      `(lambda (,v) (setf ,name ,v))))
  +              evaluate-env)))
  +    (setf evaluate-env `(list ,@(nreverse evaluate-env)))
       `(drive-cps (evaluate/cps ,(walk-form (if (rest body)
                                                 `(progn ,@body)
                                                 (first body))
  
positive.code: 
  (defvar *call/cc-returns* nil)
  
  (defmacro with-call/cc (initial-environment &body body)
    "Execute BODY with delimited partial continuations.
  
    Within the code of BODY almest all common lisp forms maintain
  
negative.code: ;;;; Variable References
  
  (defmethod evaluate/cps ((var local-variable-reference) env k)
    (kontinue k (lookup env :let (name var) :error-p t)))
  
  (defmethod evaluate/cps ((var local-lexical-variable-reference) env k)
    (kontinue k (funcall (first (lookup env :lexical-let (name var) :error-p t)))))
  
  (defmethod evaluate/cps ((var free-variable-reference) env k)
    (declare (ignore env))
  