anchor.diff:                     (loop repeat (- n counter) do (make-var))))
                  x)
                (make-spliced-call (f env)
  -               (let ((fn (car f)))
  -                 (if (eql fn 'progn)
  -                     (make-spliced-call
  -                      `((lambda (&rest xs)
  -                          xs)
  -                        ,@(rest f))
  -                      env)
  -                     (let ((splice (splice (cdr f) env)))
  -                       `(multiple-value-call (function ,fn)
  -                          ,@splice)))))
  +               (match f
  +                 ((list* 'progn body)
  +                  (make-spliced-call
  +                   `((lambda (&rest xs)
  +                       xs)
  +                     ,@body)
  +                   env))
  +                 ((list* fn _)
  +                  (let ((splice (splice (cdr f) env)))
  +                    `(multiple-value-call (function ,fn)
  +                       ,@splice)))))
                (walk-op (x env)
                  (declare (ignorable env))
                  #+sbcl
  
positive.code:                              `(values ,x)))
                         y))
               (quotation? (x env)
                 (let ((exp (expand-macro-recursively x env)))
                   (and (listp exp)
                        (eql (car exp) 'quote))))
               (rest-op? (x env)
                 (declare (ignorable env))
                 #+sbcl
                 (prog1 nil
                   (sb-walker:walk-form
                    x env
                    (lambda (f c e)
                      (cond ((and (eql c :eval) (rest-placeholder? f e))
                             (return-from rest-op? t))
                            (t f)))))
  
                 #-sbcl
                 (or (and (listp x)
  
negative.code:                             y)))
                       (t x))))
        (declare (ignorable #'quotation?))
        (let ((body (walk-op `(progn ,@body) outer-env))
              (rest
                (and (rest-op? `(progn ,@body) outer-env)
                     `(&rest ,(intern (string '_*))))))
          `(lambda (,@(reverse vars) ,@rest)
             (declare (ignorable ,@vars))
  