anchor.diff:    (setf (symbol-value var) value)
     (kontinue k value))
   
  +(defk k-for-local-lexical-setq (var env k)
  +    (value)
  +  (funcall (second (lookup env :lexical-let var :error-p t)) value)
  +  (kontinue k value))
  +
   (defmethod evaluate/cps ((setq setq-form) env k)
  -  (if (lookup env :let (var setq))
  -      (evaluate/cps (value setq)
  -                    env `(k-for-local-setq ,(var setq) ,env ,k))
  -      (evaluate/cps (value setq)
  -                    env `(k-for-free-setq ,(var setq) ,env ,k))))
  +  (cond
  +    ((lookup env :let (var setq))
  +     (evaluate/cps (value setq)
  +                   env `(k-for-local-setq ,(var setq) ,env ,k)))
  +    ((lookup env :lexical-let (var setq))
  +     (evaluate/cps (value setq)
  +                   env `(k-for-local-lexical-setq ,(var setq) ,env ,k)))
  +    (t
  +     (evaluate/cps (value setq)
  +                   env `(k-for-free-setq ,(var setq) ,env ,k)))))
   
   ;;;; SYMBOL-MACROLET
   
  
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))
  