anchor.diff:                            (gen-flat-dif n :scale scale :window window)
                             (gen-flat-dif n)))
                      defs))
  -                 ((> n *fwd-base-case*)
  +                 (t
                     (gen (truncate n 4))
                     (gen (truncate n 2))
                     (let* ((n/2 (truncate n 2))
  
positive.code: (defun gen-flat-dif (n &key (scale 1d0) window)
    (with-vector (n :maxlive 13)
      (let ((last n))
        (labels ((scale (i)
                   (setf (@ i)
                         (op (complex-sample)
                             `(lambda (x)
                                (%window (%scale x ,scale)
                                         ,window
                                         ,i))
                             (@ i))))
                 (rec (start n)
                   (cond
                     ((= n 2)
                      (when (and (= n last)
                                 (or (not (eql scale 1d0))
                                     window))
                        (scale start)
                        (scale (1+ start)))
                      (butterfly start (1+ start)))
                     ((>= n 4)
                      (let* ((n/2    (truncate n 2))
                             (start2 (+ start n/2))
                             (n/4    (truncate n/2 2))
                             (start3 (+ start2 n/4)))
                        (dotimes (i n/2)
                          (when (= last n)
                            (scale (+ i start))
                            (scale (+ i start2)))
                          (butterfly (+ i start)
                                     (+ i start2)))
                        (rec start n/2)
  
negative.code:                (intern (format nil "~A/~A" 'dif n)))
               (gen (n &aux (name (name n)))
                 (when (member name defs :key #'first)
                   (return-from gen))
                 (cond
                   ((<= n *fwd-base-case*)
                    (push
  