
(/VERSIONCHECK 2) 

(DEFUN |REAL0;negate| (|int| $)
  (CONS (SPADCALL (QCDR |int|) (QREFELT $ 8))
        (SPADCALL (QCAR |int|) (QREFELT $ 8)))) 

(DEFUN |REAL0;midpoint;RF;2| (|i| $)
  (SPADCALL (SPADCALL 1 2 (QREFELT $ 12))
      (SPADCALL (QCAR |i|) (QCDR |i|) (QREFELT $ 13)) (QREFELT $ 14))) 

(DEFUN |REAL0;midpoints;LL;3| (|li| $)
  (PROG (#0=#:G1832 |x| #1=#:G1833)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|REAL0;midpoints;LL;3|))
             (SEQ (LETT |x| NIL . #2#) (LETT #1# |li| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |x| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (SPADCALL |x| (QREFELT $ 16))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |REAL0;makeSqfr| (F $)
  (PROG (|sqfr| |s| #0=#:G1842 #1=#:G1839 #2=#:G1837 #3=#:G1838)
    (RETURN
      (SEQ (LETT |sqfr| (SPADCALL F (QREFELT $ 21))
                 . #4=(|REAL0;makeSqfr|))
           (EXIT (LETT F
                       (PROGN
                         (LETT #3# NIL . #4#)
                         (SEQ (LETT |s| NIL . #4#)
                              (LETT #0#
                                    (SPADCALL |sqfr| (QREFELT $ 25)) . #4#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |s| (CAR #0#) . #4#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (PROGN
                                      (LETT #1# (QCAR |s|) . #4#)
                                      (COND
                                        (#3#
                                         (LETT #2#
                                          (SPADCALL #2# #1#
                                           (QREFELT $ 26)) . #4#))
                                        ('T
                                         (PROGN
                                           (LETT #2# #1# . #4#)
                                           (LETT #3# 'T . #4#)))))))
                              (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                              (EXIT NIL))
                         (COND (#3# #2#) ('T (|spadConstant| $ 9)))) . #4#)))))) 

(DEFUN |REAL0;realZeros;PolL;5| (F $)
  (|REAL0;ReZeroSqfr| (|REAL0;makeSqfr| F $) $)) 

(DEFUN |REAL0;realZeros;PolFL;6| (F |rn| $)
  (PROG (#0=#:G1847 |int| #1=#:G1848)
    (RETURN
      (SEQ (LETT F (|REAL0;makeSqfr| F $)
                 . #2=(|REAL0;realZeros;PolFL;6|))
           (EXIT (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |int| NIL . #2#)
                        (LETT #1# (|REAL0;ReZeroSqfr| F $) . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |int| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL F |int| |rn|
                                      (QREFELT $ 28))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#))))))))) 

(DEFUN |REAL0;realZeros;PolRL;7| (F |bounds| $)
  (PROG (#0=#:G1858 |int| #1=#:G1859 |rint| #2=#:G1853)
    (RETURN
      (SEQ (LETT F (|REAL0;makeSqfr| F $)
                 . #3=(|REAL0;realZeros;PolRL;7|))
           (EXIT (PROGN
                   (LETT #0# NIL . #3#)
                   (SEQ (LETT |int| NIL . #3#)
                        (LETT #1# (|REAL0;ReZeroSqfr| F $) . #3#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |int| (CAR #1#) . #3#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (COND
                                     ((QEQCAR
                                       (LETT |rint|
                                        (SPADCALL F |int| |bounds|
                                         (QREFELT $ 31)) . #3#)
                                       0)
                                      (LETT #0#
                                       (CONS
                                        (PROG2 (LETT #2# |rint| . #3#)
                                         (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 0)
                                           (|Record|
                                            (|:| |left|
                                             (|Fraction| (|Integer|)))
                                            (|:| |right|
                                             (|Fraction| (|Integer|))))
                                           #2#))
                                        #0#) . #3#)))))
                        (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#))))))))) 

(DEFUN |REAL0;realZeros;PolRFL;8| (F |bounds| |rn| $)
  (PROG (#0=#:G1863 |int| #1=#:G1864)
    (RETURN
      (SEQ (LETT F (|REAL0;makeSqfr| F $)
                 . #2=(|REAL0;realZeros;PolRFL;8|))
           (EXIT (PROGN
                   (LETT #0# NIL . #2#)
                   (SEQ (LETT |int| NIL . #2#)
                        (LETT #1#
                              (SPADCALL F |bounds| (QREFELT $ 32)) . #2#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |int| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL F |int| |rn|
                                      (QREFELT $ 28))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#))))))))) 

(DEFUN |REAL0;ReZeroSqfr| (F $)
  (PROG (|r| L |tempF| #0=#:G1877 |int| #1=#:G1878 J K)
    (RETURN
      (SEQ (COND
             ((SPADCALL F (|spadConstant| $ 34) (QREFELT $ 36))
              (|error| "ReZeroSqfr: zero polynomial"))
             ('T
              (SEQ (LETT L NIL . #2=(|REAL0;ReZeroSqfr|))
                   (EXIT (COND
                           ((EQL (SPADCALL F (QREFELT $ 38)) 0) L)
                           ('T
                            (SEQ (SEQ (LETT |r|
                                       (SPADCALL F (QREFELT $ 39)) . #2#)
                                      (EXIT
                                       (COND
                                         ((< 0 |r|)
                                          (SEQ
                                           (LETT L
                                            (LIST
                                             (CONS
                                              (|spadConstant| $ 40)
                                              (|spadConstant| $ 40))) . #2#)
                                           (LETT |tempF|
                                            (SPADCALL F
                                             (SPADCALL 1 |r|
                                              (QREFELT $ 41))
                                             (QREFELT $ 43)) . #2#)
                                           (EXIT
                                            (COND
                                              ((NULL
                                                (QEQCAR |tempF| 1))
                                               (LETT F
                                                (QCDR |tempF|) . #2#)))))))))
                                 (LETT J
                                       (PROGN
                                         (LETT #0# NIL . #2#)
                                         (SEQ (LETT |int| NIL . #2#)
                                          (LETT #1#
                                           (REVERSE
                                            (|REAL0;PosZero|
                                             (|REAL0;minus| F $) $)) . #2#)
                                          G190
                                          (COND
                                            ((OR (ATOM #1#)
                                              (PROGN
                                                (LETT |int|
                                                 (CAR #1#) . #2#)
                                                NIL))
                                             (GO G191)))
                                          (SEQ
                                           (EXIT
                                            (LETT #0#
                                             (CONS
                                              (|REAL0;negate| |int| $)
                                              #0#) . #2#)))
                                          (LETT #1# (CDR #1#) . #2#)
                                          (GO G190) G191
                                          (EXIT (NREVERSE0 #0#)))) . #2#)
                                 (LETT K (|REAL0;PosZero| F $) . #2#)
                                 (EXIT (APPEND (APPEND J L) K))))))))))))) 

(DEFUN |REAL0;PosZero| (F $)
  (PROG (|b| #0=#:G1882 |int| #1=#:G1883 L)
    (RETURN
      (SEQ (LETT |b| (|REAL0;rootBound| F $) . #2=(|REAL0;PosZero|))
           (LETT F (|REAL0;transMult| |b| F $) . #2#)
           (LETT L (|REAL0;Zero1| F $) . #2#)
           (EXIT (LETT L
                       (PROGN
                         (LETT #0# NIL . #2#)
                         (SEQ (LETT |int| NIL . #2#) (LETT #1# L . #2#)
                              G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |int| (CAR #1#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (LETT #0#
                                     (CONS
                                      (CONS
                                       (SPADCALL |b| (QCAR |int|)
                                        (QREFELT $ 44))
                                       (SPADCALL |b| (QCDR |int|)
                                        (QREFELT $ 44)))
                                      #0#) . #2#)))
                              (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                              (EXIT (NREVERSE0 #0#)))) . #2#)))))) 

(DEFUN |REAL0;Zero1| (F $)
  (PROG (|v| L |tempH| H Q |tempG| G #0=#:G1894 #1=#:G1895 J #2=#:G1896
             |int| #3=#:G1897 K)
    (RETURN
      (SEQ (LETT L NIL . #4=(|REAL0;Zero1|))
           (LETT |v|
                 (|REAL0;var|
                     (|REAL0;transAdd1| (|REAL0;invert| F $) $) $) . #4#)
           (EXIT (COND
                   ((EQL |v| 0) NIL)
                   ((EQL |v| 1)
                    (LETT L
                          (LIST (CONS (|spadConstant| $ 40)
                                      (|spadConstant| $ 10))) . #4#))
                   ('T
                    (SEQ (LETT G (|REAL0;transMultInv| 2 F $) . #4#)
                         (LETT H (|REAL0;transAdd1| G $) . #4#)
                         (COND
                           ((< 0 (SPADCALL H (QREFELT $ 39)))
                            (SEQ (LETT L
                                       (LIST
                                        (CONS
                                         (SPADCALL 1 2 (QREFELT $ 12))
                                         (SPADCALL 1 2 (QREFELT $ 12)))) . #4#)
                                 (LETT Q
                                       (SPADCALL 1 1 (QREFELT $ 41)) . #4#)
                                 (LETT |tempH|
                                       (SPADCALL H Q (QREFELT $ 43)) . #4#)
                                 (COND
                                   ((NULL (QEQCAR |tempH| 1))
                                    (LETT H (QCDR |tempH|) . #4#)))
                                 (LETT Q
                                       (SPADCALL Q
                                        (SPADCALL -1 0 (QREFELT $ 41))
                                        (QREFELT $ 45)) . #4#)
                                 (LETT |tempG|
                                       (SPADCALL G Q (QREFELT $ 43)) . #4#)
                                 (EXIT (COND
                                         ((NULL (QEQCAR |tempG| 1))
                                          (LETT G (QCDR |tempG|) . #4#)))))))
                         (LETT J
                               (PROGN
                                 (LETT #0# NIL . #4#)
                                 (SEQ (LETT |int| NIL . #4#)
                                      (LETT #1#
                                       (|REAL0;Zero1| H $) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |int|
                                             (CAR #1#) . #4#)
                                            NIL))
                                         #5=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (CONS
                                           (SPADCALL
                                            (SPADCALL (QCAR |int|)
                                             (|spadConstant| $ 10)
                                             (QREFELT $ 13))
                                            (SPADCALL 1 2
                                             (QREFELT $ 12))
                                            (QREFELT $ 14))
                                           (SPADCALL
                                            (SPADCALL (QCDR |int|)
                                             (|spadConstant| $ 10)
                                             (QREFELT $ 13))
                                            (SPADCALL 1 2
                                             (QREFELT $ 12))
                                            (QREFELT $ 14)))
                                          #0#) . #4#)))
                                      (LETT #1# (CDR #1#) . #4#)
                                      #6=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #4#)
                         (LETT K
                               (PROGN
                                 (LETT #2# NIL . #4#)
                                 (SEQ (LETT |int| NIL . #4#)
                                      (LETT #3#
                                       (|REAL0;Zero1| G $) . #4#)
                                      G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT |int|
                                             (CAR #3#) . #4#)
                                            NIL))
                                         #5#))
                                      (SEQ
                                       (EXIT
                                        (LETT #2#
                                         (CONS
                                          (CONS
                                           (SPADCALL (QCAR |int|)
                                            (SPADCALL 1 2
                                             (QREFELT $ 12))
                                            (QREFELT $ 14))
                                           (SPADCALL (QCDR |int|)
                                            (SPADCALL 1 2
                                             (QREFELT $ 12))
                                            (QREFELT $ 14)))
                                          #2#) . #4#)))
                                      (LETT #3# (CDR #3#) . #4#) #6#
                                      G191 (EXIT (NREVERSE0 #2#)))) . #4#)
                         (EXIT (APPEND (APPEND J L) K)))))))))) 

(DEFUN |REAL0;rootBound| (F $)
  (PROG (|lcoef| |an| |i| |b|)
    (RETURN
      (SEQ (COND
             ((< (SPADCALL F (QREFELT $ 46)) 0)
              (LETT F (SPADCALL F (QREFELT $ 47))
                    . #0=(|REAL0;rootBound|))))
           (LETT |lcoef| (SPADCALL F (QREFELT $ 46)) . #0#)
           (LETT F (SPADCALL F (QREFELT $ 48)) . #0#)
           (LETT |i| 0 . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL F (|spadConstant| $ 34)
                                (QREFELT $ 36))
                            'NIL)
                           ('T 'T)))
                   #1=(GO G191)))
                (SEQ (SEQ (LETT |an| (SPADCALL F (QREFELT $ 46)) . #0#)
                          (EXIT (COND
                                  ((< |an| 0)
                                   (LETT |i| (- |i| |an|) . #0#)))))
                     (EXIT (LETT F (SPADCALL F (QREFELT $ 48)) . #0#)))
                NIL #2=(GO G190) G191 (EXIT NIL))
           (LETT |b| 1 . #0#)
           (SEQ G190
                (COND
                  ((NULL (COND ((< |i| (* |b| |lcoef|)) 'NIL) ('T 'T)))
                   #1#))
                (SEQ (EXIT (LETT |b|
                                 (SPADCALL 2 |b| (QREFELT $ 50)) . #0#)))
                NIL #2# G191 (EXIT NIL))
           (EXIT |b|))))) 

(DEFUN |REAL0;transMult| (|c| F $)
  (PROG (|n| G)
    (RETURN
      (SEQ (LETT G (|spadConstant| $ 34) . #0=(|REAL0;transMult|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL F (|spadConstant| $ 34)
                                (QREFELT $ 36))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |n| (SPADCALL F (QREFELT $ 38)) . #0#)
                     (LETT G
                           (SPADCALL G
                               (SPADCALL
                                   (* (EXPT |c| |n|)
                                    (SPADCALL F (QREFELT $ 46)))
                                   |n| (QREFELT $ 41))
                               (QREFELT $ 45)) . #0#)
                     (EXIT (LETT F (SPADCALL F (QREFELT $ 48)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT G))))) 

(DEFUN |REAL0;transMultInv| (|c| F $)
  (PROG (|n| #0=#:G1911 |cc| G |d|)
    (RETURN
      (SEQ (LETT |d| (SPADCALL F (QREFELT $ 38))
                 . #1=(|REAL0;transMultInv|))
           (LETT |cc| 1 . #1#)
           (LETT G
                 (SPADCALL (SPADCALL F (QREFELT $ 46)) |d|
                     (QREFELT $ 41)) . #1#)
           (SEQ G190
                (COND
                  ((NULL (SEQ (LETT F
                                    (SPADCALL F (QREFELT $ 48)) . #1#)
                              (EXIT (COND
                                      ((SPADCALL F
                                        (|spadConstant| $ 34)
                                        (QREFELT $ 36))
                                       'NIL)
                                      ('T 'T)))))
                   (GO G191)))
                (SEQ (LETT |n| (SPADCALL F (QREFELT $ 38)) . #1#)
                     (LETT |cc|
                           (* |cc|
                              (EXPT |c|
                                    (PROG1 (LETT #0# (- |d| |n|) . #1#)
                                      (|check-subtype| (>= #0# 0)
                                       '(|NonNegativeInteger|) #0#)))) . #1#)
                     (LETT G
                           (SPADCALL G
                               (SPADCALL
                                   (* |cc| (SPADCALL F (QREFELT $ 46)))
                                   |n| (QREFELT $ 41))
                               (QREFELT $ 45)) . #1#)
                     (EXIT (LETT |d| |n| . #1#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT G))))) 

(DEFUN |REAL0;transAdd1| (F $)
  (PROG (|n| |v| #0=#:G1921 |j| |i| |ans|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL F (QREFELT $ 38))
                 . #1=(|REAL0;transAdd1|))
           (LETT |v| (SPADCALL F (+ |n| 1) (QREFELT $ 52)) . #1#)
           (SEQ (LETT |i| 0 . #1#) (LETT #0# (- |n| 1) . #1#) G190
                (COND ((QSGREATERP |i| #0#) #2=(GO G191)))
                (SEQ (EXIT (SEQ (LETT |j| (- |n| |i|) . #1#) G190
                                (COND ((> |j| |n|) #2#))
                                (SEQ (EXIT
                                      (SPADCALL |v| |j|
                                       (+
                                        (SPADCALL |v| |j|
                                         (QREFELT $ 53))
                                        (SPADCALL |v| (+ |j| 1)
                                         (QREFELT $ 53)))
                                       (QREFELT $ 54))))
                                (LETT |j| (+ |j| 1) . #1#) #3=(GO G190)
                                G191 (EXIT NIL))))
                (LETT |i| (QSADD1 |i|) . #1#) #3# G191 (EXIT NIL))
           (LETT |ans| (|spadConstant| $ 34) . #1#)
           (SEQ (LETT |i| 0 . #1#) G190
                (COND ((QSGREATERP |i| |n|) #2#))
                (SEQ (EXIT (LETT |ans|
                                 (SPADCALL |ans|
                                     (SPADCALL
                                      (SPADCALL |v| (+ |i| 1)
                                       (QREFELT $ 53))
                                      |i| (QREFELT $ 41))
                                     (QREFELT $ 45)) . #1#)))
                (LETT |i| (QSADD1 |i|) . #1#) #3# G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |REAL0;minus| (F $)
  (PROG (|n| |coef| G)
    (RETURN
      (SEQ (LETT G (|spadConstant| $ 34) . #0=(|REAL0;minus|))
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL F (|spadConstant| $ 34)
                                (QREFELT $ 36))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |n| (SPADCALL F (QREFELT $ 38)) . #0#)
                     (LETT |coef| (SPADCALL F (QREFELT $ 46)) . #0#)
                     (EXIT (COND
                             ((ODDP |n|)
                              (SEQ (LETT G
                                    (SPADCALL G
                                     (SPADCALL (- |coef|) |n|
                                      (QREFELT $ 41))
                                     (QREFELT $ 45)) . #0#)
                                   (EXIT
                                    (LETT F
                                     (SPADCALL F (QREFELT $ 48)) . #0#))))
                             ('T
                              (SEQ (LETT G
                                    (SPADCALL G
                                     (SPADCALL |coef| |n|
                                      (QREFELT $ 41))
                                     (QREFELT $ 45)) . #0#)
                                   (EXIT
                                    (LETT F
                                     (SPADCALL F (QREFELT $ 48)) . #0#)))))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT G))))) 

(DEFUN |REAL0;invert| (F $)
  (PROG (|n| #0=#:G1928 G)
    (RETURN
      (SEQ (LETT G (|spadConstant| $ 34) . #1=(|REAL0;invert|))
           (LETT |n| (SPADCALL F (QREFELT $ 38)) . #1#)
           (SEQ G190
                (COND
                  ((NULL (COND
                           ((SPADCALL F (|spadConstant| $ 34)
                                (QREFELT $ 36))
                            'NIL)
                           ('T 'T)))
                   (GO G191)))
                (SEQ (LETT G
                           (SPADCALL G
                               (SPADCALL (SPADCALL F (QREFELT $ 46))
                                   (PROG1
                                    (LETT #0#
                                     (- |n|
                                      (SPADCALL F (QREFELT $ 38))) . #1#)
                                     (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#))
                                   (QREFELT $ 41))
                               (QREFELT $ 45)) . #1#)
                     (EXIT (LETT F (SPADCALL F (QREFELT $ 48)) . #1#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT G))))) 

(DEFUN |REAL0;var| (F $)
  (PROG (|next| |i| |LastCoef|)
    (RETURN
      (SEQ (LETT |i| 0 . #0=(|REAL0;var|))
           (LETT |LastCoef| (< (SPADCALL F (QREFELT $ 46)) 0) . #0#)
           (SEQ G190
                (COND
                  ((NULL (SEQ (LETT F
                                    (SPADCALL F (QREFELT $ 48)) . #0#)
                              (EXIT (COND
                                      ((SPADCALL F
                                        (|spadConstant| $ 34)
                                        (QREFELT $ 36))
                                       'NIL)
                                      ('T 'T)))))
                   (GO G191)))
                (SEQ (LETT |next|
                           (< (SPADCALL F (QREFELT $ 46)) 0) . #0#)
                     (COND
                       (|LastCoef|
                           (COND
                             ((NULL |next|)
                              (COND
                                (|LastCoef| (LETT |i| (+ |i| 1) . #0#))))))
                       ((OR |next| |LastCoef|)
                        (LETT |i| (+ |i| 1) . #0#)))
                     (EXIT (LETT |LastCoef| |next| . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |i|))))) 

(DEFUN |REAL0;refine;Pol2RU;19| (F |int| |bounds| $)
  (PROG (|lseg| |pt|)
    (RETURN
      (SEQ (LETT |lseg|
                 (SPADCALL
                     (SPADCALL (QCDR |int|) (QCDR |bounds|)
                         (QREFELT $ 55))
                     (SPADCALL (QCAR |int|) (QCAR |bounds|)
                               (QREFELT $ 56))
                     (QREFELT $ 57))
                 . #0=(|REAL0;refine;Pol2RU;19|))
           (EXIT (COND
                   ((SPADCALL |lseg| (|spadConstant| $ 40)
                        (QREFELT $ 58))
                    (CONS 1 "failed"))
                   ((SPADCALL |lseg| (|spadConstant| $ 40)
                        (QREFELT $ 59))
                    (SEQ (LETT |pt|
                               (COND
                                 ((SPADCALL (QCAR |int|)
                                      (QCDR |bounds|) (QREFELT $ 59))
                                  (QCAR |int|))
                                 ('T (QCDR |int|))) . #0#)
                         (EXIT (COND
                                 ((EQL (SPADCALL
                                        (|REAL0;transMultInv|
                                         (SPADCALL |pt| (QREFELT $ 60))
                                         F $)
                                        (SPADCALL |pt| (QREFELT $ 61))
                                        (QREFELT $ 62))
                                       0)
                                  (CONS 0 (CONS |pt| |pt|)))
                                 ('T (CONS 1 "failed"))))))
                   ('T
                    (COND
                      ((SPADCALL |lseg|
                           (SPADCALL (QCDR |int|) (QCAR |int|)
                               (QREFELT $ 57))
                           (QREFELT $ 59))
                       (CONS 0 |int|))
                      ('T
                       (SPADCALL F
                           (SPADCALL F |int| |lseg| (QREFELT $ 28))
                           |bounds| (QREFELT $ 31))))))))))) 

(DEFUN |REAL0;refine;PolRFR;20| (F |int| |eps| $)
  (PROG (#0=#:G1947 |u| |mid| |midn| |midd| |v| |bn| |bd| |a| |b| |an|
            |ad| |xfl|)
    (RETURN
      (SEQ (LETT |a| (QCAR |int|) . #1=(|REAL0;refine;PolRFR;20|))
           (LETT |b| (QCDR |int|) . #1#)
           (EXIT (COND
                   ((SPADCALL |a| |b| (QREFELT $ 59)) (CONS |a| |b|))
                   ('T
                    (SEQ (LETT |an|
                               (SPADCALL |a| (QREFELT $ 61)) . #1#)
                         (LETT |ad|
                               (SPADCALL |a| (QREFELT $ 60)) . #1#)
                         (LETT |bn|
                               (SPADCALL |b| (QREFELT $ 61)) . #1#)
                         (LETT |bd|
                               (SPADCALL |b| (QREFELT $ 60)) . #1#)
                         (LETT |xfl| 'NIL . #1#)
                         (SEQ (LETT |u|
                                    (SPADCALL
                                     (|REAL0;transMultInv| |ad| F $)
                                     |an| (QREFELT $ 62)) . #1#)
                              (EXIT (COND
                                      ((EQL |u| 0)
                                       (SEQ
                                        (LETT F
                                         (PROG2
                                          (LETT #0#
                                           (SPADCALL F
                                            (SPADCALL
                                             (SPADCALL |ad| 1
                                              (QREFELT $ 41))
                                             (SPADCALL |an| 0
                                              (QREFELT $ 41))
                                             (QREFELT $ 63))
                                            (QREFELT $ 43)) . #1#)
                                          (QCDR #0#)
                                           (|check-union|
                                            (QEQCAR #0# 0)
                                            (QREFELT $ 6) #0#)) . #1#)
                                        (EXIT
                                         (LETT |u|
                                          (SPADCALL
                                           (|REAL0;transMultInv| |ad| F
                                            $)
                                           |an| (QREFELT $ 62)) . #1#)))))))
                         (SEQ (LETT |v|
                                    (SPADCALL
                                     (|REAL0;transMultInv| |bd| F $)
                                     |bn| (QREFELT $ 62)) . #1#)
                              (EXIT (COND
                                      ((EQL |v| 0)
                                       (SEQ
                                        (LETT F
                                         (PROG2
                                          (LETT #0#
                                           (SPADCALL F
                                            (SPADCALL
                                             (SPADCALL |bd| 1
                                              (QREFELT $ 41))
                                             (SPADCALL |bn| 0
                                              (QREFELT $ 41))
                                             (QREFELT $ 63))
                                            (QREFELT $ 43)) . #1#)
                                          (QCDR #0#)
                                           (|check-union|
                                            (QEQCAR #0# 0)
                                            (QREFELT $ 6) #0#)) . #1#)
                                        (LETT |v|
                                         (SPADCALL
                                          (|REAL0;transMultInv| |bd| F
                                           $)
                                          |bn| (QREFELT $ 62)) . #1#)
                                        (EXIT
                                         (LETT |u|
                                          (SPADCALL
                                           (|REAL0;transMultInv| |ad| F
                                            $)
                                           |an| (QREFELT $ 62)) . #1#)))))))
                         (COND
                           ((< 0 |u|)
                            (SEQ (LETT F
                                       (SPADCALL F (QREFELT $ 47)) . #1#)
                                 (EXIT (LETT |v| (- |v|) . #1#)))))
                         (COND
                           ((< |v| 0)
                            (|error| (LIST
                                      (|coerceRe2E| |int|
                                       (ELT
                                        (|Record|
                                         (|:| |left|
                                          (|Fraction| (|Integer|)))
                                         (|:| |right|
                                          (|Fraction| (|Integer|))))
                                        0))
                                      "is not a valid isolation interval for"
                                      (SPADCALL F (QREFELT $ 65))))))
                         (COND
                           ((NULL (SPADCALL (|spadConstant| $ 40) |eps|
                                      (QREFELT $ 58)))
                            (|error| "precision must be positive")))
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((SPADCALL
                                           (SPADCALL |b| |a|
                                            (QREFELT $ 57))
                                           |eps| (QREFELT $ 58))
                                          'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |mid|
                                    (SPADCALL
                                     (SPADCALL |b| |a| (QREFELT $ 13))
                                     (SPADCALL 1 2 (QREFELT $ 12))
                                     (QREFELT $ 14)) . #1#)
                                   (LETT |midn|
                                    (SPADCALL |mid| (QREFELT $ 61)) . #1#)
                                   (LETT |midd|
                                    (SPADCALL |mid| (QREFELT $ 60)) . #1#)
                                   (LETT |v|
                                    (SPADCALL
                                     (|REAL0;transMultInv| |midd| F $)
                                     |midn| (QREFELT $ 62)) . #1#)
                                   (EXIT
                                    (COND
                                      ((< |v| 0)
                                       (SEQ (LETT |a| |mid| . #1#)
                                        (LETT |an| |midn| . #1#)
                                        (EXIT (LETT |ad| |midd| . #1#))))
                                      ((< 0 |v|)
                                       (SEQ (LETT |b| |mid| . #1#)
                                        (LETT |bn| |midn| . #1#)
                                        (EXIT (LETT |bd| |midd| . #1#))))
                                      ((EQL |v| 0)
                                       (SEQ (LETT |a| |mid| . #1#)
                                        (LETT |b| |mid| . #1#)
                                        (LETT |an| |midn| . #1#)
                                        (LETT |ad| |midd| . #1#)
                                        (EXIT (LETT |xfl| 'T . #1#)))))))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (CONS |a| |b|)))))))))) 

(DEFUN |RealZeroPackage| (#0=#:G1963)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1964)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache| '|RealZeroPackage|)
                       '|domainEqualList|)
                   . #2=(|RealZeroPackage|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|RealZeroPackage;| #0#) (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|RealZeroPackage|))))))))))) 

(DEFUN |RealZeroPackage;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|RealZeroPackage|))
        (LETT |dv$| (LIST '|RealZeroPackage| DV$1) . #0#)
        (LETT $ (GETREFV 66) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|RealZeroPackage| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        $)))) 

(MAKEPROP '|RealZeroPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Fraction| 11)
             (0 . -) (5 . |One|) (9 . |One|) (|Integer|) (13 . /)
             (19 . +) (25 . *)
             (|Record| (|:| |left| 7) (|:| |right| 7))
             |REAL0;midpoint;RF;2| (|List| 7) (|List| 15)
             |REAL0;midpoints;LL;3| (|Factored| $) (31 . |squareFree|)
             (|Record| (|:| |factor| 6) (|:| |exponent| 11))
             (|List| 22) (|Factored| 6) (36 . |factors|) (41 . *)
             |REAL0;realZeros;PolL;5| |REAL0;refine;PolRFR;20|
             |REAL0;realZeros;PolFL;6| (|Union| 15 '"failed")
             |REAL0;refine;Pol2RU;19| |REAL0;realZeros;PolRL;7|
             |REAL0;realZeros;PolRFL;8| (47 . |Zero|) (|Boolean|)
             (51 . =) (|NonNegativeInteger|) (57 . |degree|)
             (62 . |minimumDegree|) (67 . |Zero|) (71 . |monomial|)
             (|Union| $ '"failed") (77 . |exquo|) (83 . *) (89 . +)
             (95 . |leadingCoefficient|) (100 . -) (105 . |reductum|)
             (|PositiveInteger|) (110 . *) (|Vector| 11)
             (116 . |vectorise|) (122 . |qelt|) (128 . |qsetelt!|)
             (135 . |min|) (141 . |max|) (147 . -) (153 . <) (159 . =)
             (165 . |denom|) (170 . |numer|) (175 . |elt|) (181 . -)
             (|OutputForm|) (187 . |coerce|))
          '#(|refine| 192 |realZeros| 206 |midpoints| 230 |midpoint|
             235)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 65
                                '(1 7 0 0 8 0 6 0 9 0 7 0 10 2 7 0 11
                                  11 12 2 7 0 0 0 13 2 7 0 0 0 14 1 6
                                  20 0 21 1 24 23 0 25 2 6 0 0 0 26 0 6
                                  0 34 2 6 35 0 0 36 1 6 37 0 38 1 6 37
                                  0 39 0 7 0 40 2 6 0 11 37 41 2 6 42 0
                                  0 43 2 7 0 11 0 44 2 6 0 0 0 45 1 6
                                  11 0 46 1 6 0 0 47 1 6 0 0 48 2 11 0
                                  49 0 50 2 6 51 0 37 52 2 51 11 0 11
                                  53 3 51 11 0 11 11 54 2 7 0 0 0 55 2
                                  7 0 0 0 56 2 7 0 0 0 57 2 7 35 0 0 58
                                  2 7 35 0 0 59 1 7 11 0 60 1 7 11 0 61
                                  2 6 11 0 11 62 2 6 0 0 0 63 1 6 64 0
                                  65 3 0 30 6 15 15 31 3 0 15 6 15 7 28
                                  2 0 18 6 15 32 1 0 18 6 27 3 0 18 6
                                  15 7 33 2 0 18 6 7 29 1 0 17 18 19 1
                                  0 7 15 16)))))
          '|lookupComplete|)) 
