
(/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 (#0=#:G1826 |r| #1=#:G1828 |x| #2=#:G1827)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #3=(|INFSP;makeEq;LLL;2|))
             (SEQ (LETT |r| NIL . #3#) (LETT #1# |nres| . #3#)
                  (LETT |x| NIL . #3#) (LETT #2# |lv| . #3#) G190
                  (COND
                    ((OR (ATOM #2#)
                         (PROGN (LETT |x| (CAR #2#) . #3#) NIL)
                         (ATOM #1#)
                         (PROGN (LETT |r| (CAR #1#) . #3#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |x| (QREFELT $ 25))
                                     (SPADCALL |r| (QREFELT $ 26))
                                     (QREFELT $ 28))
                                    #0#) . #3#)))
                  (LETT #2#
                        (PROG1 (CDR #2#) (LETT #1# (CDR #1#) . #3#)) . #3#)
                  (GO G190) G191 (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |INFSP;evaluate| (|pol| |xvar| |zvar| |z| $)
  (PROG (|rpp| |upol|)
    (RETURN
      (SEQ (LETT |rpp|
                 (SPADCALL (CONS (|function| |INFSP;numeric|) $) |pol|
                     (QREFELT $ 36))
                 . #0=(|INFSP;evaluate|))
           (LETT |rpp|
                 (SPADCALL |rpp| |zvar| |z| (QREFELT $ 37)) . #0#)
           (LETT |upol| (SPADCALL |rpp| |xvar| (QREFELT $ 39)) . #0#)
           (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 (#0=#:G1843 #1=#:G1844 |z| #2=#:G1845 |x| #3=#:G1846)
    (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))
                                  . #4=(|INFSP;innerSolve1;SupParL;6|))
                            (EXIT (PROGN
                                    (LETT #0# NIL . #4#)
                                    (SEQ (LETT |x| NIL . #4#)
                                     (LETT #1# |z| . #4#) G190
                                     (COND
                                       ((OR (ATOM #1#)
                                         (PROGN
                                           (LETT |x| (CAR #1#) . #4#)
                                           NIL))
                                        #5=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT #0#
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL 1 2
                                            (QREFELT $ 63))
                                           (SPADCALL (QCAR |x|)
                                            (QCDR |x|) (QREFELT $ 64))
                                           (QREFELT $ 65))
                                          (QREFELT $ 66))
                                         #0#) . #4#)))
                                     (LETT #1# (CDR #1#) . #4#)
                                     #6=(GO G190) G191
                                     (EXIT (NREVERSE0 #0#)))))))
                      ((|domainEqual| (QREFELT $ 7)
                           (|Fraction| (|Integer|)))
                       (SEQ (LETT |z|
                                  (SPADCALL |upol|
                                      (|INFSP;myConvert| |eps| $)
                                      (QREFELT $ 61)) . #4#)
                            (EXIT (PROGN
                                    (LETT #2# NIL . #4#)
                                    (SEQ (LETT |x| NIL . #4#)
                                     (LETT #3# |z| . #4#) G190
                                     (COND
                                       ((OR (ATOM #3#)
                                         (PROGN
                                           (LETT |x| (CAR #3#) . #4#)
                                           NIL))
                                        #5#))
                                     (SEQ
                                      (EXIT
                                       (LETT #2#
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL 1 2 (QREFELT $ 63))
                                          (SPADCALL (QCAR |x|)
                                           (QCDR |x|) (QREFELT $ 67))
                                          (QREFELT $ 68))
                                         #2#) . #4#)))
                                     (LETT #3# (CDR #3#) . #4#) #6#
                                     G191 (EXIT (NREVERSE0 #2#)))))))
                      (#7='T (|error| "improper arguments to INFSP"))))
                   (#7# (|error| "improper arguments to INFSP")))))))) 

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

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

(DEFUN |INFSP;innerSolve2| (|lp| |lv| |eps| $)
  (PROG (|mainvar| |up1| |up2| |vec| |p0| |p1|)
    (RETURN
      (SEQ (LETT |mainvar| (|SPADfirst| |lv|)
                 . #0=(|INFSP;innerSolve2|))
           (LETT |up1|
                 (SPADCALL (SPADCALL |lp| 1 (QREFELT $ 74)) |mainvar|
                     (QREFELT $ 75)) . #0#)
           (LETT |up2|
                 (SPADCALL (SPADCALL |lp| 2 (QREFELT $ 74)) |mainvar|
                     (QREFELT $ 75)) . #0#)
           (LETT |vec| (SPADCALL |up1| |up2| (QREFELT $ 79)) . #0#)
           (LETT |p0|
                 (SPADCALL
                     (SPADCALL (ELT |vec| 0) |mainvar| (QREFELT $ 80))
                     (QREFELT $ 81)) . #0#)
           (LETT |p1|
                 (SPADCALL
                     (SPADCALL (ELT |vec| 1) |mainvar| (QREFELT $ 80))
                     |mainvar| (QREFELT $ 82)) . #0#)
           (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 (#0=#:G1962 |p| #1=#:G1963 |lnp| OV #2=#:G1964 |vv| #3=#:G1965
            #4=#:G1869 |lvv| DP |dmp| #5=#:G1966 |q1| #6=#:G1967 |lq|
            |gb| #7=#:G1968 #8=#:G1969 |fq| #9=#:G1970 #10=#:G1875
            #11=#:G1873 #12=#:G1874 |rlv| |rrlvv| #13=#:G1971 |res1|
            |f| #14=#:G1972 #15=#:G1815 #16=#:G1973 #17=#:G1944
            #18=#:G1942 #19=#:G1943 #20=#:G1881 #21=#:G1879 #22=#:G1880
            |listGen| #23=#:G1945 #24=#:G1974 |pr| #25=#:G1975
            #26=#:G1976 #27=#:G1977 |listG| |res| #28=#:G1978
            #29=#:G1951 #30=#:G1949 #31=#:G1950 #32=#:G1979 |partRes|
            |gres| #33=#:G1980 |genRecord| |lgen| |lval| #34=#:G1981
            |pf| #35=#:G1982 |lgen1| |lris| #36=#:G1983 |r| #37=#:G1984
            |result|)
    (RETURN
      (SEQ (LETT |lnp|
                 (PROGN
                   (LETT #0# NIL . #38=(|INFSP;innerSolve;2LLParL;10|))
                   (SEQ (LETT |p| NIL . #38#) (LETT #1# |lp| . #38#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |p| (CAR #1#) . #38#) NIL))
                           #39=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |p|
                                      (|compiledLookupCheck| '|pToDmp|
                                       (LIST
                                        (LIST
                                         '|DistributedMultivariatePolynomial|
                                         |lv| (|devaluate| (ELT $ 6)))
                                        (LIST '|Polynomial|
                                         (|devaluate| (ELT $ 6))))
                                       (|PolToPol| |lv| (ELT $ 6))))
                                     #0#) . #38#)))
                        (LETT #1# (CDR #1#) . #38#) #40=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #38#)
           (LETT OV (|OrderedVariableList| |lv|) . #38#)
           (LETT |lvv|
                 (PROGN
                   (LETT #2# NIL . #38#)
                   (SEQ (LETT |vv| NIL . #38#) (LETT #3# |lv| . #38#)
                        G190
                        (COND
                          ((OR (ATOM #3#)
                               (PROGN
                                 (LETT |vv| (CAR #3#) . #38#)
                                 NIL))
                           #39#))
                        (SEQ (EXIT (LETT #2#
                                    (CONS
                                     (PROG2
                                      (LETT #4#
                                       (SPADCALL |vv|
                                        (|compiledLookupCheck|
                                         '|variable|
                                         (LIST
                                          (LIST '|Union| '$ '"failed")
                                          (LIST '|Symbol|))
                                         OV)) . #38#)
                                      (QCDR #4#)
                                       (|check-union| (QEQCAR #4# 0) OV
                                        #4#))
                                     #2#) . #38#)))
                        (LETT #3# (CDR #3#) . #38#) #40# G191
                        (EXIT (NREVERSE0 #2#)))) . #38#)
           (LETT DP
                 (|DirectProduct| (LENGTH |lv|) (|NonNegativeInteger|)) . #38#)
           (LETT |dmp|
                 (|DistributedMultivariatePolynomial| |lv|
                     (QREFELT $ 6)) . #38#)
           (LETT |lq| NIL . #38#)
           (COND
             ((NULL (SPADCALL |ld| NIL (QREFELT $ 92)))
              (LETT |lq|
                    (PROGN
                      (LETT #5# NIL . #38#)
                      (SEQ (LETT |q1| NIL . #38#)
                           (LETT #6# |ld| . #38#) G190
                           (COND
                             ((OR (ATOM #6#)
                                  (PROGN
                                    (LETT |q1| (CAR #6#) . #38#)
                                    NIL))
                              #39#))
                           (SEQ (EXIT (LETT #5#
                                       (CONS
                                        (SPADCALL |q1|
                                         (|compiledLookupCheck|
                                          '|pToDmp|
                                          (LIST
                                           (LIST
                                            '|DistributedMultivariatePolynomial|
                                            |lv|
                                            (|devaluate| (ELT $ 6)))
                                           (LIST '|Polynomial|
                                            (|devaluate| (ELT $ 6))))
                                          (|PolToPol| |lv| (ELT $ 6))))
                                        #5#) . #38#)))
                           (LETT #6# (CDR #6#) . #38#) #40# G191
                           (EXIT (NREVERSE0 #5#)))) . #38#)))
           (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)))) . #38#)
           (EXIT (COND
                   ((SPADCALL |partRes|
                        (SPADCALL NIL
                            (|compiledLookupCheck| '|list|
                                (LIST '$
                                      (LIST '|List|
                                       (|devaluate| |dmp|)))
                                (|List| (|List| |dmp|))))
                        (|compiledLookupCheck| '=
                            (LIST (LIST '|Boolean|) '$ '$)
                            (|List| (|List| |dmp|))))
                    NIL)
                   ('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|) . #38#)
                                 (EXIT (LETT |partRes|
                                        (PROGN
                                          (LETT #7# NIL . #38#)
                                          (SEQ (LETT |pr| NIL . #38#)
                                           (LETT #8# |partRes| . #38#)
                                           G190
                                           (COND
                                             ((OR (ATOM #8#)
                                               (PROGN
                                                 (LETT |pr|
                                                  (CAR #8#) . #38#)
                                                 NIL))
                                              #39#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((PROGN
                                                  (LETT #12#
                                                   NIL . #38#)
                                                  (SEQ
                                                   (LETT |fq|
                                                    NIL . #38#)
                                                   (LETT #9#
                                                    |lq| . #38#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #9#)
                                                       (PROGN
                                                         (LETT |fq|
                                                          (CAR #9#) . #38#)
                                                         NIL))
                                                      #39#))
                                                   (SEQ
                                                    (EXIT
                                                     (PROGN
                                                       (LETT #10#
                                                        (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)) . #38#)
                                                       (COND
                                                         (#12#
                                                          (LETT #11#
                                                           (COND
                                                             (#11#
                                                              #10#)
                                                             ('T 'NIL)) . #38#))
                                                         ('T
                                                          (PROGN
                                                            (LETT #11#
                                                             #10# . #38#)
                                                            (LETT #12#
                                                             'T . #38#)))))))
                                                   (LETT #9#
                                                    (CDR #9#) . #38#)
                                                   #40# G191
                                                   (EXIT NIL))
                                                  (COND
                                                    (#12# #11#)
                                                    ('T 'T)))
                                                (LETT #7#
                                                 (CONS |pr| #7#) . #38#)))))
                                           (LETT #8# (CDR #8#) . #38#)
                                           #40# G191
                                           (EXIT (NREVERSE0 #7#)))) . #38#)))))
                         (LETT |rlv| (REVERSE |lv|) . #38#)
                         (LETT |rrlvv| (CDR (REVERSE |lvv|)) . #38#)
                         (LETT |listGen| NIL . #38#)
                         (SEQ (LETT |res| NIL . #38#)
                              (LETT #13# |partRes| . #38#) G190
                              (COND
                                ((OR (ATOM #13#)
                                     (PROGN
                                       (LETT |res| (CAR #13#) . #38#)
                                       NIL))
                                 #39#))
                              (SEQ (EXIT
                                    (SEQ
                                     (LETT |res1|
                                      (CDR (REVERSE |res|)) . #38#)
                                     (EXIT
                                      (COND
                                        ((PROGN
                                           (LETT #22# NIL . #38#)
                                           (SEQ (LETT |f| NIL . #38#)
                                            (LETT #14# |res1| . #38#)
                                            G190
                                            (COND
                                              ((OR (ATOM #14#)
                                                (PROGN
                                                  (LETT |f|
                                                   (CAR #14#) . #38#)
                                                  NIL))
                                               #39#))
                                            (SEQ
                                             (EXIT
                                              (PROGN
                                                (LETT #20#
                                                 (EQL
                                                  (PROGN
                                                    (LETT #19#
                                                     NIL . #38#)
                                                    (SEQ
                                                     (LETT #15#
                                                      NIL . #38#)
                                                     (LETT #16#
                                                      (SPADCALL |f|
                                                       |rrlvv|
                                                       (|compiledLookupCheck|
                                                        '|degree|
                                                        (LIST
                                                         (LIST '|List|
                                                          (LIST
                                                           '|NonNegativeInteger|))
                                                         '$
                                                         (LIST '|List|
                                                          (LIST
                                                           '|OrderedVariableList|
                                                           |lv|)))
                                                        (|DistributedMultivariatePolynomial|
                                                         |lv|
                                                         (ELT $ 6)))) . #38#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #16#)
                                                         (PROGN
                                                           (LETT #15#
                                                            (CAR #16#) . #38#)
                                                           NIL))
                                                        #39#))
                                                     (SEQ
                                                      (EXIT
                                                       (PROGN
                                                         (LETT #17#
                                                          #15# . #38#)
                                                         (COND
                                                           (#19#
                                                            (LETT #18#
                                                             (MAX #18#
                                                              #17#) . #38#))
                                                           ('T
                                                            (PROGN
                                                              (LETT
                                                               #18#
                                                               #17# . #38#)
                                                              (LETT
                                                               #19#
                                                               'T . #38#)))))))
                                                     (LETT #16#
                                                      (CDR #16#) . #38#)
                                                     #40# G191
                                                     (EXIT NIL))
                                                    (COND
                                                      (#19# #18#)
                                                      ('T
                                                       (|IdentityError|
                                                        '|max|))))
                                                  1) . #38#)
                                                (COND
                                                  (#22#
                                                   (LETT #21#
                                                    (COND
                                                      (#21# #20#)
                                                      ('T 'NIL)) . #38#))
                                                  ('T
                                                   (PROGN
                                                     (LETT #21#
                                                      #20# . #38#)
                                                     (LETT #22#
                                                      'T . #38#)))))))
                                            (LETT #14#
                                             (CDR #14#) . #38#)
                                            #40# G191 (EXIT NIL))
                                           (COND (#22# #21#) ('T 'T)))
                                         (PROGN
                                           (LETT #23#
                                            (LETT |listGen|
                                             (CONS |res| |listGen|) . #38#) . #38#)
                                           (GO #23#)))))))
                                   #23# (EXIT #23#))
                              (LETT #13# (CDR #13#) . #38#) #40# G191
                              (EXIT NIL))
                         (LETT |result| NIL . #38#)
                         (COND
                           ((NULL (SPADCALL |listGen| NIL
                                      (|compiledLookupCheck| '=
                                       (LIST (LIST '|Boolean|) '$ '$)
                                       (|List| (|List| |dmp|)))))
                            (SEQ (LETT |listG|
                                       (PROGN
                                         (LETT #24# NIL . #38#)
                                         (SEQ (LETT |pr| NIL . #38#)
                                          (LETT #25# |listGen| . #38#)
                                          G190
                                          (COND
                                            ((OR (ATOM #25#)
                                              (PROGN
                                                (LETT |pr|
                                                 (CAR #25#) . #38#)
                                                NIL))
                                             #39#))
                                          (SEQ
                                           (EXIT
                                            (LETT #24#
                                             (CONS
                                              (PROGN
                                                (LETT #26# NIL . #38#)
                                                (SEQ
                                                 (LETT |pf| NIL . #38#)
                                                 (LETT #27#
                                                  |pr| . #38#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #27#)
                                                     (PROGN
                                                       (LETT |pf|
                                                        (CAR #27#) . #38#)
                                                       NIL))
                                                    #39#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT #26#
                                                    (CONS
                                                     (SPADCALL |pf|
                                                      (|compiledLookupCheck|
                                                       '|dmpToP|
                                                       (LIST
                                                        (LIST
                                                         '|Polynomial|
                                                         (|devaluate|
                                                          (ELT $ 6)))
                                                        (LIST
                                                         '|DistributedMultivariatePolynomial|
                                                         |lv|
                                                         (|devaluate|
                                                          (ELT $ 6))))
                                                       (|PolToPol| |lv|
                                                        (ELT $ 6))))
                                                     #26#) . #38#)))
                                                 (LETT #27#
                                                  (CDR #27#) . #38#)
                                                 #40# G191
                                                 (EXIT
                                                  (NREVERSE0 #26#))))
                                              #24#) . #38#)))
                                          (LETT #25# (CDR #25#) . #38#)
                                          #40# G191
                                          (EXIT (NREVERSE0 #24#)))) . #38#)
                                 (LETT |result|
                                       (PROGN
                                         (LETT #31# NIL . #38#)
                                         (SEQ (LETT |res| NIL . #38#)
                                          (LETT #28# |listG| . #38#)
                                          G190
                                          (COND
                                            ((OR (ATOM #28#)
                                              (PROGN
                                                (LETT |res|
                                                 (CAR #28#) . #38#)
                                                NIL))
                                             #39#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #29#
                                               (|INFSP;findGenZeros|
                                                |res| |rlv| |eps| $) . #38#)
                                              (COND
                                                (#31#
                                                 (LETT #30#
                                                  (APPEND #30# #29#) . #38#))
                                                ('T
                                                 (PROGN
                                                   (LETT #30#
                                                    #29# . #38#)
                                                   (LETT #31#
                                                    'T . #38#)))))))
                                          (LETT #28# (CDR #28#) . #38#)
                                          #40# G191 (EXIT NIL))
                                         (COND (#31# #30#) ('T NIL))) . #38#)
                                 (EXIT (SEQ (LETT |gres| NIL . #38#)
                                        (LETT #32# |listGen| . #38#)
                                        G190
                                        (COND
                                          ((OR (ATOM #32#)
                                            (PROGN
                                              (LETT |gres|
                                               (CAR #32#) . #38#)
                                              NIL))
                                           #39#))
                                        (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|)))) . #38#)))
                                        (LETT #32# (CDR #32#) . #38#)
                                        #40# G191 (EXIT NIL))))))
                         (SEQ (LETT |gres| NIL . #38#)
                              (LETT #33# |partRes| . #38#) G190
                              (COND
                                ((OR (ATOM #33#)
                                     (PROGN
                                       (LETT |gres| (CAR #33#) . #38#)
                                       NIL))
                                 #39#))
                              (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)))) . #38#)
                                   (LETT |lgen|
                                    (QCAR |genRecord|) . #38#)
                                   (LETT |lval|
                                    (QCDR |genRecord|) . #38#)
                                   (LETT |lgen1|
                                    (PROGN
                                      (LETT #34# NIL . #38#)
                                      (SEQ (LETT |pf| NIL . #38#)
                                       (LETT #35# |lgen| . #38#) G190
                                       (COND
                                         ((OR (ATOM #35#)
                                           (PROGN
                                             (LETT |pf|
                                              (CAR #35#) . #38#)
                                             NIL))
                                          #39#))
                                       (SEQ
                                        (EXIT
                                         (LETT #34#
                                          (CONS
                                           (SPADCALL |pf|
                                            (|compiledLookupCheck|
                                             '|dmpToP|
                                             (LIST
                                              (LIST '|Polynomial|
                                               (|devaluate| (ELT $ 6)))
                                              (LIST
                                               '|DistributedMultivariatePolynomial|
                                               |lv|
                                               (|devaluate| (ELT $ 6))))
                                             (|PolToPol| |lv|
                                              (ELT $ 6))))
                                           #34#) . #38#)))
                                       (LETT #35# (CDR #35#) . #38#)
                                       #40# G191
                                       (EXIT (NREVERSE0 #34#)))) . #38#)
                                   (LETT |lris|
                                    (|INFSP;findGenZeros| |lgen1| |rlv|
                                     |eps| $) . #38#)
                                   (EXIT
                                    (LETT |result|
                                     (APPEND
                                      (PROGN
                                        (LETT #36# NIL . #38#)
                                        (SEQ (LETT |r| NIL . #38#)
                                         (LETT #37# |lris| . #38#) G190
                                         (COND
                                           ((OR (ATOM #37#)
                                             (PROGN
                                               (LETT |r|
                                                (CAR #37#) . #38#)
                                               NIL))
                                            #39#))
                                         (SEQ
                                          (EXIT
                                           (LETT #36#
                                            (CONS
                                             (|INFSP;oldCoord| |r|
                                              |lval| $)
                                             #36#) . #38#)))
                                         (LETT #37# (CDR #37#) . #38#)
                                         #40# G191
                                         (EXIT (NREVERSE0 #36#))))
                                      |result|) . #38#)))
                              (LETT #33# (CDR #33#) . #38#) #40# G191
                              (EXIT NIL))
                         (EXIT |result|))))))))) 

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

(DEFUN |InnerNumericFloatSolvePackage;| (|#1| |#2| |#3|)
  (PROG (DV$1 DV$2 DV$3 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|InnerNumericFloatSolvePackage|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT |dv$|
              (LIST '|InnerNumericFloatSolvePackage| DV$1 DV$2 DV$3) . #0#)
        (LETT $ (GETREFV 93) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|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|)) 
