anchor.diff:    `(define-transform ,binary-fn ((lhs fixnum) (rhs fixnum))
         ((:result-type ,result)
          (:optimize (= safety 0) (= speed 3)))
  -     (ast `(the fixnum (call ,',fast-fn ,lhs ,rhs)))))
  +     `(the fixnum (call ,',fast-fn ,lhs ,rhs))))
   
   (define-fast-fixnum-transform-arith-two-arg sys.int::binary-+ %fast-fixnum-+)
   (define-fast-fixnum-transform-arith-two-arg sys.int::binary-- %fast-fixnum--)
  
positive.code: (defmethod apply-transforms-1 ((form ast-call) target-architecture)
   (let* ((matching-transform (match-transform form 't target-architecture))
          (new-form (if matching-transform
                        (apply-transform matching-transform (arguments form))
                        nil)))
     (cond (new-form
            (change-made)
  
negative.code: 
  (define-transform float ((number fixnum) (prototype double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(the double-float
          (call mezzano.runtime::%%coerce-fixnum-to-double-float ,number)))
  
  (define-transform sys.int::binary-= ((lhs double-float) (rhs double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(call eq ,lhs ,rhs))
  
  (define-transform sys.int::binary-< ((lhs double-float) (rhs double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(call sys.int::%%double-float-< ,lhs ,rhs))
  
  (define-transform sys.int::binary->= ((lhs double-float) (rhs double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(call not (call sys.int::%%double-float-< ,lhs ,rhs)))
  
  (define-transform sys.int::binary-> ((lhs double-float) (rhs double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(call sys.int::%%double-float-< ,rhs ,lhs))
  
  (define-transform sys.int::binary-<= ((lhs double-float) (rhs double-float))
      ((:optimize (= safety 0) (= speed 3)))
    `(call not (call sys.int::%%double-float-< ,rhs ,lhs)))
  
  ;;; Fast array accesses. Unbounded and may attack at any time.
  ;;; Currently only functional on simple 1d arrays.
  