anchor.diff:              for i upfrom 0
               do (insert-write val i))
         new)))
  +
  +(defun butterfly (i j)
  +  (setf (values (@ i) (@ j))
  +        (op (complex-sample complex-sample)
  +            `(lambda (x y)
  +               (values (+ x y)
  +                       (- x y)))
  +            (@ i) (@ j))))
  +
  +(defun rotate (i k root)
  +  (setf (@ i)
  +        (op (complex-sample)
  +            `(lambda (x)
  +               ,(mul-root 'x root
  +                          (and k
  +                               `(aref twiddle ,k))))
  +            (@ i))))
  
positive.code: 
  (defvar *ops*)
  
  (defun op (result-types body args)
    (let ((op (%op result-types body args)))
      (vector-push-extend op *ops*)
      (values-list (op-writes op))))
  
  (defvar *vector*)
  
  
negative.code:                   (load-op
                     (let ((var (load-op-var op)))
                       `((,(vval-name var)) (,(vval-type var))
                         (aref vec (+ start ,(load-op-idx op))))))
                    (store-op
                     `(() () (setf (aref vec (+ start ,(store-op-idx op)))
                                   ,(let ((var (store-op-var op)))
                                      (if (vval-p var)
                                          (vval-name var)
  