
(/VERSIONCHECK 2) 

(DEFUN |IR2F;cmplex| (|alpha| |p| $)
  (SPADCALL |alpha|
      (SPADCALL (SPADCALL |p| |alpha| (QREFELT $ 9)) (QREFELT $ 10))
      (QREFELT $ 11))) 

(DEFUN |IR2F;IR2F| (|i| $)
  (SPADCALL
      (SPADCALL (SPADCALL |i| (QREFELT $ 13)) NIL
          (SPADCALL |i| (QREFELT $ 16)) (QREFELT $ 19))
      (QREFELT $ 20))) 

(DEFUN |IR2F;pairprod| (|x| |l| $)
  (PROG (#0=#:G1849 |y| #1=#:G1850)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|IR2F;pairprod|))
             (SEQ (LETT |y| NIL . #2#) (LETT #1# |l| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |y| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL |x| |y| (QREFELT $ 11))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |IR2F;evenRoots| (|x| $)
  (PROG (#0=#:G1856 |k| #1=#:G1857)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|IR2F;evenRoots|))
             (SEQ (LETT |k| NIL . #2#)
                  (LETT #1# (SPADCALL |x| (QREFELT $ 22)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |k| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (COND
                               ((COND
                                  ((SPADCALL |k|
                                    (SPADCALL "nthRoot" (QREFELT $ 25))
                                    (QREFELT $ 28))
                                   (COND
                                     ((SPADCALL
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |k| (QREFELT $ 30))
                                         (QREFELT $ 31))
                                        (QREFELT $ 33))
                                       (QREFELT $ 34))
                                      (COND
                                        ((NULL
                                          (SPADCALL
                                           (|SPADfirst|
                                            (SPADCALL |k|
                                             (QREFELT $ 30)))
                                           (QREFELT $ 36)))
                                         'NIL)
                                        ('T 'T)))
                                     ('T 'NIL)))
                                  ('T 'NIL))
                                (LETT #0#
                                      (CONS
                                       (|SPADfirst|
                                        (SPADCALL |k| (QREFELT $ 30)))
                                       #0#) . #2#)))))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |IR2F;expand;IrL;5| (|i| $)
  (PROG (|j|)
    (RETURN
      (SEQ (LETT |j| (SPADCALL |i| (QREFELT $ 37)) |IR2F;expand;IrL;5|)
           (EXIT (|IR2F;pairsum| (LIST (|IR2F;IR2F| |j| $))
                     (|IR2F;mkRealFunc| (SPADCALL |j| (QREFELT $ 38))
                         $)
                     $)))))) 

(DEFUN |IR2F;split;2Ir;6| (|i| $)
  (PROG (#0=#:G1865 |l| #1=#:G1866)
    (RETURN
      (SEQ (SPADCALL (SPADCALL |i| (QREFELT $ 13))
               (SPADCALL
                   (PROGN
                     (LETT #0# NIL . #2=(|IR2F;split;2Ir;6|))
                     (SEQ (LETT |l| NIL . #2#)
                          (LETT #1#
                                (SPADCALL |i| (QREFELT $ 38)) . #2#)
                          G190
                          (COND
                            ((OR (ATOM #1#)
                                 (PROGN
                                   (LETT |l| (CAR #1#) . #2#)
                                   NIL))
                             (GO G191)))
                          (SEQ (EXIT (LETT #0#
                                      (CONS (|IR2F;nlogs| |l| $) #0#) . #2#)))
                          (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                          (EXIT (NREVERSE0 #0#))))
                   (QREFELT $ 41))
               (SPADCALL |i| (QREFELT $ 16)) (QREFELT $ 19)))))) 

(DEFUN |IR2F;complexExpand;IrF;7| (|i| $)
  (PROG (|j| |lg| #0=#:G1873 #1=#:G1870 #2=#:G1868 #3=#:G1869)
    (RETURN
      (SEQ (LETT |j| (SPADCALL |i| (QREFELT $ 37))
                 . #4=(|IR2F;complexExpand;IrF;7|))
           (EXIT (SPADCALL (|IR2F;IR2F| |j| $)
                     (PROGN
                       (LETT #3# NIL . #4#)
                       (SEQ (LETT |lg| NIL . #4#)
                            (LETT #0#
                                  (SPADCALL |j| (QREFELT $ 38)) . #4#)
                            G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |lg| (CAR #0#) . #4#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #1#
                                          (SPADCALL
                                           (SPADCALL (QVELT |lg| 0)
                                            (QREFELT $ 43))
                                           (|IR2F;lg2cfunc| |lg| $)
                                           (QREFELT $ 11)) . #4#)
                                         (COND
                                           (#3#
                                            (LETT #2#
                                             (SPADCALL #2# #1#
                                              (QREFELT $ 44)) . #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| $ 45))))
                     (QREFELT $ 44))))))) 

(DEFUN |IR2F;quadratic| (|p| |lg| $)
  (PROG (|b| |a| |p0| |delta| |d| |c| |q| |e| |f| |nrm| |lgp| |sqr| |s|
             |sqrp| |pp| |sqrn| |nn|)
    (RETURN
      (SEQ (COND
             ((SPADCALL
                  (LETT |delta|
                        (SPADCALL
                            (SPADCALL
                                (LETT |b|
                                      (SPADCALL |p| 1 (QREFELT $ 50))
                                      . #0=(|IR2F;quadratic|))
                                2 (QREFELT $ 52))
                            (SPADCALL
                                (SPADCALL 4
                                    (LETT |a|
                                     (SPADCALL |p| 2 (QREFELT $ 50)) . #0#)
                                    (QREFELT $ 53))
                                (LETT |p0|
                                      (SPADCALL |p| 0 (QREFELT $ 50)) . #0#)
                                (QREFELT $ 11))
                            (QREFELT $ 55)) . #0#)
                  (QREFELT $ 56))
              (LIST (|IR2F;linear|
                        (SPADCALL
                            (SPADCALL (|spadConstant| $ 48) 1
                                (QREFELT $ 57))
                            (SPADCALL (SPADCALL |b| |a| (QREFELT $ 58))
                                (QREFELT $ 59))
                            (QREFELT $ 60))
                        |lg| $)))
             ('T
              (SEQ (LETT |e|
                         (QCAR (LETT |q|
                                     (|IR2F;quadeval| |lg|
                                      (LETT |c|
                                       (SPADCALL
                                        (SPADCALL |b|
                                         (LETT |d|
                                          (SPADCALL
                                           (SPADCALL 2 |a|
                                            (QREFELT $ 53))
                                           (QREFELT $ 61)) . #0#)
                                         (QREFELT $ 11))
                                        (QREFELT $ 62)) . #0#)
                                      |d| |delta| $) . #0#)) . #0#)
                   (LETT |lgp|
                         (SPADCALL |c|
                             (SPADCALL
                                 (LETT |nrm|
                                       (SPADCALL
                                        (SPADCALL |e| 2 (QREFELT $ 52))
                                        (SPADCALL |delta|
                                         (SPADCALL
                                          (LETT |f| (QCDR |q|) . #0#) 2
                                          (QREFELT $ 52))
                                         (QREFELT $ 11))
                                        (QREFELT $ 55)) . #0#)
                                 (QREFELT $ 10))
                             (QREFELT $ 11)) . #0#)
                   (LETT |s|
                         (QCAR (LETT |sqr|
                                     (|IR2F;insqrt| |delta| $) . #0#)) . #0#)
                   (LETT |pp|
                         (LETT |nn| (|spadConstant| $ 45) . #0#) . #0#)
                   (COND
                     ((NULL (< (QCDR |sqr|) 0))
                      (SEQ (LETT |sqrp|
                                 (SPADCALL (QCAR |s|)
                                     (SPADCALL
                                      (SPADCALL (QCDR |s|)
                                       (QREFELT $ 63))
                                      (QREFELT $ 65))
                                     (QREFELT $ 11)) . #0#)
                           (EXIT (LETT |pp|
                                       (SPADCALL |lgp|
                                        (SPADCALL
                                         (SPADCALL |d| |sqrp|
                                          (QREFELT $ 11))
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL 2 |e|
                                               (QREFELT $ 53))
                                              |f| (QREFELT $ 11))
                                             |nrm| (QREFELT $ 58))
                                            |sqrp| (QREFELT $ 11))
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |e| 2
                                              (QREFELT $ 52))
                                             (SPADCALL |delta|
                                              (SPADCALL |f| 2
                                               (QREFELT $ 52))
                                              (QREFELT $ 11))
                                             (QREFELT $ 44))
                                            |nrm| (QREFELT $ 58))
                                           (QREFELT $ 44))
                                          (QREFELT $ 10))
                                         (QREFELT $ 11))
                                        (QREFELT $ 44)) . #0#)))))
                   (COND
                     ((NULL (< 0 (QCDR |sqr|)))
                      (SEQ (LETT |sqrn|
                                 (SPADCALL (QCAR |s|)
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL (QCDR |s|)
                                        (QREFELT $ 62))
                                       (QREFELT $ 63))
                                      (QREFELT $ 65))
                                     (QREFELT $ 11)) . #0#)
                           (EXIT (LETT |nn|
                                       (SPADCALL |lgp|
                                        (SPADCALL
                                         (SPADCALL |d| |sqrn|
                                          (QREFELT $ 11))
                                         (|IR2F;ilog| |e|
                                          (SPADCALL |f| |sqrn|
                                           (QREFELT $ 11))
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |a|
                                             (QREFELT $ 67))
                                            (SPADCALL |b|
                                             (QREFELT $ 67))
                                            (QREFELT $ 69))
                                           (SPADCALL |p0|
                                            (QREFELT $ 67))
                                           (QREFELT $ 69))
                                          $)
                                         (QREFELT $ 11))
                                        (QREFELT $ 44)) . #0#)))))
                   (EXIT (COND
                           ((< 0 (QCDR |sqr|)) (LIST |pp|))
                           ((< (QCDR |sqr|) 0) (LIST |nn|))
                           ('T (LIST |pp| |nn|))))))))))) 

(DEFUN |IR2F;tantrick| (|a| |b| $)
  (COND
    ((QEQCAR (SPADCALL |a| (QREFELT $ 71)) 0)
     (SPADCALL 2
         (SPADCALL
             (SPADCALL (SPADCALL |b| |a| (QREFELT $ 58))
                 (QREFELT $ 62))
             (QREFELT $ 72))
         (QREFELT $ 53)))
    ('T
     (SPADCALL 2
         (SPADCALL (SPADCALL |a| |b| (QREFELT $ 58)) (QREFELT $ 72))
         (QREFELT $ 53))))) 

(DEFUN |IR2F;ilog| (|a| |b| |lk| $)
  (PROG (|l| #0=#:G1815 #1=#:G1898 #2=#:G1894 #3=#:G1892 #4=#:G1893
             |k|)
    (RETURN
      (SEQ (LETT |l|
                 (SPADCALL
                     (SPADCALL
                         (SPADCALL (SPADCALL |a| (QREFELT $ 74))
                             (QREFELT $ 76))
                         (SPADCALL (SPADCALL |b| (QREFELT $ 74))
                             (QREFELT $ 76))
                         (QREFELT $ 69))
                     (SPADCALL |lk|
                         (SPADCALL
                             (SPADCALL (SPADCALL |a| (QREFELT $ 77))
                                 (QREFELT $ 76))
                             (SPADCALL (SPADCALL |b| (QREFELT $ 77))
                                 (QREFELT $ 76))
                             (QREFELT $ 69))
                         (QREFELT $ 69))
                     (QREFELT $ 78))
                 . #5=(|IR2F;ilog|))
           (EXIT (COND
                   ((NULL |l|) (|IR2F;tantrick| |a| |b| $))
                   ('T
                    (SEQ (LETT |k|
                               (PROGN
                                 (LETT #4# NIL . #5#)
                                 (SEQ (LETT #0# NIL . #5#)
                                      (LETT #1# |l| . #5#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT #0# (CAR #1#) . #5#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #2# #0# . #5#)
                                          (COND
                                            (#4#
                                             (LETT #3#
                                              (SPADCALL #3# #2#
                                               (QREFELT $ 79)) . #5#))
                                            ('T
                                             (PROGN
                                               (LETT #3# #2# . #5#)
                                               (LETT #4# 'T . #5#)))))))
                                      (LETT #1# (CDR #1#) . #5#)
                                      (GO G190) G191 (EXIT NIL))
                                 (COND
                                   (#4# #3#)
                                   ('T (|IdentityError| '|max|)))) . #5#)
                         (EXIT (|IR2F;ilog0| |a| |b|
                                   (SPADCALL
                                    (SPADCALL |a| |k| (QREFELT $ 82))
                                    (QREFELT $ 84))
                                   (SPADCALL
                                    (SPADCALL |b| |k| (QREFELT $ 82))
                                    (QREFELT $ 84))
                                   (SPADCALL |k| (QREFELT $ 85)) $)))))))))) 

(DEFUN |IR2F;ilog0| (|a| |b| |upa| |upb| |k| $)
  (PROG (|#G30| |#G31| |#G32| |#G33| |r| |g| |qr| |aa| |bb|)
    (RETURN
      (SEQ (COND
             ((< (SPADCALL |upa| (QREFELT $ 86))
                 (SPADCALL |upb| (QREFELT $ 86)))
              (SEQ (PROGN
                     (LETT |#G30| (SPADCALL |upb| (QREFELT $ 87))
                           . #0=(|IR2F;ilog0|))
                     (LETT |#G31| |upa| . #0#)
                     (LETT |upa| |#G30| . #0#)
                     (LETT |upb| |#G31| . #0#))
                   (EXIT (PROGN
                           (LETT |#G32|
                                 (SPADCALL |b| (QREFELT $ 62)) . #0#)
                           (LETT |#G33| |a| . #0#)
                           (LETT |a| |#G32| . #0#)
                           (LETT |b| |#G33| . #0#))))))
           (EXIT (COND
                   ((ZEROP (SPADCALL |upb| (QREFELT $ 86)))
                    (|IR2F;tantrick| |a| |b| $))
                   ('T
                    (SEQ (LETT |r|
                               (SPADCALL |upa| |upb| (QREFELT $ 89)) . #0#)
                         (LETT |g|
                               (SPADCALL (QVELT |r| 2) (QREFELT $ 91)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |g| 1)
                                  (|IR2F;tantrick| |a| |b| $))
                                 ('T
                                  (SEQ (COND
                                         ((NULL
                                           (<
                                            (SPADCALL (QVELT |r| 0)
                                             (QREFELT $ 86))
                                            (SPADCALL |upb|
                                             (QREFELT $ 86))))
                                          (SEQ
                                           (LETT |qr|
                                            (SPADCALL (QVELT |r| 0)
                                             |upb| (QREFELT $ 93)) . #0#)
                                           (QSETVELT |r| 0 (QCDR |qr|))
                                           (EXIT
                                            (QSETVELT |r| 1
                                             (SPADCALL (QVELT |r| 1)
                                              (SPADCALL (QCAR |qr|)
                                               |upa| (QREFELT $ 94))
                                              (QREFELT $ 60)))))))
                                       (LETT |aa|
                                        (SPADCALL (QVELT |r| 1) |k|
                                         (QREFELT $ 9)) . #0#)
                                       (LETT |bb|
                                        (SPADCALL
                                         (SPADCALL (QVELT |r| 0) |k|
                                          (QREFELT $ 9))
                                         (QREFELT $ 62)) . #0#)
                                       (EXIT
                                        (SPADCALL
                                         (|IR2F;tantrick|
                                          (SPADCALL
                                           (SPADCALL |aa| |a|
                                            (QREFELT $ 11))
                                           (SPADCALL |bb| |b|
                                            (QREFELT $ 11))
                                           (QREFELT $ 44))
                                          (QCDR |g|) $)
                                         (|IR2F;ilog0| |aa| |bb|
                                          (QVELT |r| 1)
                                          (SPADCALL (QVELT |r| 0)
                                           (QREFELT $ 87))
                                          |k| $)
                                         (QREFELT $ 44))))))))))))))) 

(DEFUN |IR2F;lg2func| (|lg| $)
  (PROG (|p| |d| |r| |alpha| #0=#:G1925 #1=#:G1929)
    (RETURN
      (SEQ (COND
             ((ZEROP (LETT |d|
                           (SPADCALL
                               (LETT |p| (QVELT |lg| 1)
                                     . #2=(|IR2F;lg2func|))
                               (QREFELT $ 86)) . #2#))
              (|error| "poly has degree 0"))
             ((EQL |d| 1) (LIST (|IR2F;linear| |p| (QVELT |lg| 2) $)))
             ((EQL |d| 2) (|IR2F;quadratic| |p| (QVELT |lg| 2) $))
             ('T
              (SEQ (EXIT (SEQ (COND
                                ((ODDP |d|)
                                 (SEQ (LETT |r|
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 95))
                                        (QREFELT $ 91)) . #2#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |r| 0)
                                          (PROGN
                                            (LETT #1#
                                             (|IR2F;pairsum|
                                              (LIST
                                               (|IR2F;cmplex|
                                                (LETT |alpha|
                                                 (SPADCALL
                                                  (SPADCALL |p|
                                                   (QREFELT $ 97))
                                                  (QREFELT $ 65)) . #2#)
                                                (QVELT |lg| 2) $))
                                              (|IR2F;lg2func|
                                               (VECTOR (QVELT |lg| 0)
                                                (PROG2
                                                 (LETT #0#
                                                  (SPADCALL |p|
                                                   (SPADCALL
                                                    (SPADCALL
                                                     (|spadConstant| $
                                                      48)
                                                     1 (QREFELT $ 57))
                                                    (SPADCALL |alpha|
                                                     (QREFELT $ 59))
                                                    (QREFELT $ 98))
                                                   (QREFELT $ 100)) . #2#)
                                                 (QCDR #0#)
                                                  (|check-union|
                                                   (QEQCAR #0# 0)
                                                   (|SparseUnivariatePolynomial|
                                                    (QREFELT $ 7))
                                                   #0#))
                                                (QVELT |lg| 2))
                                               $)
                                              $) . #2#)
                                            (GO #1#))))))))
                              (EXIT (LIST (|IR2F;lg2cfunc| |lg| $)))))
                   #1# (EXIT #1#)))))))) 

(DEFUN |IR2F;lg2cfunc| (|lg| $)
  (PROG (|alpha| #0=#:G1937 #1=#:G1935 #2=#:G1933 #3=#:G1934)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|IR2F;lg2cfunc|))
             (SEQ (LETT |alpha| NIL . #4#)
                  (LETT #0#
                        (SPADCALL (QVELT |lg| 1) (QREFELT $ 101)) . #4#)
                  G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |alpha| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (|IR2F;cmplex| |alpha|
                                      (QVELT |lg| 2) $) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 44)) . #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| $ 45)))))))) 

(DEFUN |IR2F;mkRealFunc| (|l| $)
  (PROG (|lg| #0=#:G1942 |ans|)
    (RETURN
      (SEQ (LETT |ans| NIL . #1=(|IR2F;mkRealFunc|))
           (SEQ (LETT |lg| NIL . #1#) (LETT #0# |l| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |lg| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |ans|
                                 (|IR2F;pairsum| |ans|
                                     (|IR2F;pairprod|
                                      (SPADCALL (QVELT |lg| 0)
                                       (QREFELT $ 43))
                                      (|IR2F;lg2func| |lg| $) $)
                                     $) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |IR2F;linear| (|p| |lg| $)
  (PROG (|alpha|)
    (RETURN
      (SEQ (LETT |alpha|
                 (SPADCALL
                     (SPADCALL (SPADCALL |p| 0 (QREFELT $ 50))
                         (SPADCALL |p| 1 (QREFELT $ 50))
                         (QREFELT $ 58))
                     (QREFELT $ 62))
                 |IR2F;linear|)
           (EXIT (SPADCALL |alpha|
                     (SPADCALL (SPADCALL |lg| |alpha| (QREFELT $ 9))
                         (QREFELT $ 10))
                     (QREFELT $ 11))))))) 

(DEFUN |IR2F;quadeval| (|p| |a| |b| |delta| $)
  (PROG (|v| |i| #0=#:G1951 |c| |d| |temp| |bi| |ai|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 102))
              (CONS (|spadConstant| $ 45) (|spadConstant| $ 45)))
             ('T
              (SEQ (LETT |bi|
                         (LETT |c|
                               (LETT |d| (|spadConstant| $ 45)
                                     . #1=(|IR2F;quadeval|)) . #1#) . #1#)
                   (LETT |ai| (|spadConstant| $ 48) . #1#)
                   (LETT |v|
                         (SPADCALL |p|
                             (+ 1 (SPADCALL |p| (QREFELT $ 86)))
                             (QREFELT $ 104)) . #1#)
                   (SEQ (LETT |i| (SPADCALL |v| (QREFELT $ 105)) . #1#)
                        (LETT #0# (QVSIZE |v|) . #1#) G190
                        (COND ((> |i| #0#) (GO G191)))
                        (SEQ (LETT |c|
                                   (SPADCALL |c|
                                    (SPADCALL
                                     (SPADCALL |v| |i| (QREFELT $ 106))
                                     |ai| (QREFELT $ 11))
                                    (QREFELT $ 44)) . #1#)
                             (LETT |d|
                                   (SPADCALL |d|
                                    (SPADCALL
                                     (SPADCALL |v| |i| (QREFELT $ 106))
                                     |bi| (QREFELT $ 11))
                                    (QREFELT $ 44)) . #1#)
                             (LETT |temp|
                                   (SPADCALL
                                    (SPADCALL |a| |ai| (QREFELT $ 11))
                                    (SPADCALL
                                     (SPADCALL |b| |bi| (QREFELT $ 11))
                                     |delta| (QREFELT $ 11))
                                    (QREFELT $ 44)) . #1#)
                             (LETT |bi|
                                   (SPADCALL
                                    (SPADCALL |a| |bi| (QREFELT $ 11))
                                    (SPADCALL |b| |ai| (QREFELT $ 11))
                                    (QREFELT $ 44)) . #1#)
                             (EXIT (LETT |ai| |temp| . #1#)))
                        (LETT |i| (+ |i| 1) . #1#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (CONS |c| |d|))))))))) 

(DEFUN |IR2F;compatible?| (|lx| |ly| $)
  (PROG (|x| #0=#:G1964 |y| #1=#:G1965 |s| #2=#:G1963 #3=#:G1959)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL |ly|) 'T)
                   ('T
                    (SEQ (SEQ (LETT |x| NIL . #4=(|IR2F;compatible?|))
                              (LETT #0# |lx| . #4#) G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |x| (CAR #0#) . #4#)
                                       NIL))
                                 #5=(GO G191)))
                              (SEQ (EXIT
                                    (SEQ (LETT |y| NIL . #4#)
                                     (LETT #1# |ly| . #4#) G190
                                     (COND
                                       ((OR (ATOM #1#)
                                         (PROGN
                                           (LETT |y| (CAR #1#) . #4#)
                                           NIL))
                                        #5#))
                                     (SEQ
                                      (LETT |s|
                                       (SPADCALL
                                        (SPADCALL |x| |y|
                                         (QREFELT $ 11))
                                        (QREFELT $ 109)) . #4#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |s| 0)
                                          (COND
                                            ((< (QCDR |s|) 0)
                                             (PROGN
                                               (LETT #3#
                                                (PROGN
                                                  (LETT #2# 'NIL . #4#)
                                                  (GO #2#)) . #4#)
                                               (GO #3#))))))))
                                     (LETT #1# (CDR #1#) . #4#)
                                     #6=(GO G190) G191 (EXIT NIL)))
                                   #3# (EXIT #3#))
                              (LETT #0# (CDR #0#) . #4#) #6# G191
                              (EXIT NIL))
                         (EXIT 'T)))))
           #2# (EXIT #2#))))) 

(DEFUN |IR2F;pairsum| (|lx| |ly| $)
  (PROG (|x| #0=#:G1973 |ls| #1=#:G1974 |y| #2=#:G1975 |ln| |l|)
    (RETURN
      (SEQ (COND
             ((NULL |lx|) |ly|)
             ((NULL |ly|) |lx|)
             ('T
              (SEQ (LETT |l| NIL . #3=(|IR2F;pairsum|))
                   (SEQ (LETT |x| NIL . #3#) (LETT #0# |lx| . #3#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |x| (CAR #0#) . #3#) NIL))
                           #4=(GO G191)))
                        (SEQ (LETT |ls| (|IR2F;evenRoots| |x| $) . #3#)
                             (EXIT (COND
                                     ((NULL
                                       (NULL
                                        (LETT |ln|
                                         (PROGN
                                           (LETT #1# NIL . #3#)
                                           (SEQ (LETT |y| NIL . #3#)
                                            (LETT #2# |ly| . #3#) G190
                                            (COND
                                              ((OR (ATOM #2#)
                                                (PROGN
                                                  (LETT |y|
                                                   (CAR #2#) . #3#)
                                                  NIL))
                                               #4#))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((|IR2F;compatible?|
                                                  |ls|
                                                  (|IR2F;evenRoots| |y|
                                                   $)
                                                  $)
                                                 (LETT #1#
                                                  (CONS
                                                   (SPADCALL |x| |y|
                                                    (QREFELT $ 44))
                                                   #1#) . #3#)))))
                                            (LETT #2# (CDR #2#) . #3#)
                                            #5=(GO G190) G191
                                            (EXIT (NREVERSE0 #1#)))) . #3#)))
                                      (LETT |l|
                                       (SPADCALL
                                        (SPADCALL |l| |ln|
                                         (QREFELT $ 110))
                                        (QREFELT $ 111)) . #3#)))))
                        (LETT #0# (CDR #0#) . #3#) #5# G191 (EXIT NIL))
                   (EXIT |l|)))))))) 

(DEFUN |IR2F;insqrt| (|y| $)
  (PROG (|rec| |s|)
    (RETURN
      (SEQ (LETT |rec| (SPADCALL |y| 2 (QREFELT $ 114))
                 . #0=(|IR2F;insqrt|))
           (EXIT (COND
                   ((EQL (QVELT |rec| 0) 1)
                    (CONS (CONS (SPADCALL (QVELT |rec| 1)
                                    (QVELT |rec| 2) (QREFELT $ 11))
                                (|spadConstant| $ 48))
                          1))
                   ((NULL (EQL (QVELT |rec| 0) 2))
                    (|error| "Should not happen"))
                   ('T
                    (CONS (CONS (QVELT |rec| 1) (QVELT |rec| 2))
                          (SEQ (LETT |s|
                                     (SPADCALL (QVELT |rec| 2)
                                      (QREFELT $ 109)) . #0#)
                               (EXIT (COND
                                       ((QEQCAR |s| 1) 0)
                                       ('T (QCDR |s|))))))))))))) 

(DEFUN |IR2F;nlogs| (|lg| $)
  (PROG (#0=#:G1994 |f| #1=#:G1995)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|IR2F;nlogs|))
             (SEQ (LETT |f| NIL . #2#)
                  (LETT #1#
                        (SPADCALL
                            (SPADCALL
                                (SPADCALL (QVELT |lg| 1)
                                    (QREFELT $ 115))
                                (QREFELT $ 118))
                            (QREFELT $ 121)) . #2#)
                  G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |f| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (VECTOR
                                     (SPADCALL (QCDR |f|)
                                      (QVELT |lg| 0) (QREFELT $ 122))
                                     (QCAR |f|) (QVELT |lg| 2))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |IntegrationResultToFunction| (&REST #0=#:G1996)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1997)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (|devaluateList| #0#)
                       (HGET |$ConstructorCache|
                             '|IntegrationResultToFunction|)
                       '|domainEqualList|)
                   . #2=(|IntegrationResultToFunction|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (APPLY (|function|
                                 |IntegrationResultToFunction;|)
                             #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache|
                        '|IntegrationResultToFunction|))))))))))) 

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

(MAKEPROP '|IntegrationResultToFunction| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|SparseUnivariatePolynomial| 7) (0 . |elt|) (6 . |log|)
             (11 . *) (|IntegrationResult| 7) (17 . |ratpart|)
             (|Record| (|:| |integrand| 7) (|:| |intvar| 7))
             (|List| 14) (22 . |notelem|)
             (|Record| (|:| |scalar| 42) (|:| |coeff| 8)
                 (|:| |logand| 8))
             (|List| 17) (27 . |mkAnswer|) (34 . |retract|) (|List| 81)
             (39 . |tower|) (|String|) (|Symbol|) (44 . |coerce|)
             (|Boolean|) (|Kernel| 7) (49 . |is?|) (|List| 7)
             (55 . |argument|) (60 . |second|) (|Integer|)
             (65 . |retract|) (70 . |even?|) (|List| 24)
             (75 . |variables|) |IR2F;split;2Ir;6| (80 . |logpart|)
             |IR2F;expand;IrL;5| (|List| $) (85 . |concat|)
             (|Fraction| 32) (90 . |coerce|) (95 . +) (101 . |Zero|)
             |IR2F;complexExpand;IrF;7| (105 . |One|) (109 . |One|)
             (|NonNegativeInteger|) (113 . |coefficient|)
             (|PositiveInteger|) (119 . **) (125 . *) (131 . |Zero|)
             (135 . -) (141 . |zero?|) (146 . |monomial|) (152 . /)
             (158 . |coerce|) (163 . +) (169 . |inv|) (174 . -)
             (179 . |sqrt|) (|AlgebraicManipulations| 6 7)
             (184 . |rootSimp|) (189 . |Zero|) (193 . |kernels|)
             (|List| 27) (198 . |setUnion|) (|Union| 42 '"failed")
             (204 . |retractIfCan|) (209 . |atan|)
             (|SparseMultivariatePolynomial| 6 81) (214 . |numer|)
             (|SparseMultivariatePolynomial| 6 27) (219 . |variables|)
             (224 . |denom|) (229 . |setDifference|) (235 . |max|)
             (|Fraction| 96) (|Kernel| $) (241 . |univariate|)
             (|Fraction| 8) (247 . |numer|) (252 . |coerce|)
             (257 . |degree|) (262 . -)
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (267 . |extendedEuclidean|) (|Union| 7 '"failed")
             (273 . |retractIfCan|)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (278 . |divide|) (284 . *) (290 . |reductum|)
             (|SparseUnivariatePolynomial| $) (295 . |zeroOf|)
             (300 . -) (|Union| $ '"failed") (306 . |exquo|)
             (312 . |zerosOf|) (317 . |zero?|) (|Vector| 7)
             (322 . |vectorise|) (328 . |minIndex|) (333 . |qelt|)
             (|Union| 32 '"failed") (|ElementaryFunctionSign| 6 7)
             (339 . |sign|) (344 . |concat|) (350 . |removeDuplicates|)
             (|Record| (|:| |exponent| 49) (|:| |coef| 7)
                 (|:| |radicand| 7))
             (|PolynomialRoots| (|IndexedExponents| 27) 27 6 75 7)
             (355 . |froot|) (361 . |primitivePart|) (|Factored| 8)
             (|FunctionSpaceUnivariatePolynomialFactor| 6 7 8)
             (366 . |ffactor|)
             (|Record| (|:| |factor| 8) (|:| |exponent| 32))
             (|List| 119) (371 . |factors|) (376 . *))
          '#(|split| 382 |expand| 387 |complexExpand| 392) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 122
                                '(2 8 7 0 7 9 1 7 0 0 10 2 7 0 0 0 11 1
                                  12 7 0 13 1 12 15 0 16 3 12 0 7 18 15
                                  19 1 12 7 0 20 1 7 21 0 22 1 24 0 23
                                  25 2 27 26 0 24 28 1 27 29 0 30 1 29
                                  7 0 31 1 7 32 0 33 1 32 26 0 34 1 7
                                  35 0 36 1 12 18 0 38 1 18 0 40 41 1 7
                                  0 42 43 2 7 0 0 0 44 0 7 0 45 0 6 0
                                  47 0 7 0 48 2 8 7 0 49 50 2 7 0 0 51
                                  52 2 7 0 51 0 53 0 6 0 54 2 7 0 0 0
                                  55 1 7 26 0 56 2 8 0 7 49 57 2 7 0 0
                                  0 58 1 8 0 7 59 2 8 0 0 0 60 1 7 0 0
                                  61 1 7 0 0 62 1 7 0 0 63 1 64 7 7 65
                                  0 8 0 66 1 7 21 0 67 2 68 0 0 0 69 1
                                  7 70 0 71 1 7 0 0 72 1 7 73 0 74 1 75
                                  68 0 76 1 7 73 0 77 2 68 0 0 0 78 2
                                  27 0 0 0 79 2 7 80 0 81 82 1 83 8 0
                                  84 1 7 0 81 85 1 8 49 0 86 1 8 0 0 87
                                  2 8 88 0 0 89 1 8 90 0 91 2 8 92 0 0
                                  93 2 8 0 0 0 94 1 8 0 0 95 1 7 0 96
                                  97 2 8 0 0 0 98 2 8 99 0 0 100 1 7 40
                                  96 101 1 8 26 0 102 2 8 103 0 49 104
                                  1 103 32 0 105 2 103 7 0 32 106 1 108
                                  107 7 109 2 29 0 0 0 110 1 29 0 0 111
                                  2 113 112 7 49 114 1 8 0 0 115 1 117
                                  116 8 118 1 116 120 0 121 2 42 0 32 0
                                  122 1 0 12 12 37 1 0 29 12 39 1 0 7
                                  12 46)))))
          '|lookupComplete|)) 
