
(/VERSIONCHECK 2) 

(DEFUN |MFLOAT;retractIfCan;$U;1| (|u| $)
  (CONS 0
        (SPADCALL (SPADCALL |u| (QREFELT $ 16))
                  (SPADCALL (SPADCALL (QREFELT $ 8) 1 (QREFELT $ 21))
                            (SPADCALL |u| (QREFELT $ 22)) (QREFELT $ 23))
                  (QREFELT $ 24)))) 

(DEFUN |MFLOAT;wholePart;$I;2| (|u| $)
  (PROG (|f| |exp| |man|)
    (RETURN
     (SEQ
      (LETT |man| (SPADCALL |u| (QREFELT $ 16)) . #1=(|MFLOAT;wholePart;$I;2|))
      (LETT |exp| (SPADCALL |u| (QREFELT $ 22)) . #1#)
      (EXIT
       (LETT |f|
             (COND
              ((SPADCALL |exp| (QREFELT $ 28))
               (* |man| (SPADCALL (QREFELT $ 8) |exp| (QREFELT $ 13))))
              ((ZEROP |exp|) |man|)
              ('T
               (SPADCALL
                (SPADCALL |man|
                          (SPADCALL (QREFELT $ 8) (- |exp|) (QREFELT $ 13))
                          (QREFELT $ 21))
                (QREFELT $ 29))))
             . #1#)))))) 

(DEFUN |MFLOAT;normalise| (|u| $)
  (PROG (|man| |exp| |q1| BBF |sgn| BB)
    (RETURN
     (SEQ (LETT |exp| (SPADCALL |u| (QREFELT $ 22)) . #1=(|MFLOAT;normalise|))
          (LETT |man| (SPADCALL |u| (QREFELT $ 16)) . #1#)
          (LETT BB (QREFELT $ 8) . #1#)
          (LETT |sgn| (SPADCALL |man| (QREFELT $ 31)) . #1#)
          (LETT |man| (ABS |man|) . #1#)
          (EXIT
           (COND ((ZEROP |man|) (CONS 0 0))
                 (#2='T
                  (SEQ
                   (COND
                    ((< |man| (QREFELT $ 14))
                     (SEQ G190
                          (COND ((NULL (< |man| (QREFELT $ 14))) #3=(GO G191)))
                          (SEQ (LETT |exp| (- |exp| 1) . #1#)
                               (EXIT (LETT |man| (* |man| BB) . #1#)))
                          NIL #4=(GO G190) G191 (EXIT NIL))))
                   (COND
                    ((< (QREFELT $ 14) |man|)
                     (SEQ (LETT |q1| (SPADCALL |man| 1 (QREFELT $ 21)) . #1#)
                          (LETT BBF (SPADCALL BB 1 (QREFELT $ 21)) . #1#)
                          (SEQ G190
                               (COND
                                ((NULL
                                  (< (QREFELT $ 14)
                                     (SPADCALL |q1| (QREFELT $ 29))))
                                 #3#))
                               (SEQ
                                (LETT |q1| (SPADCALL |q1| BBF (QREFELT $ 34))
                                      . #1#)
                                (EXIT (LETT |exp| (+ |exp| 1) . #1#)))
                               NIL #4# G191 (EXIT NIL))
                          (EXIT
                           (LETT |man| (|MFLOAT;locRound| |q1| $) . #1#)))))
                   (EXIT
                    (COND
                     ((SPADCALL |sgn| (QREFELT $ 28))
                      (|MFLOAT;checkExponent| (CONS |man| |exp|) $))
                     (#2#
                      (|MFLOAT;checkExponent| (CONS (- |man|) |exp|)
                       $)))))))))))) 

(PUT '|MFLOAT;mantissa;$I;4| '|SPADreplace| 'QCAR) 

(DEFUN |MFLOAT;mantissa;$I;4| (|u| $) (QCAR |u|)) 

(PUT '|MFLOAT;exponent;$I;5| '|SPADreplace| 'QCDR) 

(DEFUN |MFLOAT;exponent;$I;5| (|u| $) (QCDR |u|)) 

(DEFUN |MFLOAT;newPower| (|base| |prec| $)
  (PROG (|power| |current| |target|)
    (RETURN
     (SEQ (LETT |power| 1 . #1=(|MFLOAT;newPower|))
          (LETT |target| (SPADCALL 10 |prec| (QREFELT $ 13)) . #1#)
          (LETT |current| (SPADCALL (QREFELT $ 35)) . #1#)
          (SEQ G190
               (COND
                ((NULL
                  (<
                   (LETT |current| (* |current| (SPADCALL (QREFELT $ 35)))
                         . #1#)
                   |target|))
                 (GO G191)))
               (SEQ (EXIT (LETT |power| (+ |power| 1) . #1#))) NIL (GO G190)
               G191 (EXIT NIL))
          (SETELT $ 11 |power|)
          (SETELT $ 14 (SPADCALL (QREFELT $ 8) (QREFELT $ 11) (QREFELT $ 13)))
          (EXIT (SPADCALL (QREFELT $ 38))))))) 

(DEFUN |MFLOAT;changeBase;2IPi$;7| (|exp| |man| |base| $)
  (PROG (|newMan| |f| |newExp| BB |sign|)
    (RETURN
     (SEQ (LETT |newExp| 0 . #1=(|MFLOAT;changeBase;2IPi$;7|))
          (LETT |f|
                (SPADCALL |man|
                          (SPADCALL (SPADCALL 2 (QREFELT $ 39)) |exp|
                                    (QREFELT $ 23))
                          (QREFELT $ 24))
                . #1#)
          (LETT |sign| (SPADCALL |f| (QREFELT $ 40)) . #1#)
          (LETT |f| (SPADCALL |f| (QREFELT $ 41)) . #1#)
          (LETT |newMan| (SPADCALL |f| (QREFELT $ 29)) . #1#)
          (EXIT
           (COND ((SPADCALL |f| (QREFELT $ 42)) (CONS 0 0))
                 ('T
                  (SEQ (LETT BB (SPADCALL (QREFELT $ 8) (QREFELT $ 39)) . #1#)
                       (COND
                        ((< |newMan| (QREFELT $ 14))
                         (SEQ G190
                              (COND
                               ((NULL (< |newMan| (QREFELT $ 14)))
                                #2=(GO G191)))
                              (SEQ (LETT |newExp| (- |newExp| 1) . #1#)
                                   (LETT |f| (SPADCALL |f| BB (QREFELT $ 43))
                                         . #1#)
                                   (EXIT
                                    (LETT |newMan|
                                          (SPADCALL |f| (QREFELT $ 29))
                                          . #1#)))
                              NIL #3=(GO G190) G191 (EXIT NIL))))
                       (COND
                        ((< (QREFELT $ 14) |newMan|)
                         (SEQ G190
                              (COND ((NULL (< (QREFELT $ 14) |newMan|)) #2#))
                              (SEQ (LETT |newExp| (+ |newExp| 1) . #1#)
                                   (LETT |f| (SPADCALL |f| BB (QREFELT $ 34))
                                         . #1#)
                                   (EXIT
                                    (LETT |newMan|
                                          (SPADCALL |f| (QREFELT $ 29))
                                          . #1#)))
                              NIL #3# G191 (EXIT NIL))))
                       (EXIT (CONS (* |sign| |newMan|) |newExp|)))))))))) 

(DEFUN |MFLOAT;checkExponent| (|u| $)
  (PROG (|message|)
    (RETURN
     (SEQ
      (COND
       ((OR (< (SPADCALL |u| (QREFELT $ 22)) (QREFELT $ 9))
            (< (QREFELT $ 10) (SPADCALL |u| (QREFELT $ 22))))
        (SEQ
         (LETT |message|
               (SPADCALL
                (LIST "Exponent out of range: " (STRINGIMAGE (QREFELT $ 9))
                      ".." (STRINGIMAGE (QREFELT $ 10)))
                (QREFELT $ 47))
               |MFLOAT;checkExponent|)
         (EXIT (|error| (SPADCALL |message| (QREFELT $ 49))))))
       ('T |u|)))))) 

(DEFUN |MFLOAT;coerce;$Of;9| (|u| $)
  (SPADCALL (SPADCALL |u| (QREFELT $ 50)) (QREFELT $ 51))) 

(DEFUN |MFLOAT;coerce;Mi$;10| (|u| $)
  (|MFLOAT;checkExponent|
   (SPADCALL 0 (SPADCALL |u| (QREFELT $ 54)) 10 (QREFELT $ 44)) $)) 

(DEFUN |MFLOAT;coerce;$F;11| (|u| $)
  (PROG (|r| |oldDigits|)
    (RETURN
     (SEQ
      (LETT |oldDigits| (SPADCALL (QREFELT $ 7) (QREFELT $ 56))
            . #1=(|MFLOAT;coerce;$F;11|))
      (LETT |r|
            (SPADCALL (SPADCALL |u| (QREFELT $ 16))
                      (SPADCALL |u| (QREFELT $ 22)) (QREFELT $ 8)
                      (QREFELT $ 57))
            . #1#)
      (SPADCALL |oldDigits| (QREFELT $ 56)) (EXIT |r|))))) 

(DEFUN |MFLOAT;coerce;F$;12| (|u| $)
  (|MFLOAT;checkExponent|
   (SPADCALL (SPADCALL |u| (QREFELT $ 58)) (SPADCALL |u| (QREFELT $ 59))
             (SPADCALL (QREFELT $ 36)) (QREFELT $ 44))
   $)) 

(DEFUN |MFLOAT;coerce;I$;13| (|u| $)
  (|MFLOAT;checkExponent| (SPADCALL 0 |u| 10 (QREFELT $ 44)) $)) 

(DEFUN |MFLOAT;coerce;F$;14| (|u| $)
  (SPADCALL (SPADCALL (SPADCALL |u| (QREFELT $ 62)) (QREFELT $ 63))
            (SPADCALL (SPADCALL |u| (QREFELT $ 64)) (QREFELT $ 63))
            (QREFELT $ 65))) 

(DEFUN |MFLOAT;retract;$F;15| (|u| $)
  (PROG (|value|)
    (RETURN
     (SEQ (LETT |value| (SPADCALL |u| (QREFELT $ 26)) |MFLOAT;retract;$F;15|)
          (EXIT
           (COND
            ((QEQCAR |value| 1)
             (|error| "Cannot retract to a Fraction Integer"))
            ('T (QCDR |value|)))))))) 

(DEFUN |MFLOAT;retract;$F;16| (|u| $) (SPADCALL |u| (QREFELT $ 50))) 

(DEFUN |MFLOAT;retractIfCan;$U;17| (|u| $)
  (CONS 0 (SPADCALL |u| (QREFELT $ 50)))) 

(DEFUN |MFLOAT;retractIfCan;$U;18| (|u| $)
  (PROG (|value|)
    (RETURN
     (SEQ
      (LETT |value|
            (SPADCALL (SPADCALL |u| (QREFELT $ 16))
                      (SPADCALL (SPADCALL (QREFELT $ 8) (QREFELT $ 39))
                                (SPADCALL |u| (QREFELT $ 22)) (QREFELT $ 23))
                      (QREFELT $ 24))
            |MFLOAT;retractIfCan;$U;18|)
      (EXIT
       (COND
        ((SPADCALL (SPADCALL |value| (QREFELT $ 71)) (QREFELT $ 42))
         (CONS 0 (SPADCALL |value| (QREFELT $ 29))))
        ('T (CONS 1 "failed")))))))) 

(DEFUN |MFLOAT;retract;$I;19| (|u| $)
  (PROG (#1=#:G1899 |result|)
    (RETURN
     (SEQ
      (LETT |result| (SPADCALL |u| (QREFELT $ 73))
            . #2=(|MFLOAT;retract;$I;19|))
      (EXIT
       (COND
        ((SPADCALL |result| (CONS 1 "failed") (QREFELT $ 74))
         (|error| "Not an Integer"))
        ('T
         (PROG2
             (LETT #1# |result| . #2#)
             (QCDR #1#)
           (|check-union| (QEQCAR #1# 0) (|Integer|) #1#))))))))) 

(DEFUN |MFLOAT;precision;2Pi;20| (|p| $)
  (PROG (|old|)
    (RETURN
     (SEQ (LETT |old| (QREFELT $ 7) |MFLOAT;precision;2Pi;20|)
          (|MFLOAT;newPower| (QREFELT $ 8) |p| $) (SETELT $ 7 |p|)
          (EXIT |old|))))) 

(DEFUN |MFLOAT;precision;Pi;21| ($) (QREFELT $ 7)) 

(DEFUN |MFLOAT;base;2Pi;22| (|b| $)
  (PROG (|old|)
    (RETURN
     (SEQ (LETT |old| |b| |MFLOAT;base;2Pi;22|)
          (|MFLOAT;newPower| |b| (QREFELT $ 7) $) (SETELT $ 8 |b|)
          (EXIT |old|))))) 

(DEFUN |MFLOAT;base;Pi;23| ($) (QREFELT $ 8)) 

(DEFUN |MFLOAT;maximumExponent;2I;24| (|u| $)
  (PROG (|old|)
    (RETURN
     (SEQ (LETT |old| (QREFELT $ 10) |MFLOAT;maximumExponent;2I;24|)
          (SETELT $ 10 |u|) (EXIT |old|))))) 

(DEFUN |MFLOAT;maximumExponent;I;25| ($) (QREFELT $ 10)) 

(DEFUN |MFLOAT;minimumExponent;2I;26| (|u| $)
  (PROG (|old|)
    (RETURN
     (SEQ (LETT |old| (QREFELT $ 9) |MFLOAT;minimumExponent;2I;26|)
          (SETELT $ 9 |u|) (EXIT |old|))))) 

(DEFUN |MFLOAT;minimumExponent;I;27| ($) (QREFELT $ 9)) 

(PUT '|MFLOAT;Zero;$;28| '|SPADreplace| '(XLAM NIL (CONS 0 0))) 

(DEFUN |MFLOAT;Zero;$;28| ($) (CONS 0 0)) 

(DEFUN |MFLOAT;One;$;29| ($) (SPADCALL 0 1 10 (QREFELT $ 44))) 

(DEFUN |MFLOAT;zero?;$B;30| (|u| $) (SPADCALL |u| (CONS 0 0) (QREFELT $ 83))) 

(DEFUN |MFLOAT;locRound| (|x| $)
  (COND
   ((NULL
     (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 71)) (QREFELT $ 41))
               (SPADCALL 1 2 (QREFELT $ 21)) (QREFELT $ 85)))
    (+ (SPADCALL |x| (QREFELT $ 29)) (SPADCALL |x| (QREFELT $ 40))))
   ('T (SPADCALL |x| (QREFELT $ 29))))) 

(DEFUN |MFLOAT;recip;$U;32| (|f1| $)
  (COND ((SPADCALL |f1| (QREFELT $ 84)) (CONS 1 "failed"))
        ('T
         (CONS 0
               (|MFLOAT;normalise|
                (CONS
                 (|MFLOAT;locRound|
                  (SPADCALL
                   (SPADCALL (QREFELT $ 8) (* 2 (QREFELT $ 11)) (QREFELT $ 13))
                   (SPADCALL |f1| (QREFELT $ 16)) (QREFELT $ 21))
                  $)
                 (- (+ (SPADCALL |f1| (QREFELT $ 22)) (* 2 (QREFELT $ 11)))))
                $))))) 

(DEFUN |MFLOAT;*;3$;33| (|f1| |f2| $)
  (|MFLOAT;normalise|
   (CONS (* (SPADCALL |f1| (QREFELT $ 16)) (SPADCALL |f2| (QREFELT $ 16)))
         (+ (SPADCALL |f1| (QREFELT $ 22)) (SPADCALL |f2| (QREFELT $ 22))))
   $)) 

(DEFUN |MFLOAT;^;$F$;34| (|f1| |p| $)
  (SPADCALL (SPADCALL (SPADCALL |f1| (QREFELT $ 50)) |p| (QREFELT $ 89))
            (QREFELT $ 60))) 

(DEFUN |MFLOAT;/;3$;35| (|f1| |f2| $)
  (COND ((SPADCALL |f2| (QREFELT $ 84)) (|error| "division by zero"))
        ((SPADCALL |f1| (QREFELT $ 84)) (|spadConstant| $ 32))
        ((SPADCALL |f1| |f2| (QREFELT $ 83)) (|spadConstant| $ 17))
        ('T
         (|MFLOAT;normalise|
          (CONS
           (|MFLOAT;locRound|
            (SPADCALL
             (* (SPADCALL |f1| (QREFELT $ 16))
                (SPADCALL (QREFELT $ 8) (* 2 (QREFELT $ 11)) (QREFELT $ 13)))
             (SPADCALL |f2| (QREFELT $ 16)) (QREFELT $ 21))
            $)
           (- (SPADCALL |f1| (QREFELT $ 22))
              (+ (SPADCALL |f2| (QREFELT $ 22)) (* 2 (QREFELT $ 11)))))
          $)))) 

(DEFUN |MFLOAT;inv;2$;36| (|f1| $)
  (SPADCALL (|spadConstant| $ 17) |f1| (QREFELT $ 65))) 

(DEFUN |MFLOAT;exquo;2$U;37| (|f1| |f2| $)
  (CONS 0 (SPADCALL |f1| |f2| (QREFELT $ 65)))) 

(DEFUN |MFLOAT;divide;2$R;38| (|f1| |f2| $)
  (CONS (SPADCALL |f1| |f2| (QREFELT $ 65)) (|spadConstant| $ 32))) 

(DEFUN |MFLOAT;quo;3$;39| (|f1| |f2| $) (SPADCALL |f1| |f2| (QREFELT $ 65))) 

(DEFUN |MFLOAT;rem;3$;40| (|f1| |f2| $) (|spadConstant| $ 32)) 

(DEFUN |MFLOAT;*;I2$;41| (|u| |f1| $)
  (|MFLOAT;normalise|
   (CONS (* |u| (SPADCALL |f1| (QREFELT $ 16))) (SPADCALL |f1| (QREFELT $ 22)))
   $)) 

(DEFUN |MFLOAT;=;2$B;42| (|f1| |f2| $)
  (COND
   ((EQL (SPADCALL |f1| (QREFELT $ 16)) (SPADCALL |f2| (QREFELT $ 16)))
    (EQL (SPADCALL |f1| (QREFELT $ 22)) (SPADCALL |f2| (QREFELT $ 22))))
   ('T 'NIL))) 

(DEFUN |MFLOAT;+;3$;43| (|f1| |f2| $)
  (PROG (|e2| |e1| |m2| |m1|)
    (RETURN
     (SEQ (LETT |m1| (SPADCALL |f1| (QREFELT $ 16)) . #1=(|MFLOAT;+;3$;43|))
          (LETT |m2| (SPADCALL |f2| (QREFELT $ 16)) . #1#)
          (LETT |e1| (SPADCALL |f1| (QREFELT $ 22)) . #1#)
          (LETT |e2| (SPADCALL |f2| (QREFELT $ 22)) . #1#)
          (EXIT
           (COND
            ((< |e2| |e1|)
             (COND
              ((< (+ (+ |e2| (QREFELT $ 11)) 2) |e1|)
               (COND ((SPADCALL |f1| (QREFELT $ 84)) |f2|) (#2='T |f1|)))
              (#2#
               (|MFLOAT;normalise|
                (CONS (+ (* |m1| (EXPT (QREFELT $ 8) (- |e1| |e2|))) |m2|)
                      |e2|)
                $))))
            ((< (+ (+ |e1| (QREFELT $ 11)) 2) |e2|)
             (COND ((SPADCALL |f2| (QREFELT $ 84)) |f1|) (#2# |f2|)))
            (#2#
             (|MFLOAT;normalise|
              (CONS (+ (* |m2| (EXPT (QREFELT $ 8) (- |e2| |e1|))) |m1|) |e1|)
              $)))))))) 

(DEFUN |MFLOAT;-;2$;44| (|f1| $)
  (CONS (- (SPADCALL |f1| (QREFELT $ 16))) (SPADCALL |f1| (QREFELT $ 22)))) 

(DEFUN |MFLOAT;-;3$;45| (|f1| |f2| $)
  (SPADCALL |f1| (SPADCALL |f2| (QREFELT $ 99)) (QREFELT $ 98))) 

(DEFUN |MFLOAT;<;2$B;46| (|f1| |f2| $)
  (PROG (|e2| |e1| |m2| |m1|)
    (RETURN
     (SEQ (LETT |m1| (SPADCALL |f1| (QREFELT $ 16)) . #1=(|MFLOAT;<;2$B;46|))
          (LETT |m2| (SPADCALL |f2| (QREFELT $ 16)) . #1#)
          (LETT |e1| (SPADCALL |f1| (QREFELT $ 22)) . #1#)
          (LETT |e2| (SPADCALL |f2| (QREFELT $ 22)) . #1#)
          (EXIT
           (COND
            ((EQL (SPADCALL |m1| (QREFELT $ 31))
                  (SPADCALL |m2| (QREFELT $ 31)))
             (COND ((< |e1| |e2|) 'T)
                   (#2='T
                    (SEQ
                     (COND ((EQL |e1| |e2|) (COND ((< |m1| |m2|) (EXIT 'T)))))
                     (EXIT 'NIL)))))
            ((EQL (SPADCALL |m1| (QREFELT $ 31)) 1) 'NIL)
            (#2#
             (SEQ
              (COND
               ((EQL (SPADCALL |m1| (QREFELT $ 31)) 0)
                (COND ((EQL (SPADCALL |m2| (QREFELT $ 31)) -1) (EXIT 'NIL)))))
              (EXIT 'T))))))))) 

(PUT '|MFLOAT;characteristic;Nni;47| '|SPADreplace| '(XLAM NIL 0)) 

(DEFUN |MFLOAT;characteristic;Nni;47| ($) 0) 

(DEFUN |MachineFloat| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G1986)
       (RETURN
        (COND
         ((LETT #2# (HGET |$ConstructorCache| '|MachineFloat|)
                . #3=(|MachineFloat|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|MachineFloat|
                         (LIST (CONS NIL (CONS 1 (|MachineFloat;|))))))
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#) (HREM |$ConstructorCache| '|MachineFloat|))))))))))) 

(DEFUN |MachineFloat;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|MachineFloat|) . #1=(|MachineFloat|))
      (LETT $ (GETREFV 116) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|MachineFloat| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (AND (|HasCategory| $ '(|arbitraryPrecision|)) (|augmentPredVector| $ 1))
      (AND (|not| (|HasCategory| $ '(|arbitraryExponent|)))
           (|not| (|HasCategory| $ '(|arbitraryPrecision|)))
           (|augmentPredVector| $ 2))
      (QSETREFV $ 6
                (|Record| (|:| |mantissa| (|Integer|))
                          (|:| |exponent| (|Integer|))))
      (QSETREFV $ 7 16)
      (QSETREFV $ 8 2)
      (QSETREFV $ 9 -1021)
      (QSETREFV $ 10 1024)
      (QSETREFV $ 11 53)
      (QSETREFV $ 14 (SPADCALL (QREFELT $ 8) (QREFELT $ 11) (QREFELT $ 13)))
      $)))) 

(MAKEPROP '|MachineFloat| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL '|Rep| 'P 'B 'EMIN 'EMAX 'POWER
              (|PositiveInteger|) (0 . ^) 'MMAX (|Integer|)
              |MFLOAT;mantissa;$I;4|
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |MFLOAT;One;$;29|) $))
              (|Float|) (6 . |One|) (|Fraction| 15) (10 . /)
              |MFLOAT;exponent;$I;5| (16 . ^) (22 . *) (|Union| 20 '"failed")
              |MFLOAT;retractIfCan;$U;1| (|Boolean|) (28 . |positive?|)
              (33 . |wholePart|) |MFLOAT;wholePart;$I;2| (38 . |sign|)
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |MFLOAT;Zero;$;28|) $))
              (43 . |Zero|) (47 . /) |MFLOAT;base;Pi;23| (53 . |base|) (|Void|)
              (57 . |void|) (61 . |coerce|) (66 . |sign|) (71 . |abs|)
              (76 . |zero?|) (81 . *) |MFLOAT;changeBase;2IPi$;7| (|List| $)
              (|String|) (87 . |concat|) (|OutputForm|) (92 . |coerce|)
              |MFLOAT;coerce;$F;11| (97 . |coerce|) |MFLOAT;coerce;$Of;9|
              (|MachineInteger|) (102 . |retract|) |MFLOAT;coerce;Mi$;10|
              (107 . |digits|) (112 . |float|) (119 . |exponent|)
              (124 . |mantissa|) |MFLOAT;coerce;F$;12| (129 . |coerce|)
              (134 . |numer|) |MFLOAT;coerce;I$;13| (139 . |denom|)
              |MFLOAT;/;3$;35| |MFLOAT;coerce;F$;14| |MFLOAT;retract;$F;15|
              |MFLOAT;retract;$F;16| (|Union| 18 '"failed")
              |MFLOAT;retractIfCan;$U;17| (144 . |fractionPart|)
              (|Union| 15 '"failed") |MFLOAT;retractIfCan;$U;18| (149 . =)
              |MFLOAT;retract;$I;19| |MFLOAT;precision;2Pi;20|
              |MFLOAT;precision;Pi;21| |MFLOAT;base;2Pi;22|
              |MFLOAT;maximumExponent;2I;24| |MFLOAT;maximumExponent;I;25|
              |MFLOAT;minimumExponent;2I;26| |MFLOAT;minimumExponent;I;27|
              |MFLOAT;=;2$B;42| |MFLOAT;zero?;$B;30| (155 . <)
              (|Union| $ '"failed") |MFLOAT;recip;$U;32| |MFLOAT;*;3$;33|
              (161 . ^) |MFLOAT;^;$F$;34| |MFLOAT;inv;2$;36|
              |MFLOAT;exquo;2$U;37|
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              |MFLOAT;divide;2$R;38| |MFLOAT;quo;3$;39| |MFLOAT;rem;3$;40|
              |MFLOAT;*;I2$;41| |MFLOAT;+;3$;43| |MFLOAT;-;2$;44|
              |MFLOAT;-;3$;45| |MFLOAT;<;2$B;46| (|NonNegativeInteger|)
              |MFLOAT;characteristic;Nni;47| (|PatternMatchResult| 18 $)
              (|Pattern| 18) (|DoubleFloat|) (|Factored| $)
              (|Record| (|:| |coef1| $) (|:| |coef2| $))
              (|Union| 108 '#1="failed") (|Union| 45 '#1#)
              (|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $))
              (|Record| (|:| |coef| 45) (|:| |generator| $))
              (|SparseUnivariatePolynomial| $)
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (|SingleInteger|))
           '#(~= 167 |zero?| 173 |wholePart| 178 |unitNormal| 183
              |unitCanonical| 188 |unit?| 193 |truncate| 198 |subtractIfCan|
              203 |squareFreePart| 209 |squareFree| 214 |sqrt| 219 |smaller?|
              224 |sizeLess?| 230 |sign| 236 |sample| 241 |round| 245
              |retractIfCan| 250 |retract| 265 |rem| 280 |recip| 286 |quo| 291
              |principalIdeal| 297 |prime?| 302 |precision| 307 |positive?| 316
              |patternMatch| 321 |order| 328 |one?| 333 |nthRoot| 338 |norm|
              344 |negative?| 349 |multiEuclidean| 354 |minimumExponent| 360
              |min| 369 |maximumExponent| 379 |max| 388 |mantissa| 398 |lcm|
              403 |latex| 414 |inv| 419 |increasePrecision| 424 |hash| 429
              |gcdPolynomial| 434 |gcd| 440 |fractionPart| 451 |floor| 456
              |float| 461 |factor| 474 |extendedEuclidean| 479 |exquo| 492
              |expressIdealMember| 498 |exponent| 504 |euclideanSize| 509
              |divide| 514 |digits| 520 |decreasePrecision| 529 |convert| 534
              |coerce| 549 |characteristic| 594 |changeBase| 598 |ceiling| 605
              |bits| 610 |base| 619 |associates?| 628 |abs| 634 ^ 639 |Zero|
              663 |One| 667 >= 671 > 677 = 683 <= 689 < 695 / 701 - 707 + 718 *
              724)
           'NIL
           (CONS
            (|makeByteWordVec2| 1
                                '(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                                  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                                  0 0 0 0 0 0 0 0 0 0 0 0))
            (CONS
             '#(|FloatingPointSystem&| |RealNumberSystem&| |Field&|
                |EuclideanDomain&| NIL |UniqueFactorizationDomain&| NIL
                |GcdDomain&| |DivisionRing&| |IntegralDomain&| |Algebra&|
                |Algebra&| NIL |OrderedRing&| |Module&| NIL NIL |Module&| NIL
                NIL NIL |Ring&| NIL NIL NIL NIL NIL NIL NIL |AbelianGroup&| NIL
                NIL NIL |OrderedSet&| |AbelianMonoid&| |Monoid&| NIL NIL NIL
                |SemiGroup&| |AbelianSemiGroup&| NIL |SetCategory&|
                |RetractableTo&| NIL NIL |RadicalCategory&| |RetractableTo&|
                |RetractableTo&| NIL NIL NIL NIL NIL NIL NIL |BasicType&| NIL)
             (CONS
              '#((|FloatingPointSystem|) (|RealNumberSystem|) (|Field|)
                 (|EuclideanDomain|) (|PrincipalIdealDomain|)
                 (|UniqueFactorizationDomain|) (|FortranMachineTypeCategory|)
                 (|GcdDomain|) (|DivisionRing|) (|IntegralDomain|)
                 (|Algebra| 20) (|Algebra| $$) (|CharacteristicZero|)
                 (|OrderedRing|) (|Module| 20) (|EntireRing|)
                 (|CommutativeRing|) (|Module| $$) (|OrderedAbelianGroup|)
                 (|BiModule| 20 20) (|BiModule| $$ $$) (|Ring|)
                 (|OrderedCancellationAbelianMonoid|) (|RightModule| 20)
                 (|LeftModule| 20) (|LeftModule| $$) (|Rng|) (|RightModule| $$)
                 (|OrderedAbelianMonoid|) (|AbelianGroup|)
                 (|OrderedAbelianSemiGroup|) (|CancellationAbelianMonoid|)
                 (|SemiRing|) (|OrderedSet|) (|AbelianMonoid|) (|Monoid|)
                 (|SemiRng|) (|PatternMatchable| 18) (|Comparable|)
                 (|SemiGroup|) (|AbelianSemiGroup|) (|RealConstant|)
                 (|SetCategory|) (|RetractableTo| 18) (|Approximate|)
                 (|ConvertibleTo| 105) (|RadicalCategory|) (|RetractableTo| 20)
                 (|RetractableTo| 15) (|ConvertibleTo| 18)
                 (|ConvertibleTo| 106) (|canonicalsClosed|)
                 (|canonicalUnitNormal|) (|noZeroDivisors|) (|CommutativeStar|)
                 (|unitsKnown|) (|BasicType|) (|CoercibleTo| 48))
              (|makeByteWordVec2| 115
                                  '(2 12 0 0 12 13 0 18 0 19 2 20 0 15 15 21 2
                                    20 0 0 15 23 2 20 0 15 0 24 1 15 27 0 28 1
                                    20 15 0 29 1 15 15 0 31 0 18 0 33 2 20 0 0
                                    0 34 0 18 12 36 0 37 0 38 1 20 0 15 39 1 20
                                    15 0 40 1 20 0 0 41 1 20 27 0 42 2 20 0 0 0
                                    43 1 46 0 45 47 1 46 48 0 49 1 18 48 0 51 1
                                    53 15 0 54 1 18 12 12 56 3 18 0 15 15 12 57
                                    1 18 15 0 58 1 18 15 0 59 1 0 0 15 61 1 20
                                    15 0 62 1 20 15 0 64 1 20 0 0 71 2 72 27 0
                                    0 74 2 20 27 0 0 85 2 18 0 0 20 89 2 0 27 0
                                    0 1 1 0 27 0 84 1 0 15 0 30 1 0 114 0 1 1 0
                                    0 0 1 1 0 27 0 1 1 0 0 0 1 2 0 86 0 0 1 1 0
                                    0 0 1 1 0 107 0 1 1 0 0 0 1 2 0 27 0 0 1 2
                                    0 27 0 0 1 1 0 15 0 1 0 0 0 1 1 0 0 0 1 1 0
                                    69 0 70 1 0 25 0 26 1 0 72 0 73 1 0 18 0 68
                                    1 0 20 0 67 1 0 15 0 75 2 0 0 0 0 96 1 0 86
                                    0 87 2 0 0 0 0 95 1 0 112 45 1 1 0 27 0 1 1
                                    0 12 12 76 0 0 12 77 1 0 27 0 1 3 0 104 0
                                    105 104 1 1 0 15 0 1 1 0 27 0 1 2 0 0 0 15
                                    1 1 0 0 0 1 1 0 27 0 1 2 0 110 45 0 1 1 0
                                    15 15 81 0 0 15 82 0 2 0 1 2 0 0 0 0 1 1 0
                                    15 15 79 0 0 15 80 0 2 0 1 2 0 0 0 0 1 1 0
                                    15 0 16 1 0 0 45 1 2 0 0 0 0 1 1 0 46 0 1 1
                                    0 0 0 91 1 1 12 15 1 1 0 115 0 1 2 0 113
                                    113 113 1 1 0 0 45 1 2 0 0 0 0 1 1 0 0 0 1
                                    1 0 0 0 1 3 0 0 15 15 12 1 2 0 0 15 15 1 1
                                    0 107 0 1 3 0 109 0 0 0 1 2 0 111 0 0 1 2 0
                                    86 0 0 92 2 0 110 45 0 1 1 0 15 0 22 1 0
                                    102 0 1 2 0 93 0 0 94 1 1 12 12 1 0 0 12 1
                                    1 1 12 15 1 1 0 105 0 1 1 0 18 0 1 1 0 106
                                    0 1 1 0 18 0 50 1 0 0 53 55 1 0 0 18 60 1 0
                                    0 20 66 1 0 0 15 63 1 0 0 20 66 1 0 0 0 1 1
                                    0 0 15 63 1 0 48 0 52 0 0 102 103 3 0 0 15
                                    15 12 44 1 0 0 0 1 1 1 12 12 1 0 0 12 1 1 0
                                    12 12 78 0 0 12 35 2 0 27 0 0 1 1 0 0 0 1 2
                                    0 0 0 20 90 2 0 0 0 15 1 2 0 0 0 102 1 2 0
                                    0 0 12 1 0 0 0 32 0 0 0 17 2 0 27 0 0 1 2 0
                                    27 0 0 1 2 0 27 0 0 83 2 0 27 0 0 1 2 0 27
                                    0 0 101 2 0 0 0 0 65 2 0 0 0 0 100 1 0 0 0
                                    99 2 0 0 0 0 98 2 0 0 20 0 1 2 0 0 0 20 1 2
                                    0 0 15 0 97 2 0 0 0 0 88 2 0 0 102 0 1 2 0
                                    0 12 0 1)))))
           '|lookupComplete|)) 

(MAKEPROP '|MachineFloat| 'NILADIC T) 
