anchor.diff:  (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))))
  +	(format stream str))))
   
   (defun change-file (file &optional is-h)
     (setf *exec-out* (c-strify file))
  
positive.code: ; Copyright Jonathan Baca, 2016
  
  (defparameter *file-out* nil)
  (defparameter *exec-out* nil)
  
negative.code: (defun cof (x)
    (if (null x) ""
        (if (atom x)
  	  (if (inhash x *c-synonyms*)
  	      (cof (gethash x *c-synonyms*))
  	      (c-strify x))
            (if (atom (car x))
                (case (char (strof (car x)) 0)
  		(#\@ (apply #'call-c (cof (symtrim (car x) 1)) (cdr x)))
  		(#\[ (apply #'nth-c (cof (symtrim (car x) 2)) (cdr x)))
  		(#\% (apply #'addr-c (cof (symtrim (car x) 1)) (cdr x)))
  		(#\^ (apply #'cast-c (cof (symtrim (car x) 1)) (cdr x)))
  		(#\$ (apply #'ptr-c (cof (symtrim (car x) 1)) (cdr x)))
  		(otherwise (apply (addsyms (car x) '-c) (cdr x))))
                (format nil "~{~a~^~(;~%~)~}" (mapcar #'cof x))))))
  
  (defmacro cofy (x) `(setf ,x (cof ,x)))
  (defmacro cofsy (x) `(setf ,x (mapcar #'cof (f/list ,x))))
  
  (defun replacify (vars subs template)
    (labels ((helper (v s temp)
  	     (if (eq temp v) s
  		 (if (atom temp) temp
  		     (mapcar #'(lambda (x) (helper v s x)) temp)))))
      (if (null vars) template
  	(replacify (cdr vars) (cdr subs) (helper (car vars) (car subs) template)))))
  
  (defmacro replacify-lambda (vars template)
    (let ((varlist (loop for i from 1 to (length vars) collect (gensym))))
      `(lambda ,varlist (replacify ',vars (list ,@varlist) ',template))))
  
  ;; ## NOW DEFINE THE C LANGUAGE
  
  (binops (=   :l t :nyms (= set let <- ":="))
          (!=  :l t :nyms (!= neq diff different))
          (==  :r t :nyms (== eq same))
          (<   :r t :nyms (< lt))
          (>   :r t :nyms (> gt))
          (<=  :r t :nyms (<= leq le))
          (>=  :r t :nyms (>= geq ge))
          (&&  :r t :nyms (&& and et und y))
          (&   :r t :nyms (& bit-and band .and bit-et bet .et bit-und bund .und bit-y by .y ))
          (&=  :l t :nyms (&= &-eq bit-and-eq band-eq .and-eq bit-et-eq bet-eq .et-eq bit-und-eq bund-eq
  			    .und-eq bit-y-eq by-eq .y-eq &= bit-and= band= .and= bit-et= bet=
  			    .et= bit-und= bund= .und= bit-y= by= .y= ))
          ("||":r t :nyms (or uel oder o))
          ("|" :r t :nyms (bit-or .or bor bit-uel .uel buel bit-oder .oder boder bit-o .o bo))
          ("|=":l t :nyms (bit-or-eq .or-eq bor-eq bit-uel-eq .uel-eq buel-eq bit-oder-eq
  