anchor.diff:                               (,name/4 (+ start ,(+ n/2 n/4))))))
                       (push body defs))))))
         (gen n)
  -      `(labels (,@base-defs ,@(nreverse defs))
  -         (declare (ignorable ,@(mapcar (lambda (x) `#',(car x)) base-defs))
  -                  (inline ,@(mapcar #'car base-defs)
  -                          ,(name n)))
  -         ,(and (<= n *fwd-base-case*)
  -               (not (and (eql scale 1d0)
  -                         (null window)))
  -               `(for (,n (i start)
  -                         ,@(and window `((j window-start))))
  -                  (setf (aref vec i) (%scale
  -                                      (%window (aref vec i)
  -                                               ,window
  -                                               ,(if window 'j 0))
  -                                      ,scale))))
  +      `(labels (,@(nreverse defs))
  +         (declare (inline ,(name n)))
            (,(name n) start)))))
   
   (defun %dif (vec start n twiddle)
  
positive.code: (defvar *fwd-base-case* 8)
  
  (defun gen-flat-dif (n &key (scale 1d0) window)
    (with-vector (n :maxlive 13)
  
negative.code:                       (rec start3 n/4))))))
          (rec 0 n)))))
  
  (defun gen-dif (n &key (scale 1d0) window)
    (let ((defs '())
          (last n))
      (labels ((name (n)
                 (intern (format nil "~A/~A" 'dif n)))
               (gen (n &aux (name (name n)))
                 (when (member name defs :key #'first)
                   (return-from gen name))
                 (cond
                   ((<= n *fwd-base-case*)
                    (push
                     `(,(name n) (start)
                       (declare (type index start)
                                (ignorable start))
                       ,(if (= n last)
                            (gen-flat-dif n :scale scale :window window)
                            (gen-flat-dif n)))
                     defs))
                   ((> n *fwd-base-case*)
                    (gen (truncate n 4))
                    (gen (truncate n 2))
                    (let* ((n/2 (truncate n 2))
                           (n/4 (truncate n 4))
  