
(/VERSIONCHECK 2) 

(DEFUN |INFSP;numeric| (|r| $)
  (PROG (|gr|)
    (RETURN
     (SEQ
      (COND
       ((|domainEqual| (QREFELT $ 6) (|Integer|))
        (COND
         ((|domainEqual| (QREFELT $ 7) (|Float|))
          (SPADCALL |r| (QREFELT $ 11)))
         ((|domainEqual| (QREFELT $ 7) (|Fraction| (|Integer|)))
          (SPADCALL |r| (QREFELT $ 13)))
         ((|domainEqual| (QREFELT $ 7) (|Complex| (|Float|)))
          (SPADCALL |r| (QREFELT $ 15)))
         ((|domainEqual| (QREFELT $ 7) (|Complex| (|Fraction| (|Integer|))))
          (SPADCALL |r| (QREFELT $ 17)))))
       ((|domainEqual| (QREFELT $ 6) (|Complex| (|Integer|)))
        (SEQ (LETT |gr| |r| |INFSP;numeric|)
             (EXIT
              (COND
               ((|domainEqual| (QREFELT $ 7)
                               (|Complex| (|Fraction| (|Integer|))))
                (SPADCALL
                 (SPADCALL (SPADCALL |gr| (QREFELT $ 19)) (QREFELT $ 13))
                 (SPADCALL (SPADCALL |gr| (QREFELT $ 20)) (QREFELT $ 13))
                 (QREFELT $ 21)))
               ((|domainEqual| (QREFELT $ 7) (|Complex| (|Float|)))
                (SPADCALL |gr| (QREFELT $ 22)))))))
       ('T (|error| "case not handled"))))))) 

(DEFUN |INFSP;makeEq;LLL;2| (|nres| |lv| $)
  (PROG (#1=#:G673 |x| #2=#:G674 |r| #3=#:G672)
    (RETURN
     (SEQ
      (PROGN
       (LETT #3# NIL . #4=(|INFSP;makeEq;LLL;2|))
       (SEQ (LETT |r| NIL . #4#) (LETT #2# |nres| . #4#) (LETT |x| NIL . #4#)
            (LETT #1# |lv| . #4#) G190
            (COND
             ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #4#) NIL) (ATOM #2#)
                  (PROGN (LETT |r| (CAR #2#) . #4#) NIL))
              (GO G191)))
            (SEQ
             (EXIT
              (LETT #3#
                    (CONS
                     (SPADCALL (SPADCALL |x| (QREFELT $ 25))
                               (SPADCALL |r| (QREFELT $ 26)) (QREFELT $ 28))
                     #3#)
                    . #4#)))
            (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #4#)) . #4#)
            (GO G190) G191 (EXIT (NREVERSE0 #3#)))))))) 

(DEFUN |INFSP;evaluate| (|pol| |xvar| |zvar| |z| $)
  (PROG (|upol| |rpp|)
    (RETURN
     (SEQ
      (LETT |rpp|
            (SPADCALL (CONS (|function| |INFSP;numeric|) $) |pol|
                      (QREFELT $ 36))
            . #1=(|INFSP;evaluate|))
      (LETT |rpp| (SPADCALL |rpp| |zvar| |z| (QREFELT $ 37)) . #1#)
      (LETT |upol| (SPADCALL |rpp| |xvar| (QREFELT $ 39)) . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL (SPADCALL (SPADCALL |upol| 0 (QREFELT $ 44)) (QREFELT $ 45))
                  (QREFELT $ 46))
        (SPADCALL (SPADCALL |upol| (QREFELT $ 47)) (QREFELT $ 46))
        (QREFELT $ 48))))))) 

(DEFUN |INFSP;myConvert| (|eps| $)
  (COND ((|domainEqual| (QREFELT $ 8) (|Fraction| (|Integer|))) |eps|)
        ((|domainEqual| (QREFELT $ 8) (|Float|))
         (SPADCALL |eps| (QREFELT $ 49))))) 

(DEFUN |INFSP;innerSolve1;PParL;5| (|pol| |eps| $)
  (SPADCALL (SPADCALL |pol| (QREFELT $ 51)) |eps| (QREFELT $ 52))) 

(DEFUN |INFSP;innerSolve1;SupParL;6| (|upol| |eps| $)
  (PROG (#1=#:G692 |x| #2=#:G691 |z| #3=#:G690 #4=#:G689)
    (RETURN
     (SEQ
      (COND
       ((|domainEqual| (QREFELT $ 6) (|Complex| (|Integer|)))
        (COND
         ((OR (|domainEqual| (QREFELT $ 8) (|Fraction| (|Integer|)))
              (|domainEqual| (QREFELT $ 8) (|Float|)))
          (EXIT (SPADCALL |upol| |eps| (QREFELT $ 56)))))))
      (EXIT
       (COND
        ((|domainEqual| (QREFELT $ 6) (|Integer|))
         (COND
          ((|domainEqual| (QREFELT $ 7) (|Float|))
           (SEQ
            (LETT |z|
                  (SPADCALL |upol| (|INFSP;myConvert| |eps| $) (QREFELT $ 61))
                  . #5=(|INFSP;innerSolve1;SupParL;6|))
            (EXIT
             (PROGN
              (LETT #4# NIL . #5#)
              (SEQ (LETT |x| NIL . #5#) (LETT #3# |z| . #5#) G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |x| (CAR #3#) . #5#) NIL))
                     #6=(GO G191)))
                   (SEQ
                    (EXIT
                     (LETT #4#
                           (CONS
                            (SPADCALL
                             (SPADCALL (SPADCALL 1 2 (QREFELT $ 63))
                                       (SPADCALL (QCAR |x|) (QCDR |x|)
                                                 (QREFELT $ 64))
                                       (QREFELT $ 65))
                             (QREFELT $ 66))
                            #4#)
                           . #5#)))
                   (LETT #3# (CDR #3#) . #5#) #7=(GO G190) G191
                   (EXIT (NREVERSE0 #4#)))))))
          ((|domainEqual| (QREFELT $ 7) (|Fraction| (|Integer|)))
           (SEQ
            (LETT |z|
                  (SPADCALL |upol| (|INFSP;myConvert| |eps| $) (QREFELT $ 61))
                  . #5#)
            (EXIT
             (PROGN
              (LETT #2# NIL . #5#)
              (SEQ (LETT |x| NIL . #5#) (LETT #1# |z| . #5#) G190
                   (COND
                    ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #5#) NIL))
                     #6#))
                   (SEQ
                    (EXIT
                     (LETT #2#
                           (CONS
                            (SPADCALL (SPADCALL 1 2 (QREFELT $ 63))
                                      (SPADCALL (QCAR |x|) (QCDR |x|)
                                                (QREFELT $ 67))
                                      (QREFELT $ 68))
                            #2#)
                           . #5#)))
                   (LETT #1# (CDR #1#) . #5#) #7# G191
                   (EXIT (NREVERSE0 #2#)))))))
          (#8='T (|error| "improper arguments to INFSP"))))
        (#8# (|error| "improper arguments to INFSP")))))))) 

(DEFUN |INFSP;findGenZeros| (|lp| |rlvar| |eps| $)
  (PROG (#1=#:G700 |pol| #2=#:G701 |xvar| #3=#:G699 #4=#:G698 |z| #5=#:G697
         |lz| |rlp| |zvar| |f|)
    (RETURN
     (SEQ (LETT |rlp| (REVERSE |lp|) . #6=(|INFSP;findGenZeros|))
          (LETT |f| (|SPADfirst| |rlp|) . #6#)
          (LETT |zvar| (|SPADfirst| |rlvar|) . #6#)
          (LETT |rlp| (CDR |rlp|) . #6#)
          (LETT |lz| (SPADCALL |f| |eps| (QREFELT $ 53)) . #6#)
          (EXIT
           (PROGN
            (LETT #5# NIL . #6#)
            (SEQ (LETT |z| NIL . #6#) (LETT #4# |lz| . #6#) G190
                 (COND
                  ((OR (ATOM #4#) (PROGN (LETT |z| (CAR #4#) . #6#) NIL))
                   #7=(GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #5#
                         (CONS
                          (REVERSE
                           (CONS |z|
                                 (PROGN
                                  (LETT #3# NIL . #6#)
                                  (SEQ (LETT |xvar| NIL . #6#)
                                       (LETT #2# (CDR |rlvar|) . #6#)
                                       (LETT |pol| NIL . #6#)
                                       (LETT #1# |rlp| . #6#) G190
                                       (COND
                                        ((OR (ATOM #1#)
                                             (PROGN
                                              (LETT |pol| (CAR #1#) . #6#)
                                              NIL)
                                             (ATOM #2#)
                                             (PROGN
                                              (LETT |xvar| (CAR #2#) . #6#)
                                              NIL))
                                         #7#))
                                       (SEQ
                                        (EXIT
                                         (LETT #3#
                                               (CONS
                                                (|INFSP;evaluate| |pol| |xvar|
                                                 |zvar| |z| $)
                                                #3#)
                                               . #6#)))
                                       (LETT #1#
                                             (PROG1 (CDR #1#)
                                               (LETT #2# (CDR #2#) . #6#))
                                             . #6#)
                                       #8=(GO G190) G191
                                       (EXIT (NREVERSE0 #3#))))))
                          #5#)
                         . #6#)))
                 (LETT #4# (CDR #4#) . #6#) #8# G191
                 (EXIT (NREVERSE0 #5#))))))))) 

(DEFUN |INFSP;oldCoord| (|numres| |lval| $)
  (PROG (#1=#:G703 #2=#:G702 #3=#:G704 #4=#:G707 |n| #5=#:G708 |nr| |rnumres|)
    (RETURN
     (SEQ (LETT |rnumres| (REVERSE |numres|) . #6=(|INFSP;oldCoord|))
          (SPADCALL |rnumres| '|first|
                    (SPADCALL (|SPADfirst| |rnumres|)
                              (PROGN
                               (LETT #1# NIL . #6#)
                               (SEQ (LETT |nr| NIL . #6#)
                                    (LETT #5# (CDR |rnumres|) . #6#)
                                    (LETT |n| NIL . #6#)
                                    (LETT #4# |lval| . #6#) G190
                                    (COND
                                     ((OR (ATOM #4#)
                                          (PROGN
                                           (LETT |n| (CAR #4#) . #6#)
                                           NIL)
                                          (ATOM #5#)
                                          (PROGN
                                           (LETT |nr| (CAR #5#) . #6#)
                                           NIL))
                                      (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                       (LETT #3#
                                             (SPADCALL |n| |nr| (QREFELT $ 69))
                                             . #6#)
                                       (COND
                                        (#1#
                                         (LETT #2#
                                               (SPADCALL #2# #3#
                                                         (QREFELT $ 67))
                                               . #6#))
                                        ('T
                                         (PROGN
                                          (LETT #2# #3# . #6#)
                                          (LETT #1# 'T . #6#)))))))
                                    (LETT #4#
                                          (PROG1 (CDR #4#)
                                            (LETT #5# (CDR #5#) . #6#))
                                          . #6#)
                                    (GO G190) G191 (EXIT NIL))
                               (COND (#1# #2#) ('T (|spadConstant| $ 41))))
                              (QREFELT $ 67))
                    (QREFELT $ 71))
          (EXIT (REVERSE |rnumres|)))))) 

(DEFUN |INFSP;innerSolve2| (|lp| |lv| |eps| $)
  (PROG (|p1| |p0| |vec| |up2| |up1| |mainvar|)
    (RETURN
     (SEQ (LETT |mainvar| (|SPADfirst| |lv|) . #1=(|INFSP;innerSolve2|))
          (LETT |up1|
                (SPADCALL (SPADCALL |lp| 1 (QREFELT $ 74)) |mainvar|
                          (QREFELT $ 75))
                . #1#)
          (LETT |up2|
                (SPADCALL (SPADCALL |lp| 2 (QREFELT $ 74)) |mainvar|
                          (QREFELT $ 75))
                . #1#)
          (LETT |vec| (SPADCALL |up1| |up2| (QREFELT $ 79)) . #1#)
          (LETT |p0|
                (SPADCALL (SPADCALL (ELT |vec| 0) |mainvar| (QREFELT $ 80))
                          (QREFELT $ 81))
                . #1#)
          (LETT |p1|
                (SPADCALL (SPADCALL (ELT |vec| 1) |mainvar| (QREFELT $ 80))
                          |mainvar| (QREFELT $ 82))
                . #1#)
          (COND
           ((OR (SPADCALL |p1| (QREFELT $ 84))
                (NULL
                 (SPADCALL
                  (SPADCALL |p0|
                            (SPADCALL (SPADCALL |p1| |mainvar| (QREFELT $ 75))
                                      (QREFELT $ 88))
                            (QREFELT $ 89))
                  (|spadConstant| $ 90) (QREFELT $ 91))))
            (EXIT
             (SPADCALL (CONS (|spadConstant| $ 85) |lp|) NIL |lv| |eps|
                       (QREFELT $ 87)))))
          (EXIT
           (|INFSP;findGenZeros| (LIST |p1| |p0|) (REVERSE |lv|) |eps| $)))))) 

(DEFUN |INFSP;innerSolve;2LLParL;10| (|lp| |ld| |lv| |eps| $)
  (PROG (|result| #1=#:G830 |r| #2=#:G829 |lris| |lgen1| #3=#:G828 |pf|
         #4=#:G827 |lval| |lgen| |genRecord| #5=#:G826 |gres| |partRes|
         #6=#:G825 #7=#:G796 #8=#:G795 #9=#:G797 #10=#:G824 |res| |listG|
         #11=#:G823 #12=#:G822 #13=#:G821 |pr| #14=#:G820 #15=#:G791 |listGen|
         #16=#:G726 #17=#:G725 #18=#:G727 #19=#:G789 #20=#:G788 #21=#:G790
         #22=#:G819 #23=#:G661 #24=#:G818 |f| |res1| #25=#:G817 |rrlvv| |rlv|
         #26=#:G720 #27=#:G719 #28=#:G721 #29=#:G816 |fq| #30=#:G815 #31=#:G814
         |gb| |lq| #32=#:G813 |q1| #33=#:G812 |dmp| DP |lvv| #34=#:G715
         #35=#:G811 |vv| #36=#:G810 OV |lnp| #37=#:G809 |p| #38=#:G808)
    (RETURN
     (SEQ
      (LETT |lnp|
            (PROGN
             (LETT #38# NIL . #39=(|INFSP;innerSolve;2LLParL;10|))
             (SEQ (LETT |p| NIL . #39#) (LETT #37# |lp| . #39#) G190
                  (COND
                   ((OR (ATOM #37#) (PROGN (LETT |p| (CAR #37#) . #39#) NIL))
                    #40=(GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #38#
                          (CONS
                           (SPADCALL |p|
                                     (|compiledLookupCheck| '|pToDmp|
                                                            (LIST
                                                             (LIST
                                                              '|DistributedMultivariatePolynomial|
                                                              |lv|
                                                              (|devaluate|
                                                               (ELT $ 6)))
                                                             (LIST
                                                              '|Polynomial|
                                                              (|devaluate|
                                                               (ELT $ 6))))
                                                            (|PolToPol| |lv|
                                                                        (ELT $
                                                                             6))))
                           #38#)
                          . #39#)))
                  (LETT #37# (CDR #37#) . #39#) #41=(GO G190) G191
                  (EXIT (NREVERSE0 #38#))))
            . #39#)
      (LETT OV (|OrderedVariableList| |lv|) . #39#)
      (LETT |lvv|
            (PROGN
             (LETT #36# NIL . #39#)
             (SEQ (LETT |vv| NIL . #39#) (LETT #35# |lv| . #39#) G190
                  (COND
                   ((OR (ATOM #35#) (PROGN (LETT |vv| (CAR #35#) . #39#) NIL))
                    #40#))
                  (SEQ
                   (EXIT
                    (LETT #36#
                          (CONS
                           (PROG2
                               (LETT #34#
                                     (SPADCALL |vv|
                                               (|compiledLookupCheck|
                                                '|variable|
                                                (LIST
                                                 (LIST '|Union| '$ '"failed")
                                                 (LIST '|Symbol|))
                                                OV))
                                     . #39#)
                               (QCDR #34#)
                             (|check-union| (QEQCAR #34# 0) OV #34#))
                           #36#)
                          . #39#)))
                  (LETT #35# (CDR #35#) . #39#) #41# G191
                  (EXIT (NREVERSE0 #36#))))
            . #39#)
      (LETT DP (|DirectProduct| (LENGTH |lv|) (|NonNegativeInteger|)) . #39#)
      (LETT |dmp| (|DistributedMultivariatePolynomial| |lv| (QREFELT $ 6))
            . #39#)
      (LETT |lq| NIL . #39#)
      (COND
       ((NULL (SPADCALL |ld| NIL (QREFELT $ 92)))
        (LETT |lq|
              (PROGN
               (LETT #33# NIL . #39#)
               (SEQ (LETT |q1| NIL . #39#) (LETT #32# |ld| . #39#) G190
                    (COND
                     ((OR (ATOM #32#)
                          (PROGN (LETT |q1| (CAR #32#) . #39#) NIL))
                      #40#))
                    (SEQ
                     (EXIT
                      (LETT #33#
                            (CONS
                             (SPADCALL |q1|
                                       (|compiledLookupCheck| '|pToDmp|
                                                              (LIST
                                                               (LIST
                                                                '|DistributedMultivariatePolynomial|
                                                                |lv|
                                                                (|devaluate|
                                                                 (ELT $ 6)))
                                                               (LIST
                                                                '|Polynomial|
                                                                (|devaluate|
                                                                 (ELT $ 6))))
                                                              (|PolToPol| |lv|
                                                                          (ELT
                                                                           $
                                                                           6))))
                             #33#)
                            . #39#)))
                    (LETT #32# (CDR #32#) . #39#) #41# G191
                    (EXIT (NREVERSE0 #33#))))
              . #39#)))
      (LETT |partRes|
            (SPADCALL |lnp| |lvv|
                      (|compiledLookupCheck| '|groebSolve|
                                             (LIST
                                              (LIST '|List|
                                                    (LIST '|List|
                                                          (LIST
                                                           '|DistributedMultivariatePolynomial|
                                                           |lv|
                                                           (|devaluate|
                                                            (ELT $ 6)))))
                                              (LIST '|List|
                                                    (LIST
                                                     '|DistributedMultivariatePolynomial|
                                                     |lv|
                                                     (|devaluate| (ELT $ 6))))
                                              (LIST '|List|
                                                    (LIST
                                                     '|OrderedVariableList|
                                                     |lv|)))
                                             (|GroebnerSolve| |lv| (ELT $ 6)
                                                              (ELT $ 6))))
            . #39#)
      (EXIT
       (COND
        ((SPADCALL |partRes|
                   (SPADCALL NIL
                             (|compiledLookupCheck| '|list|
                                                    (LIST '$
                                                          (LIST '|List|
                                                                (|devaluate|
                                                                 |dmp|)))
                                                    (|List| (|List| |dmp|))))
                   (|compiledLookupCheck| '= (LIST (LIST '|Boolean|) '$ '$)
                                          (|List| (|List| |dmp|))))
         NIL)
        (#42='T
         (SEQ
          (COND
           ((NULL
             (SPADCALL |lq| NIL
                       (|compiledLookupCheck| '= (LIST (LIST '|Boolean|) '$ '$)
                                              (|List| |dmp|))))
            (SEQ
             (LETT |gb|
                   (|GroebnerInternalPackage| (QREFELT $ 6)
                                              (|DirectProduct| (LENGTH |lv|)
                                                               (|NonNegativeInteger|))
                                              OV |dmp|)
                   . #39#)
             (EXIT
              (LETT |partRes|
                    (PROGN
                     (LETT #31# NIL . #39#)
                     (SEQ (LETT |pr| NIL . #39#) (LETT #30# |partRes| . #39#)
                          G190
                          (COND
                           ((OR (ATOM #30#)
                                (PROGN (LETT |pr| (CAR #30#) . #39#) NIL))
                            #40#))
                          (SEQ
                           (EXIT
                            (COND
                             ((PROGN
                               (LETT #26# NIL . #39#)
                               (SEQ (LETT |fq| NIL . #39#)
                                    (LETT #29# |lq| . #39#) G190
                                    (COND
                                     ((OR (ATOM #29#)
                                          (PROGN
                                           (LETT |fq| (CAR #29#) . #39#)
                                           NIL))
                                      #40#))
                                    (SEQ
                                     (EXIT
                                      (PROGN
                                       (LETT #28#
                                             (COND
                                              ((SPADCALL
                                                (SPADCALL |fq| |pr|
                                                          (|compiledLookupCheck|
                                                           '|redPol|
                                                           (LIST
                                                            (|devaluate| |dmp|)
                                                            (|devaluate| |dmp|)
                                                            (LIST '|List|
                                                                  (|devaluate|
                                                                   |dmp|)))
                                                           |gb|))
                                                (SPADCALL
                                                 (|compiledLookupCheck| '|Zero|
                                                                        (LIST
                                                                         '$)
                                                                        (|DistributedMultivariatePolynomial|
                                                                         |lv|
                                                                         (ELT $
                                                                              6))))
                                                (|compiledLookupCheck| '=
                                                                       (LIST
                                                                        (LIST
                                                                         '|Boolean|)
                                                                        '$ '$)
                                                                       (|DistributedMultivariatePolynomial|
                                                                        |lv|
                                                                        (ELT $
                                                                             6))))
                                               'NIL)
                                              ('T 'T))
                                             . #39#)
                                       (COND
                                        (#26#
                                         (LETT #27#
                                               (COND (#27# #28#) ('T 'NIL))
                                               . #39#))
                                        ('T
                                         (PROGN
                                          (LETT #27# #28# . #39#)
                                          (LETT #26# 'T . #39#)))))))
                                    (LETT #29# (CDR #29#) . #39#) #41# G191
                                    (EXIT NIL))
                               (COND (#26# #27#) (#42# 'T)))
                              (LETT #31# (CONS |pr| #31#) . #39#)))))
                          (LETT #30# (CDR #30#) . #39#) #41# G191
                          (EXIT (NREVERSE0 #31#))))
                    . #39#)))))
          (LETT |rlv| (REVERSE |lv|) . #39#)
          (LETT |rrlvv| (CDR (REVERSE |lvv|)) . #39#)
          (LETT |listGen| NIL . #39#)
          (SEQ (LETT |res| NIL . #39#) (LETT #25# |partRes| . #39#) G190
               (COND
                ((OR (ATOM #25#) (PROGN (LETT |res| (CAR #25#) . #39#) NIL))
                 #40#))
               (SEQ
                (EXIT
                 (SEQ (LETT |res1| (CDR (REVERSE |res|)) . #39#)
                      (EXIT
                       (COND
                        ((PROGN
                          (LETT #16# NIL . #39#)
                          (SEQ (LETT |f| NIL . #39#) (LETT #24# |res1| . #39#)
                               G190
                               (COND
                                ((OR (ATOM #24#)
                                     (PROGN (LETT |f| (CAR #24#) . #39#) NIL))
                                 #40#))
                               (SEQ
                                (EXIT
                                 (PROGN
                                  (LETT #18#
                                        (EQL
                                         (PROGN
                                          (LETT #19# NIL . #39#)
                                          (SEQ (LETT #23# NIL . #39#)
                                               (LETT #22#
                                                     (SPADCALL |f| |rrlvv|
                                                               (|compiledLookupCheck|
                                                                '|degree|
                                                                (LIST
                                                                 (LIST '|List|
                                                                       (LIST
                                                                        '|NonNegativeInteger|))
                                                                 '$
                                                                 (LIST '|List|
                                                                       (LIST
                                                                        '|OrderedVariableList|
                                                                        |lv|)))
                                                                (|DistributedMultivariatePolynomial|
                                                                 |lv|
                                                                 (ELT $ 6))))
                                                     . #39#)
                                               G190
                                               (COND
                                                ((OR (ATOM #22#)
                                                     (PROGN
                                                      (LETT #23# (CAR #22#)
                                                            . #39#)
                                                      NIL))
                                                 #40#))
                                               (SEQ
                                                (EXIT
                                                 (PROGN
                                                  (LETT #21# #23# . #39#)
                                                  (COND
                                                   (#19#
                                                    (LETT #20# (MAX #20# #21#)
                                                          . #39#))
                                                   ('T
                                                    (PROGN
                                                     (LETT #20# #21# . #39#)
                                                     (LETT #19# 'T
                                                           . #39#)))))))
                                               (LETT #22# (CDR #22#) . #39#)
                                               #41# G191 (EXIT NIL))
                                          (COND (#19# #20#)
                                                ('T (|IdentityError| '|max|))))
                                         1)
                                        . #39#)
                                  (COND
                                   (#16#
                                    (LETT #17# (COND (#17# #18#) ('T 'NIL))
                                          . #39#))
                                   ('T
                                    (PROGN
                                     (LETT #17# #18# . #39#)
                                     (LETT #16# 'T . #39#)))))))
                               (LETT #24# (CDR #24#) . #39#) #41# G191
                               (EXIT NIL))
                          (COND (#16# #17#) ('T 'T)))
                         (PROGN
                          (LETT #15#
                                (LETT |listGen| (CONS |res| |listGen|) . #39#)
                                . #39#)
                          (GO #15#)))))))
                #15# (EXIT #15#))
               (LETT #25# (CDR #25#) . #39#) #41# G191 (EXIT NIL))
          (LETT |result| NIL . #39#)
          (COND
           ((NULL
             (SPADCALL |listGen| NIL
                       (|compiledLookupCheck| '= (LIST (LIST '|Boolean|) '$ '$)
                                              (|List| (|List| |dmp|)))))
            (SEQ
             (LETT |listG|
                   (PROGN
                    (LETT #14# NIL . #39#)
                    (SEQ (LETT |pr| NIL . #39#) (LETT #13# |listGen| . #39#)
                         G190
                         (COND
                          ((OR (ATOM #13#)
                               (PROGN (LETT |pr| (CAR #13#) . #39#) NIL))
                           #40#))
                         (SEQ
                          (EXIT
                           (LETT #14#
                                 (CONS
                                  (PROGN
                                   (LETT #12# NIL . #39#)
                                   (SEQ (LETT |pf| NIL . #39#)
                                        (LETT #11# |pr| . #39#) G190
                                        (COND
                                         ((OR (ATOM #11#)
                                              (PROGN
                                               (LETT |pf| (CAR #11#) . #39#)
                                               NIL))
                                          #40#))
                                        (SEQ
                                         (EXIT
                                          (LETT #12#
                                                (CONS
                                                 (SPADCALL |pf|
                                                           (|compiledLookupCheck|
                                                            '|dmpToP|
                                                            (LIST
                                                             (LIST
                                                              '|Polynomial|
                                                              (|devaluate|
                                                               (ELT $ 6)))
                                                             (LIST
                                                              '|DistributedMultivariatePolynomial|
                                                              |lv|
                                                              (|devaluate|
                                                               (ELT $ 6))))
                                                            (|PolToPol| |lv|
                                                                        (ELT $
                                                                             6))))
                                                 #12#)
                                                . #39#)))
                                        (LETT #11# (CDR #11#) . #39#) #41# G191
                                        (EXIT (NREVERSE0 #12#))))
                                  #14#)
                                 . #39#)))
                         (LETT #13# (CDR #13#) . #39#) #41# G191
                         (EXIT (NREVERSE0 #14#))))
                   . #39#)
             (LETT |result|
                   (PROGN
                    (LETT #7# NIL . #39#)
                    (SEQ (LETT |res| NIL . #39#) (LETT #10# |listG| . #39#)
                         G190
                         (COND
                          ((OR (ATOM #10#)
                               (PROGN (LETT |res| (CAR #10#) . #39#) NIL))
                           #40#))
                         (SEQ
                          (EXIT
                           (PROGN
                            (LETT #9#
                                  (|INFSP;findGenZeros| |res| |rlv| |eps| $)
                                  . #39#)
                            (COND (#7# (LETT #8# (APPEND #8# #9#) . #39#))
                                  ('T
                                   (PROGN
                                    (LETT #8# #9# . #39#)
                                    (LETT #7# 'T . #39#)))))))
                         (LETT #10# (CDR #10#) . #39#) #41# G191 (EXIT NIL))
                    (COND (#7# #8#) (#42# NIL)))
                   . #39#)
             (EXIT
              (SEQ (LETT |gres| NIL . #39#) (LETT #6# |listGen| . #39#) G190
                   (COND
                    ((OR (ATOM #6#) (PROGN (LETT |gres| (CAR #6#) . #39#) NIL))
                     #40#))
                   (SEQ
                    (EXIT
                     (LETT |partRes|
                           (SPADCALL |partRes|
                                     (SPADCALL |gres| |partRes|
                                               (|compiledLookupCheck|
                                                '|position|
                                                (LIST (LIST '|Integer|)
                                                      (LIST '|List|
                                                            (|devaluate|
                                                             |dmp|))
                                                      '$)
                                                (|List| (|List| |dmp|))))
                                     (|compiledLookupCheck| '|delete|
                                                            (LIST '$ '$
                                                                  (LIST
                                                                   '|Integer|))
                                                            (|List|
                                                             (|List| |dmp|))))
                           . #39#)))
                   (LETT #6# (CDR #6#) . #39#) #41# G191 (EXIT NIL))))))
          (SEQ (LETT |gres| NIL . #39#) (LETT #5# |partRes| . #39#) G190
               (COND
                ((OR (ATOM #5#) (PROGN (LETT |gres| (CAR #5#) . #39#) NIL))
                 #40#))
               (SEQ
                (LETT |genRecord|
                      (SPADCALL |gres| |lvv|
                                (|compiledLookupCheck| '|genericPosition|
                                                       (LIST
                                                        (LIST '|Record|
                                                              (LIST '|:|
                                                                    '|dpolys|
                                                                    (LIST
                                                                     '|List|
                                                                     (LIST
                                                                      '|DistributedMultivariatePolynomial|
                                                                      |lv|
                                                                      (|devaluate|
                                                                       (ELT $
                                                                            6)))))
                                                              (LIST '|:|
                                                                    '|coords|
                                                                    (LIST
                                                                     '|List|
                                                                     (LIST
                                                                      '|Integer|))))
                                                        (LIST '|List|
                                                              (LIST
                                                               '|DistributedMultivariatePolynomial|
                                                               |lv|
                                                               (|devaluate|
                                                                (ELT $ 6))))
                                                        (LIST '|List|
                                                              (LIST
                                                               '|OrderedVariableList|
                                                               |lv|)))
                                                       (|GroebnerSolve| |lv|
                                                                        (ELT $
                                                                             6)
                                                                        (ELT $
                                                                             6))))
                      . #39#)
                (LETT |lgen| (QCAR |genRecord|) . #39#)
                (LETT |lval| (QCDR |genRecord|) . #39#)
                (LETT |lgen1|
                      (PROGN
                       (LETT #4# NIL . #39#)
                       (SEQ (LETT |pf| NIL . #39#) (LETT #3# |lgen| . #39#)
                            G190
                            (COND
                             ((OR (ATOM #3#)
                                  (PROGN (LETT |pf| (CAR #3#) . #39#) NIL))
                              #40#))
                            (SEQ
                             (EXIT
                              (LETT #4#
                                    (CONS
                                     (SPADCALL |pf|
                                               (|compiledLookupCheck| '|dmpToP|
                                                                      (LIST
                                                                       (LIST
                                                                        '|Polynomial|
                                                                        (|devaluate|
                                                                         (ELT $
                                                                              6)))
                                                                       (LIST
                                                                        '|DistributedMultivariatePolynomial|
                                                                        |lv|
                                                                        (|devaluate|
                                                                         (ELT $
                                                                              6))))
                                                                      (|PolToPol|
                                                                       |lv|
                                                                       (ELT $
                                                                            6))))
                                     #4#)
                                    . #39#)))
                            (LETT #3# (CDR #3#) . #39#) #41# G191
                            (EXIT (NREVERSE0 #4#))))
                      . #39#)
                (LETT |lris| (|INFSP;findGenZeros| |lgen1| |rlv| |eps| $)
                      . #39#)
                (EXIT
                 (LETT |result|
                       (APPEND
                        (PROGN
                         (LETT #2# NIL . #39#)
                         (SEQ (LETT |r| NIL . #39#) (LETT #1# |lris| . #39#)
                              G190
                              (COND
                               ((OR (ATOM #1#)
                                    (PROGN (LETT |r| (CAR #1#) . #39#) NIL))
                                #40#))
                              (SEQ
                               (EXIT
                                (LETT #2#
                                      (CONS (|INFSP;oldCoord| |r| |lval| $)
                                            #2#)
                                      . #39#)))
                              (LETT #1# (CDR #1#) . #39#) #41# G191
                              (EXIT (NREVERSE0 #2#))))
                        |result|)
                       . #39#)))
               (LETT #5# (CDR #5#) . #39#) #41# G191 (EXIT NIL))
          (EXIT |result|))))))))) 

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

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

(MAKEPROP '|InnerNumericFloatSolvePackage| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
              (|local| |#3|) (|Integer|) (|Float|) (0 . |coerce|)
              (|Fraction| 9) (5 . |coerce|) (|Complex| 10) (10 . |coerce|)
              (|Complex| 12) (15 . |coerce|) (|Complex| 9) (20 . |real|)
              (25 . |imag|) (30 . |complex|) (36 . |convert|) (|Symbol|)
              (|Polynomial| 7) (41 . |coerce|) (46 . |coerce|) (|Equation| 24)
              (51 . |equation|) (|List| 27) (|List| 7) (|List| 23)
              |INFSP;makeEq;LLL;2| (|Mapping| 7 6) (|Polynomial| 6)
              (|PolynomialFunctions2| 6 7) (57 . |map|) (63 . |eval|)
              (|SparseUnivariatePolynomial| $) (70 . |univariate|)
              (76 . |Zero|) (80 . |Zero|) (|NonNegativeInteger|)
              (|SparseUnivariatePolynomial| 24) (84 . |coefficient|) (90 . -)
              (95 . |retract|) (100 . |leadingCoefficient|) (105 . /)
              (111 . |retract|) (|SparseUnivariatePolynomial| 6)
              (116 . |univariate|) |INFSP;innerSolve1;SupParL;6|
              |INFSP;innerSolve1;PParL;5| (|List| (|Complex| 8))
              (|ComplexRootPackage| 50 8) (121 . |complexZeros|)
              (|Record| (|:| |left| 12) (|:| |right| 12)) (|List| 57)
              (|SparseUnivariatePolynomial| 9) (|RealZeroPackage| 59)
              (127 . |realZeros|) (133 . |One|) (137 . /) (143 . +) (149 . *)
              (155 . |convert|) (160 . +) (166 . *) (172 . *) '"first"
              (178 . |setelt|) (185 . |One|) (|List| 34) (189 . |elt|)
              (195 . |univariate|) (|PrimitiveArray| 77)
              (|SparseUnivariatePolynomial| 34) (|SubResultantPackage| 34 77)
              (201 . |subresultantVector|) (207 . |multivariate|)
              (213 . |primitivePart|) (218 . |primitivePart|) (|Boolean|)
              (224 . |zero?|) (229 . |Zero|) (|List| 30)
              |INFSP;innerSolve;2LLParL;10| (233 . |leadingCoefficient|)
              (238 . |gcd|) (244 . |One|) (248 . =) (254 . =))
           '#(|makeEq| 260 |innerSolve1| 266 |innerSolve| 278) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 92
                                                 '(1 10 0 9 11 1 12 0 9 13 1 14
                                                   0 9 15 1 16 0 9 17 1 18 9 0
                                                   19 1 18 9 0 20 2 16 0 12 12
                                                   21 1 18 14 0 22 1 24 0 23 25
                                                   1 24 0 7 26 2 27 0 24 24 28
                                                   2 35 24 33 34 36 3 24 0 0 23
                                                   7 37 2 24 38 0 23 39 0 6 0
                                                   40 0 7 0 41 2 43 24 0 42 44
                                                   1 24 0 0 45 1 24 7 0 46 1 43
                                                   24 0 47 2 7 0 0 0 48 1 10 12
                                                   0 49 1 34 50 0 51 2 55 54 50
                                                   8 56 2 60 58 59 12 61 0 7 0
                                                   62 2 12 0 9 9 63 2 12 0 0 0
                                                   64 2 12 0 0 0 65 1 12 10 0
                                                   66 2 7 0 0 0 67 2 7 0 0 0 68
                                                   2 7 0 9 0 69 3 30 7 0 70 7
                                                   71 0 6 0 72 2 73 34 0 9 74 2
                                                   34 38 0 23 75 2 78 76 77 77
                                                   79 2 34 0 38 23 80 1 34 0 0
                                                   81 2 34 0 0 23 82 1 34 83 0
                                                   84 0 34 0 85 1 77 34 0 88 2
                                                   34 0 0 0 89 0 34 0 90 2 34
                                                   83 0 0 91 2 73 83 0 0 92 2 0
                                                   29 30 31 32 2 0 30 34 8 53 2
                                                   0 30 50 8 52 4 0 86 73 73 31
                                                   8 87)))))
           '|lookupComplete|)) 
