anchor.diff:          (apply #'kontinue (first arguments) (cdr arguments)))
         (arguments func) '()
         env))
  +
  +    ((and (eql 'call-next-method (operator func))
  +	  (second (multiple-value-list (lookup env :next-method t))))
  +     (aif (lookup env :next-method t)
  +	  (evaluate-arguments-then-apply
  +	   (lambda (arguments)
  +	     (apply-lambda/cc it arguments k))
  +	   (arguments func) '() env)
  +	  (error "no next method")))
  +
  +    ((and (eql 'next-method-p (operator func))
  +	  (second (multiple-value-list (lookup env :next-method t))))
  +     (kontinue k (lookup env :next-method t)))
       
       ((eql 'funcall (operator func))
        (evaluate-funcall/cc (arguments func) env k))
  
positive.code:        (declare (ignorable ,@(extract-argument-names arguments :allow-specializers nil)))
         (error "Sorry, /CC function are not callable outside of with-call/cc."))))
  
  (defmacro defmethod/cc (name arguments &body body)
    `(progn
       (setf (get ',name 'defmethod/cc) t)
       (defmethod ,name ,arguments
         (declare (ignorable ,@(extract-argument-names arguments :allow-specializers t)))
         (make-instance 'closure/cc
                        :code (walk-form '(lambda ,(extract-argument-names arguments :allow-specializers t
                                                                           :keep-lambda-keywords t)
                                           ,@body)
                                         nil nil)
                        :env nil))))
  
  (defmacro defgeneric/cc (name args &rest options)
    "Trivial wrapper around defgeneric designed to alert readers that these methods are cc methods."
    `(defgeneric ,name ,args ,@options))
  
  ;; Copyright (c) 2002-2005, Edward Marco Baringer
  ;; All rights reserved. 
  
negative.code:     ;; remaining-parameters have been modified)
      (dolist (parameter remaining-parameters)
        (typecase parameter
          (rest-function-argument-form
  	 (setf env (register env :let (name parameter) remaining-arguments))
  	 (setf remaining-arguments nil))
  	(optional-function-argument-form
           (if remaining-arguments
               (progn
                 (setf env (register env :let (name parameter) (pop remaining-arguments)))
  