anchor.diff:    `(progn
        (define-transform sys.int::aref-1 ((array (simple-array ,type (*))) index)
            ((:optimize (= safety 0) (= speed 3)))
  -       (ast `(the ,',type (call ,',accessor ,array ,index))))
  +       `(the ,',type (call ,',accessor ,array ,index)))
        (define-transform (setf sys.int::aref-1) (value (array (simple-array ,type (*))) index)
            ((:optimize (= safety 0) (= speed 3)))
  -       (ast `(the ,',type (call (setf ,',accessor) ,value ,array ,index))))))
  +       `(the ,',type (call (setf ,',accessor) ,value ,array ,index)))))
   
   (define-fast-array-transform t sys.int::%object-ref-t)
   (define-fast-array-transform fixnum sys.int::%object-ref-t)
  
positive.code: (define-transform length ((sequence (and (simple-array * (*))
                                           (not (simple-array character (*))))))
      ((:optimize (= safety 0) (= speed 3)))
    (ast `(the (integer 0 ,array-dimension-limit) (call sys.int::%object-header-data ,sequence))))
  
  ;;; Misc transforms.
  
  
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.
  