anchor.diff:  (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)
  +      (labels ((rec (start n)
                    (cond
  +                   ((= n 1)
  +                    (when (and (= n last)
  +                               (or (not (eql scale 1d0))
  +                                   window))
  +                      (scale start scale window)))
                      ((= n 2)
                       (when (and (= n last)
                                  (or (not (eql scale 1d0))
                                      window))
  -                      (scale start)
  -                      (scale (1+ start)))
  +                      (scale start scale window)
  +                      (scale (1+ start) scale window))
                       (butterfly start (1+ start)))
  -                   ((>= n 4)
  +                   (t
                       (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)))
  +                          (scale (+ i start) scale window)
  +                          (scale (+ i start2) scale window))
                           (butterfly (+ i start)
                                      (+ i start2)))
                         (rec start n/2)
  
positive.code:                           (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))
  
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
  