anchor.diff:       (compile ',(cnym f))))
   
   (defmacro binop2 (oper &key nlp nrp nym)
  -    (def nym oper)
  -    (un nlp)
  -    (un nrp)
  -    (labels ((helper (a b) (if a `(format nil "(~a)" (cof ,b)) `(cof ,b))))
  -            `(cdefun ,nym (x y) (format nil "~a~a~a" ,(helper nlp 'x) ',oper ,(helper nrp 'y)))))
  -
  -; does a left reduce
  +  (def nym oper)
  +  (un nlp)
  +  (un nrp)
  +  (labels ((helper (a b) (if a `(format nil "(~a)" (cof ,b)) `(cof ,b))))
  +    `(cdefun ,nym (x y) (format nil "~a~a~a" ,(helper nlp 'x) ',oper ,(helper nrp 'y)))))
  +
  +					; does a left reduce
   (defmacro lredop (oper &key nym nparen)
     (def nym oper)
  - (let ((lp (if nparen "" "(")) (rp (if nparen "" ")")))
  -  `(cdefun ,nym (&rest xs)
  -     (if (null xs) nil
  -         (if (= 1 (length xs))
  -             (format nil "~a~a~a" ,lp (cof (car xs)) ,rp)
  -             (format nil "~a~a~a~a~a~a~a" ,lp ,lp (cof (car xs)) ,rp ',oper (apply (function ,(cnym nym)) (cdr xs)) ,rp))))))
  +  (let ((lp (if nparen "" "(")) (rp (if nparen "" ")")))
  +    `(cdefun ,nym (&rest xs)
  +	     (if (null xs) nil
  +		 (if (= 1 (length xs))
  +		     (format nil "~a~a~a" ,lp (cof (car xs)) ,rp)
  +		     (format nil "~a~a~a~a~a~a~a" ,lp ,lp (cof (car xs)) ,rp ',oper (apply (function ,(cnym nym)) (cdr xs)) ,rp))))))
   
   (defmacro rredop (oper &key nym nparen)
     (def nym oper)
  - (let ((lp (if nparen "" "(")) (rp (if nparen "" ")")))
  +  (let ((lp (if nparen "" "(")) (rp (if nparen "" ")")))
       `(cdefun ,nym (&rest xs)
  -     (if (null xs) nil
  -         (if (= 1 (length xs))
  -             (format nil "~a~a~a" ,lp (cof (car xs)) ,rp)
  -             (format nil "~a~a~a~a~a~a~a" ,lp (apply (function ,(cnym nym)) (butlast xs)) ',oper ,lp (cof (car (last xs))) ,rp ,rp))))))
  +	     (if (null xs) nil
  +		 (if (= 1 (length xs))
  +		     (format nil "~a~a~a" ,lp (cof (car xs)) ,rp)
  +		     (format nil "~a~a~a~a~a~a~a" ,lp (apply (function ,(cnym nym)) (butlast xs)) ',oper ,lp (cof (car (last xs))) ,rp ,rp))))))
   
   
   (defmacro binop (oper &key nlp nrp nym nyms l r nparen)
     ;;; (format t "OPER:~a NYM:~a NYMS:~a NPAREN:~a~%" oper nym nyms nparen)
  -    (if nyms
  -        `(progn ,@(mapcar #'(lambda (x) `(binop ,oper :nlp ,(un nlp) :nrp ,(un nrp) :nym ,x :l l :r r :nparen ,nparen)) nyms))
  -        (if (or l r)
  -            (if l `(lredop ,oper :nym ,nym :nparen ,nparen) `(rredop ,oper :nym ,nym :nparen ,nparen))
  -            `(binop2 ,oper :nlp ,nlp :nrp ,nrp :nym ,nym))))
  +  (if nyms
  +      `(progn ,@(mapcar #'(lambda (x) `(binop ,oper :nlp ,(un nlp) :nrp ,(un nrp) :nym ,x :l l :r r :nparen ,nparen)) nyms))
  +      (if (or l r)
  +	  (if l `(lredop ,oper :nym ,nym :nparen ,nparen) `(rredop ,oper :nym ,nym :nparen ,nparen))
  +	  `(binop2 ,oper :nlp ,nlp :nrp ,nrp :nym ,nym))))
   
   (defmacro pre (oper &key nym nparen)
     `(cdefun ,nym (x) (format nil "~a~a~a~a" ',oper ,(if nparen "" "(") (cof x) ,(if nparen "" ")") )))
   (defmacro post (oper &key nym nparen)
     `(cdefun ,nym (x) (format nil "~a~a~a~a" ,(if nparen "" "(") (cof x) ,(if nparen "" ")") ',oper)))
   (defmacro prepost (oper &key post nym nparen nyms)
  -    (setf nym (if nym nym oper))
  -    (if nyms
  -        `(progn ,@(mapcar #'(lambda (x) `(prepost ,oper :post ,post :nym ,x :nparen ,nparen)) nyms))
  -        (if post
  -            `(post ,oper :nym ,nym :nparen ,nparen)
  -            `(pre ,oper :nym ,nym :nparen ,nparen))))
  +  (setf nym (if nym nym oper))
  +  (if nyms
  +      `(progn ,@(mapcar #'(lambda (x) `(prepost ,oper :post ,post :nym ,x :nparen ,nparen)) nyms))
  +      (if post
  +	  `(post ,oper :nym ,nym :nparen ,nparen)
  +	  `(pre ,oper :nym ,nym :nparen ,nparen))))
   (defmacro preposts (&rest opers)
  -    `(progn ,@(mapcar #'(lambda (oper) `(prepost ,@(f/list oper))) opers)))
  +  `(progn ,@(mapcar #'(lambda (oper) `(prepost ,@(f/list oper))) opers)))
   (defmacro binops (&rest opers)
  -    `(progn ,@(mapcar #'(lambda (oper) `(binop ,@(f/list oper))) opers)))
  +  `(progn ,@(mapcar #'(lambda (oper) `(binop ,@(f/list oper))) opers)))
   
   (defmacro swap (a b)
     (let ((c (gensym)))
  -  `(let ((,c ,a))
  -     (setf ,a ,b)
  -     (setf ,b ,c)
  -     (setf ,c ,a))))
  +    `(let ((,c ,a))
  +       (setf ,a ,b)
  +       (setf ,b ,c)
  +       (setf ,c ,a))))
   
   (defmacro cfun (nym llisp &body body)
  -    `(cdefun ,nym ,llisp ,@body))
  +  `(cdefun ,nym ,llisp ,@body))
   
   (defmacro cfuns (&body defs)
  -    `(progn ,@(mapcar #'(lambda (def) `(cfun ,@def)) defs)))
  +  `(progn ,@(mapcar #'(lambda (def) `(cfun ,@def)) defs)))
   
   (defun c (&rest xs)
     (format nil "~{~a~^~(;~%~%~)~}" (mapcar #'cof xs)))
  
positive.code: (defun count-lines-in-file (filename)
    (let ((n 0))
      (with-open-file (stream filename :direction :input :if-does-not-exist nil)
              (if stream
                  (loop for line = (read-line stream nil 'done)
                      until (eq line 'done)
                      do (incr n))))
      n))
    
    (defun read-whole-file (filename)
      (format nil "~{~a~^~%~}"
          (with-open-file (stream filename :direction :input :if-does-not-exist nil)
              (if stream
                  (loop for line = (read-line stream nil 'done)
                      until (eq line 'done)
                      collect line)))))
  
  (defun c-whole-file (filename)
    (let ((s (read-whole-file filename)) (result t) (n 0))
      (apply #'c (loop while result collect
            (progn
              (multiple-value-setq (result n) (read-from-string s nil))
              (setf s (subseq s n))
              result)))))
  
  (defun cwf (filename)
    (format t "~a" (c-whole-file filename)))
  
  (defun tempfilename (&optional extension)
      (labels ((genfilename () (strsof `(temp ,(random 1.0) ,extension))))
              (let ((filename (genfilename)))
                (loop while (probe-file filename) do
                      (setf filename (genfilename)))
                filename)))
  
  (defun compile-cl-file (filein &key fileout tags libs c-file cc)
    (def fileout "a.out")
    (def tags "")
    (def libs "")
    (def cc "gcc")
      (let ((c-code (c-whole-file filein)) (temp-file (if c-file c-file (tempfilename ".c"))))
        (format t "~a" c-file)
        (if (and *last-compiled* (not (eq *last-compiled* c-file))) (delete-file *last-compiled*))
          (with-open-file (c-file-stream temp-file :direction :output :if-does-not-exist :create)
              (format c-file-stream "~a" c-code))
          (format t "Running: ~a ~a ~a -o ~a ~a~%" cc tags temp-file fileout libs)
          (ext:run-shell-command (format nil "~a ~a ~a -o ~a ~a" cc tags temp-file fileout libs))
          (setf *last-compiled* temp-file)))
  
  (defun compile-and-run-cl-file (filein &key args fileout tags libs c-file cc)
      (def fileout "a.out")
      (compile-cl-file filein
        :fileout fileout
        :tags tags
        :libs libs
        :c-file c-file
        :cc cc)
      (format t "Running: ./~a~{~^ ~a~}~%" fileout args)
      (ext:run-shell-command (format nil "./~a~{~^ ~a~}" fileout args)))
  
  
  (compile 'write-out)
  (compile 'change-file)
  
negative.code: (defun write-out (str)
    (if *file-out*
        (with-open-file (stream *file-out* :direction :output :if-exists :append :if-does-not-exist :create)
  	(format stream str))))
  
  (defun change-file (file &optional is-h)
    (setf *exec-out* (c-strify file))
  