anchor.diff:      ;; remaining-parameters have been modified)
       (dolist (parameter remaining-parameters)
         (typecase parameter
  -        (optional-function-argument-form
  +        (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)))
  
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:         (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))
  