
(/VERSIONCHECK 2) 

(DEFUN |SYSSOLP;makeR2F| (|r| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 8)) (QREFELT $ 10))) 

(DEFUN |SYSSOLP;makeP2F| (|p| $)
  (PROG (|lv| |v| #0=#:G1837)
    (RETURN
      (SEQ (LETT |lv| (SPADCALL |p| (QREFELT $ 13))
                 . #1=(|SYSSOLP;makeP2F|))
           (EXIT (COND
                   ((SPADCALL |lv| NIL (QREFELT $ 15))
                    (SPADCALL |p| (QREFELT $ 16)))
                   ('T
                    (SEQ (SEQ (LETT |v| NIL . #1#)
                              (LETT #0# |lv| . #1#) G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |v| (CAR #0#) . #1#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (LETT |p|
                                     (SPADCALL |p| |v| (QREFELT $ 19)) . #1#)))
                              (LETT #0# (CDR #0#) . #1#) (GO G190) G191
                              (EXIT NIL))
                         (EXIT (SPADCALL |p| (QREFELT $ 16))))))))))) 

(DEFUN |SYSSOLP;makeEq| (|p| |lv| $)
  (PROG (|z| |np| |lx| |x| #0=#:G1842 #1=#:G1839 |up|)
    (RETURN
      (SEQ (LETT |z| (SPADCALL |lv| (QREFELT $ 20))
                 . #2=(|SYSSOLP;makeEq|))
           (LETT |np|
                 (SPADCALL (|SYSSOLP;makeP2F| |p| $) (QREFELT $ 21)) . #2#)
           (LETT |lx| (SPADCALL |np| (QREFELT $ 22)) . #2#)
           (SEQ (EXIT (SEQ (LETT |x| NIL . #2#) (LETT #0# |lv| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |x| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL |x| |lx|
                                          (QREFELT $ 23))
                                         (PROGN
                                           (LETT #1# |x| . #2#)
                                           (GO #1#))))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL)))
                #1# (EXIT #1#))
           (LETT |up| (SPADCALL |np| |x| (QREFELT $ 25)) . #2#)
           (EXIT (COND
                   ((EQL (SPADCALL |up| (QREFELT $ 28)) 1)
                    (SPADCALL
                        (SPADCALL (SPADCALL |x| (QREFELT $ 30))
                            (QREFELT $ 10))
                        (SPADCALL
                            (SPADCALL (SPADCALL |up| 0 (QREFELT $ 33))
                                (SPADCALL |up| (QREFELT $ 34))
                                (QREFELT $ 35))
                            (QREFELT $ 36))
                        (QREFELT $ 38)))
                   ('T
                    (SPADCALL (SPADCALL |np| (QREFELT $ 10))
                        (|spadConstant| $ 32) (QREFELT $ 38))))))))) 

(DEFUN |SYSSOLP;varInF| (|v| $)
  (SPADCALL (SPADCALL |v| (QREFELT $ 30)) (QREFELT $ 10))) 

(DEFUN |SYSSOLP;newInF| (|n| $)
  (|SYSSOLP;varInF| (SPADCALL (QREFELT $ 39)) $)) 

(DEFUN |SYSSOLP;testDegree| (|f| |lv| $)
  (PROG (|vv| #0=#:G1849 #1=#:G1847 #2=#:G1845 #3=#:G1846)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|SYSSOLP;testDegree|))
             (SEQ (LETT |vv| NIL . #4#) (LETT #0# |lv| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |vv| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (< 0
                                      (SPADCALL |f| |vv|
                                       (QREFELT $ 42))) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (COND (#2# 'T) ('T #1#)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T 'NIL))))))) 

(DEFUN |SYSSOLP;triangularSystems;LLL;7| (|lf| |lv| $)
  (PROG (|p| |fp| #0=#:G1875 |ff| #1=#:G1876 |dmp| OV DP |push|
             #2=#:G1877 |vv| #3=#:G1878 #4=#:G1856 |lvv| #5=#:G1879
             #6=#:G1880 |df| |lq| #7=#:G1881 |f| #8=#:G1882 |lp| |gb|
             #9=#:G1883 #10=#:G1884 |fq| #11=#:G1885 #12=#:G1864
             #13=#:G1862 #14=#:G1863 |parRes| #15=#:G1886 |pr|
             #16=#:G1887 #17=#:G1888 |pf| #18=#:G1889)
    (RETURN
      (SEQ (COND
             ((OR (NULL |lv|) (NULL |lf|)) NIL)
             ((EQL (LENGTH |lf|) 1)
              (SEQ (LETT |p|
                         (SPADCALL (|SPADfirst| |lf|) (QREFELT $ 21))
                         . #19=(|SYSSOLP;triangularSystems;LLL;7|))
                   (LETT |fp| (SPADCALL |p| (QREFELT $ 45)) . #19#)
                   (EXIT (PROGN
                           (LETT #0# NIL . #19#)
                           (SEQ (LETT |ff| NIL . #19#)
                                (LETT #1#
                                      (SPADCALL |fp| (QREFELT $ 48)) . #19#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |ff| (CAR #1#) . #19#)
                                      NIL))
                                   #20=(GO G191)))
                                (SEQ (EXIT
                                      (COND
                                        ((|SYSSOLP;testDegree|
                                          (QCAR |ff|) |lv| $)
                                         (LETT #0#
                                          (CONS (LIST (QCAR |ff|)) #0#) . #19#)))))
                                (LETT #1# (CDR #1#) . #19#)
                                #21=(GO G190) G191
                                (EXIT (NREVERSE0 #0#)))))))
             ('T
              (SEQ (LETT |dmp|
                         (|DistributedMultivariatePolynomial| |lv|
                             (|Polynomial| (QREFELT $ 6))) . #19#)
                   (LETT OV (|OrderedVariableList| |lv|) . #19#)
                   (LETT DP
                         (|DirectProduct| (LENGTH |lv|)
                             (|NonNegativeInteger|)) . #19#)
                   (LETT |push|
                         (|PushVariables| (QREFELT $ 6) DP OV |dmp|) . #19#)
                   (LETT |lvv|
                         (PROGN
                           (LETT #2# NIL . #19#)
                           (SEQ (LETT |vv| NIL . #19#)
                                (LETT #3# |lv| . #19#) G190
                                (COND
                                  ((OR (ATOM #3#)
                                    (PROGN
                                      (LETT |vv| (CAR #3#) . #19#)
                                      NIL))
                                   #20#))
                                (SEQ (EXIT
                                      (LETT #2#
                                       (CONS
                                        (PROG2
                                         (LETT #4#
                                          (SPADCALL |vv|
                                           (|compiledLookupCheck|
                                            '|variable|
                                            (LIST
                                             (LIST '|Union| '$
                                              '"failed")
                                             (LIST '|Symbol|))
                                            OV)) . #19#)
                                         (QCDR #4#)
                                          (|check-union| (QEQCAR #4# 0)
                                           OV #4#))
                                        #2#) . #19#)))
                                (LETT #3# (CDR #3#) . #19#) #21# G191
                                (EXIT (NREVERSE0 #2#)))) . #19#)
                   (LETT |lq|
                         (PROGN
                           (LETT #5# NIL . #19#)
                           (SEQ (LETT |f| NIL . #19#)
                                (LETT #6# |lf| . #19#) G190
                                (COND
                                  ((OR (ATOM #6#)
                                    (PROGN
                                      (LETT |f| (CAR #6#) . #19#)
                                      NIL))
                                   #20#))
                                (SEQ (EXIT
                                      (COND
                                        ((SEQ
                                          (LETT |df|
                                           (SPADCALL |f|
                                            (QREFELT $ 49)) . #19#)
                                          (EXIT
                                           (COND
                                             ((SPADCALL |df|
                                               (|spadConstant| $ 51)
                                               (QREFELT $ 52))
                                              'NIL)
                                             ('T 'T))))
                                         (LETT #5#
                                          (CONS
                                           (SPADCALL
                                            (SPADCALL |df|
                                             (|compiledLookupCheck|
                                              '|coerce|
                                              (LIST '$
                                               (LIST '|Polynomial|
                                                (|devaluate| (ELT $ 6))))
                                              |dmp|))
                                            |lvv|
                                            (|compiledLookupCheck|
                                             '|pushup|
                                             (LIST (|devaluate| |dmp|)
                                              (|devaluate| |dmp|)
                                              (LIST '|List|
                                               (|devaluate| OV)))
                                             |push|))
                                           #5#) . #19#)))))
                                (LETT #6# (CDR #6#) . #19#) #21# G191
                                (EXIT (NREVERSE0 #5#)))) . #19#)
                   (LETT |lp|
                         (PROGN
                           (LETT #7# NIL . #19#)
                           (SEQ (LETT |f| NIL . #19#)
                                (LETT #8# |lf| . #19#) G190
                                (COND
                                  ((OR (ATOM #8#)
                                    (PROGN
                                      (LETT |f| (CAR #8#) . #19#)
                                      NIL))
                                   #20#))
                                (SEQ (EXIT
                                      (LETT #7#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |f| (QREFELT $ 21))
                                          (|compiledLookupCheck|
                                           '|coerce|
                                           (LIST '$
                                            (LIST '|Polynomial|
                                             (|devaluate| (ELT $ 6))))
                                           |dmp|))
                                         |lvv|
                                         (|compiledLookupCheck|
                                          '|pushup|
                                          (LIST (|devaluate| |dmp|)
                                           (|devaluate| |dmp|)
                                           (LIST '|List|
                                            (|devaluate| OV)))
                                          |push|))
                                        #7#) . #19#)))
                                (LETT #8# (CDR #8#) . #19#) #21# G191
                                (EXIT (NREVERSE0 #7#)))) . #19#)
                   (LETT |parRes|
                         (SPADCALL |lp| |lvv|
                             (|compiledLookupCheck| '|groebSolve|
                                 (LIST (LIST '|List|
                                        (LIST '|List|
                                         (LIST
                                          '|DistributedMultivariatePolynomial|
                                          |lv|
                                          (LIST '|Polynomial|
                                           (|devaluate| (ELT $ 6))))))
                                       (LIST '|List|
                                        (LIST
                                         '|DistributedMultivariatePolynomial|
                                         |lv|
                                         (LIST '|Polynomial|
                                          (|devaluate| (ELT $ 6)))))
                                       (LIST '|List|
                                        (LIST '|OrderedVariableList|
                                         |lv|)))
                                 (|GroebnerSolve| |lv|
                                     (|Polynomial| (ELT $ 6))
                                     (ELT $ 6)))) . #19#)
                   (COND
                     ((NULL (SPADCALL |lq| NIL
                                (|compiledLookupCheck| '=
                                    (LIST (LIST '|Boolean|) '$ '$)
                                    (|List| |dmp|))))
                      (SEQ (LETT |gb|
                                 (|GroebnerInternalPackage|
                                     (|Polynomial| (QREFELT $ 6))
                                     (|DirectProduct| (LENGTH |lv|)
                                      (|NonNegativeInteger|))
                                     OV |dmp|) . #19#)
                           (EXIT (LETT |parRes|
                                       (PROGN
                                         (LETT #9# NIL . #19#)
                                         (SEQ (LETT |pr| NIL . #19#)
                                          (LETT #10# |parRes| . #19#)
                                          G190
                                          (COND
                                            ((OR (ATOM #10#)
                                              (PROGN
                                                (LETT |pr|
                                                 (CAR #10#) . #19#)
                                                NIL))
                                             #20#))
                                          (SEQ
                                           (EXIT
                                            (COND
                                              ((PROGN
                                                 (LETT #14# NIL . #19#)
                                                 (SEQ
                                                  (LETT |fq|
                                                   NIL . #19#)
                                                  (LETT #11#
                                                   |lq| . #19#)
                                                  G190
                                                  (COND
                                                    ((OR (ATOM #11#)
                                                      (PROGN
                                                        (LETT |fq|
                                                         (CAR #11#) . #19#)
                                                        NIL))
                                                     #20#))
                                                  (SEQ
                                                   (EXIT
                                                    (PROGN
                                                      (LETT #12#
                                                       (COND
                                                         ((SPADCALL
                                                           (SPADCALL
                                                            |fq| |pr|
                                                            (|compiledLookupCheck|
                                                             '|redPol|
                                                             (LIST
                                                              (|devaluate|
                                                               |dmp|)
                                                              (|devaluate|
                                                               |dmp|)
                                                              (LIST
                                                               '|List|
                                                               (|devaluate|
                                                                |dmp|)))
                                                             |gb|))
                                                           (SPADCALL
                                                            (|compiledLookupCheck|
                                                             '|Zero|
                                                             (LIST '$)
                                                             |dmp|))
                                                           (|compiledLookupCheck|
                                                            '=
                                                            (LIST
                                                             (LIST
                                                              '|Boolean|)
                                                             '$ '$)
                                                            |dmp|))
                                                          'NIL)
                                                         ('T 'T)) . #19#)
                                                      (COND
                                                        (#14#
                                                         (LETT #13#
                                                          (COND
                                                            (#13# #12#)
                                                            ('T 'NIL)) . #19#))
                                                        ('T
                                                         (PROGN
                                                           (LETT #13#
                                                            #12# . #19#)
                                                           (LETT #14#
                                                            'T . #19#)))))))
                                                  (LETT #11#
                                                   (CDR #11#) . #19#)
                                                  #21# G191 (EXIT NIL))
                                                 (COND
                                                   (#14# #13#)
                                                   ('T 'T)))
                                               (LETT #9#
                                                (CONS |pr| #9#) . #19#)))))
                                          (LETT #10# (CDR #10#) . #19#)
                                          #21# G191
                                          (EXIT (NREVERSE0 #9#)))) . #19#)))))
                   (EXIT (PROGN
                           (LETT #15# NIL . #19#)
                           (SEQ (LETT |pr| NIL . #19#)
                                (LETT #16# |parRes| . #19#) G190
                                (COND
                                  ((OR (ATOM #16#)
                                    (PROGN
                                      (LETT |pr| (CAR #16#) . #19#)
                                      NIL))
                                   #20#))
                                (SEQ (EXIT
                                      (LETT #15#
                                       (CONS
                                        (PROGN
                                          (LETT #17# NIL . #19#)
                                          (SEQ (LETT |pf| NIL . #19#)
                                           (LETT #18# |pr| . #19#) G190
                                           (COND
                                             ((OR (ATOM #18#)
                                               (PROGN
                                                 (LETT |pf|
                                                  (CAR #18#) . #19#)
                                                 NIL))
                                              #20#))
                                           (SEQ
                                            (EXIT
                                             (LETT #17#
                                              (CONS
                                               (SPADCALL
                                                (SPADCALL |pf| |lvv|
                                                 (|compiledLookupCheck|
                                                  '|pushdown|
                                                  (LIST
                                                   (|devaluate| |dmp|)
                                                   (|devaluate| |dmp|)
                                                   (LIST '|List|
                                                    (|devaluate| OV)))
                                                  |push|))
                                                (|compiledLookupCheck|
                                                 '|retract|
                                                 (LIST
                                                  (LIST '|Polynomial|
                                                   (|devaluate|
                                                    (ELT $ 6)))
                                                  '$)
                                                 |dmp|))
                                               #17#) . #19#)))
                                           (LETT #18#
                                            (CDR #18#) . #19#)
                                           #21# G191
                                           (EXIT (NREVERSE0 #17#))))
                                        #15#) . #19#)))
                                (LETT #16# (CDR #16#) . #19#) #21# G191
                                (EXIT (NREVERSE0 #15#)))))))))))) 

(DEFUN |SYSSOLP;solve;FL;8| (|pol| $)
  (PROG (|lv|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |pol| (QREFELT $ 56))
              (|error| "equation is always satisfied"))
             ('T
              (SEQ (LETT |lv|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |pol| (QREFELT $ 21))
                                     (QREFELT $ 22))
                                 (SPADCALL
                                     (SPADCALL |pol| (QREFELT $ 49))
                                     (QREFELT $ 22))
                                 (QREFELT $ 57))
                             (QREFELT $ 58))
                         |SYSSOLP;solve;FL;8|)
                   (EXIT (COND
                           ((NULL |lv|)
                            (|error| "inconsistent equation"))
                           ((< 1 (LENGTH |lv|))
                            (|error| "too many variables"))
                           ('T
                            (SPADCALL |pol| (|SPADfirst| |lv|)
                                (QREFELT $ 61)))))))))))) 

(DEFUN |SYSSOLP;solve;EL;9| (|eq| $)
  (PROG (|pol| |lv|)
    (RETURN
      (SEQ (LETT |pol|
                 (SPADCALL (SPADCALL |eq| (QREFELT $ 63))
                     (SPADCALL |eq| (QREFELT $ 64)) (QREFELT $ 65))
                 . #0=(|SYSSOLP;solve;EL;9|))
           (EXIT (COND
                   ((SPADCALL |pol| (QREFELT $ 56))
                    (|error| "equation is always satisfied"))
                   ('T
                    (SEQ (LETT |lv|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |pol| (QREFELT $ 21))
                                     (QREFELT $ 22))
                                    (SPADCALL
                                     (SPADCALL |pol| (QREFELT $ 49))
                                     (QREFELT $ 22))
                                    (QREFELT $ 57))
                                   (QREFELT $ 58)) . #0#)
                         (EXIT (COND
                                 ((NULL |lv|)
                                  (|error| "inconsistent equation"))
                                 ((< 1 (LENGTH |lv|))
                                  (|error| "too many variables"))
                                 ('T
                                  (SPADCALL |pol| (|SPADfirst| |lv|)
                                      (QREFELT $ 61))))))))))))) 

(DEFUN |SYSSOLP;solve;ESL;10| (|eq| |var| $)
  (SPADCALL
      (SPADCALL (SPADCALL |eq| (QREFELT $ 63))
          (SPADCALL |eq| (QREFELT $ 64)) (QREFELT $ 65))
      |var| (QREFELT $ 61))) 

(DEFUN |SYSSOLP;solve;FSL;11| (|pol| |var| $)
  (PROG (|p| |fp| #0=#:G1904 |ff| #1=#:G1905)
    (RETURN
      (SEQ (COND
             ((|HasCategory| (QREFELT $ 6) '(|GcdDomain|))
              (SEQ (LETT |p|
                         (SPADCALL (SPADCALL |pol| (QREFELT $ 21))
                             |var| (QREFELT $ 68))
                         . #2=(|SYSSOLP;solve;FSL;11|))
                   (LETT |fp| (SPADCALL |p| (QREFELT $ 45)) . #2#)
                   (EXIT (PROGN
                           (LETT #0# NIL . #2#)
                           (SEQ (LETT |ff| NIL . #2#)
                                (LETT #1#
                                      (SPADCALL |fp| (QREFELT $ 48)) . #2#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |ff| (CAR #1#) . #2#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (|SYSSOLP;makeEq|
                                         (SPADCALL
                                          (CONS
                                           (|function|
                                            |SYSSOLP;makeR2F|)
                                           $)
                                          (QCAR |ff|) (QREFELT $ 71))
                                         (LIST |var|) $)
                                        #0#) . #2#)))
                                (LETT #1# (CDR #1#) . #2#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#)))))))
             ('T NIL)))))) 

(DEFUN |SYSSOLP;makePolys| (|l| $)
  (PROG (#0=#:G1908 |e| #1=#:G1909)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|SYSSOLP;makePolys|))
             (SEQ (LETT |e| NIL . #2#) (LETT #1# |l| . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |e| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS
                                    (SPADCALL
                                     (SPADCALL |e| (QREFELT $ 63))
                                     (SPADCALL |e| (QREFELT $ 64))
                                     (QREFELT $ 65))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |SYSSOLP;linSolve| (|lp| |lv| $)
  (PROG (#0=#:G1929 |f| #1=#:G1930 |lr| |rec| #2=#:G1920 |rhs| |zeron|
            |p| #3=#:G1931 |sym| #4=#:G1932 |i| #5=#:G1933 |eqs|)
    (RETURN
      (SEQ (LETT |lr|
                 (PROGN
                   (LETT #0# NIL . #6=(|SYSSOLP;linSolve|))
                   (SEQ (LETT |f| NIL . #6#) (LETT #1# |lp| . #6#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |f| (CAR #1#) . #6#) NIL))
                           #7=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (SPADCALL |f| (QREFELT $ 21))
                                     #0#) . #6#)))
                        (LETT #1# (CDR #1#) . #6#) #8=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #6#)
           (LETT |rec| (SPADCALL |lr| |lv| (QREFELT $ 76)) . #6#)
           (EXIT (COND
                   ((QEQCAR (QCAR |rec|) 1) (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |rhs|
                               (PROG2 (LETT #2# (QCAR |rec|) . #6#)
                                      (QCDR #2#)
                                 (|check-union| (QEQCAR #2# 0)
                                     (|Vector|
                                      (|Fraction|
                                       (|Polynomial| (QREFELT $ 6))))
                                     #2#)) . #6#)
                         (LETT |zeron|
                               (SPADCALL (LENGTH |lv|) (QREFELT $ 78)) . #6#)
                         (SEQ (LETT |p| NIL . #6#)
                              (LETT #3# (QCDR |rec|) . #6#) G190
                              (COND
                                ((OR (ATOM #3#)
                                     (PROGN
                                       (LETT |p| (CAR #3#) . #6#)
                                       NIL))
                                 #7#))
                              (SEQ (EXIT
                                    (COND
                                      ((COND
                                         ((SPADCALL |p| |zeron|
                                           (QREFELT $ 79))
                                          'NIL)
                                         ('T 'T))
                                       (SEQ
                                        (LETT |sym|
                                         (|SYSSOLP;newInF| 1 $) . #6#)
                                        (EXIT
                                         (SEQ (LETT |i| 1 . #6#)
                                          (LETT #4#
                                           (LENGTH |lv|) . #6#)
                                          G190
                                          (COND
                                            ((QSGREATERP |i| #4#) #7#))
                                          (SEQ
                                           (EXIT
                                            (SPADCALL |rhs| |i|
                                             (SPADCALL
                                              (SPADCALL |rhs| |i|
                                               (QREFELT $ 81))
                                              (SPADCALL |sym|
                                               (SPADCALL |p| |i|
                                                (QREFELT $ 81))
                                               (QREFELT $ 82))
                                              (QREFELT $ 83))
                                             (QREFELT $ 84))))
                                          (LETT |i| (QSADD1 |i|) . #6#)
                                          #8# G191 (EXIT NIL))))))))
                              (LETT #3# (CDR #3#) . #6#) #8# G191
                              (EXIT NIL))
                         (LETT |eqs| NIL . #6#)
                         (SEQ (LETT |i| 1 . #6#)
                              (LETT #5# (LENGTH |lv|) . #6#) G190
                              (COND ((QSGREATERP |i| #5#) #7#))
                              (SEQ (EXIT
                                    (LETT |eqs|
                                     (APPEND |eqs|
                                      (LIST
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |lv| |i|
                                           (QREFELT $ 85))
                                          (QREFELT $ 30))
                                         (QREFELT $ 10))
                                        (SPADCALL |rhs| |i|
                                         (QREFELT $ 81))
                                        (QREFELT $ 86)))) . #6#)))
                              (LETT |i| (QSADD1 |i|) . #6#) #8# G191
                              (EXIT NIL))
                         (EXIT (CONS 0 |eqs|)))))))))) 

(DEFUN |SYSSOLP;solve;LL;14| (|lr| $)
  (PROG (|p| #0=#:G1939 #1=#:G1936 #2=#:G1934 #3=#:G1935 |lv|)
    (RETURN
      (SEQ (LETT |lv|
                 (PROGN
                   (LETT #3# NIL . #4=(|SYSSOLP;solve;LL;14|))
                   (SEQ (LETT |p| NIL . #4#) (LETT #0# |lr| . #4#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |p| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1#
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 21))
                                        (QREFELT $ 22))
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 49))
                                        (QREFELT $ 22))
                                       (QREFELT $ 87)) . #4#)
                                     (COND
                                       (#3#
                                        (LETT #2#
                                         (SPADCALL #2# #1#
                                          (QREFELT $ 87)) . #4#))
                                       ('T
                                        (PROGN
                                          (LETT #2# #1# . #4#)
                                          (LETT #3# 'T . #4#)))))))
                        (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                        (EXIT NIL))
                   (COND (#3# #2#) ('T (|IdentityError| '|setUnion|)))) . #4#)
           (EXIT (SPADCALL |lr| |lv| (QREFELT $ 89))))))) 

(DEFUN |SYSSOLP;solve;LL;15| (|le| $)
  (PROG (|lr| |p| #0=#:G1945 #1=#:G1942 #2=#:G1940 #3=#:G1941 |lv|)
    (RETURN
      (SEQ (LETT |lr| (|SYSSOLP;makePolys| |le| $)
                 . #4=(|SYSSOLP;solve;LL;15|))
           (LETT |lv|
                 (PROGN
                   (LETT #3# NIL . #4#)
                   (SEQ (LETT |p| NIL . #4#) (LETT #0# |lr| . #4#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |p| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1#
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 21))
                                        (QREFELT $ 22))
                                       (SPADCALL
                                        (SPADCALL |p| (QREFELT $ 49))
                                        (QREFELT $ 22))
                                       (QREFELT $ 87)) . #4#)
                                     (COND
                                       (#3#
                                        (LETT #2#
                                         (SPADCALL #2# #1#
                                          (QREFELT $ 87)) . #4#))
                                       ('T
                                        (PROGN
                                          (LETT #2# #1# . #4#)
                                          (LETT #3# 'T . #4#)))))))
                        (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                        (EXIT NIL))
                   (COND (#3# #2#) ('T (|IdentityError| '|setUnion|)))) . #4#)
           (EXIT (SPADCALL |lr| |lv| (QREFELT $ 89))))))) 

(DEFUN |SYSSOLP;solve;LLL;16| (|le| |lv| $)
  (SPADCALL (|SYSSOLP;makePolys| |le| $) |lv| (QREFELT $ 89))) 

(DEFUN |SYSSOLP;checkLinear| (|lr| |vl| $)
  (PROG (#0=#:G1958 #1=#:G1959 |ld| |f| #2=#:G1960 |x| #3=#:G1961
            #4=#:G1950 #5=#:G1948 #6=#:G1949 #7=#:G1957 |pol|
            #8=#:G1962 #9=#:G1955 #10=#:G1953 #11=#:G1954)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ld|
                            (PROGN
                              (LETT #0# NIL
                                    . #12=(|SYSSOLP;checkLinear|))
                              (SEQ (LETT |pol| NIL . #12#)
                                   (LETT #1# |lr| . #12#) G190
                                   (COND
                                     ((OR (ATOM #1#)
                                       (PROGN
                                         (LETT |pol| (CAR #1#) . #12#)
                                         NIL))
                                      #13=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (LETT #0#
                                      (CONS
                                       (SPADCALL |pol| (QREFELT $ 49))
                                       #0#) . #12#)))
                                   (LETT #1# (CDR #1#) . #12#)
                                   #14=(GO G190) G191
                                   (EXIT (NREVERSE0 #0#)))) . #12#)
                      (SEQ (LETT |f| NIL . #12#) (LETT #2# |ld| . #12#)
                           G190
                           (COND
                             ((OR (ATOM #2#)
                                  (PROGN
                                    (LETT |f| (CAR #2#) . #12#)
                                    NIL))
                              #13#))
                           (SEQ (EXIT (COND
                                        ((PROGN
                                           (LETT #6# NIL . #12#)
                                           (SEQ (LETT |x| NIL . #12#)
                                            (LETT #3#
                                             (SPADCALL |f|
                                              (QREFELT $ 22)) . #12#)
                                            G190
                                            (COND
                                              ((OR (ATOM #3#)
                                                (PROGN
                                                  (LETT |x|
                                                   (CAR #3#) . #12#)
                                                  NIL))
                                               #13#))
                                            (SEQ
                                             (EXIT
                                              (PROGN
                                                (LETT #4#
                                                 (SPADCALL |x| |vl|
                                                  (QREFELT $ 23)) . #12#)
                                                (COND
                                                  (#6#
                                                   (LETT #5#
                                                    (COND
                                                      (#5# 'T)
                                                      ('T #4#)) . #12#))
                                                  ('T
                                                   (PROGN
                                                     (LETT #5#
                                                      #4# . #12#)
                                                     (LETT #6#
                                                      'T . #12#)))))))
                                            (LETT #3# (CDR #3#) . #12#)
                                            #14# G191 (EXIT NIL))
                                           (COND (#6# #5#) ('T 'NIL)))
                                         (PROGN
                                           (LETT #7# 'NIL . #12#)
                                           (GO #7#))))))
                           (LETT #2# (CDR #2#) . #12#) #14# G191
                           (EXIT NIL))
                      (EXIT (PROGN
                              (LETT #11# NIL . #12#)
                              (SEQ (LETT |pol| NIL . #12#)
                                   (LETT #8# |lr| . #12#) G190
                                   (COND
                                     ((OR (ATOM #8#)
                                       (PROGN
                                         (LETT |pol| (CAR #8#) . #12#)
                                         NIL))
                                      #13#))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #9#
                                        (<
                                         (SPADCALL
                                          (SPADCALL |pol|
                                           (QREFELT $ 21))
                                          |vl| (QREFELT $ 93))
                                         2) . #12#)
                                       (COND
                                         (#11#
                                          (LETT #10#
                                           (COND (#10# #9#) ('T 'NIL)) . #12#))
                                         ('T
                                          (PROGN
                                            (LETT #10# #9# . #12#)
                                            (LETT #11# 'T . #12#)))))))
                                   (LETT #8# (CDR #8#) . #12#) #14#
                                   G191 (EXIT NIL))
                              (COND (#11# #10#) ('T 'T))))))
           #7# (EXIT #7#))))) 

(DEFUN |SYSSOLP;solve;LLL;18| (|lr| |vl| $)
  (PROG (|soln| |i| #0=#:G1973 |lhs| |rhs| |eqns| |parRes| #1=#:G1974
                |pr| #2=#:G1975 #3=#:G1976 |f| #4=#:G1977)
    (RETURN
      (SEQ (COND
             ((NULL |vl|) NIL)
             ((|SYSSOLP;checkLinear| |lr| |vl| $)
              (SEQ (LETT |soln| (|SYSSOLP;linSolve| |lr| |vl| $)
                         . #5=(|SYSSOLP;solve;LLL;18|))
                   (EXIT (COND
                           ((QEQCAR |soln| 1) NIL)
                           ('T
                            (SEQ (LETT |eqns| NIL . #5#)
                                 (SEQ (LETT |i| 1 . #5#)
                                      (LETT #0# (LENGTH |vl|) . #5#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         #6=(GO G191)))
                                      (SEQ
                                       (LETT |lhs|
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |vl| |i|
                                           (QREFELT $ 85))
                                          (QREFELT $ 30))
                                         (QREFELT $ 10)) . #5#)
                                       (LETT |rhs|
                                        (SPADCALL
                                         (SPADCALL (QCDR |soln|) |i|
                                          (QREFELT $ 94))
                                         (QREFELT $ 64)) . #5#)
                                       (EXIT
                                        (LETT |eqns|
                                         (APPEND |eqns|
                                          (LIST
                                           (SPADCALL |lhs| |rhs|
                                            (QREFELT $ 86)))) . #5#)))
                                      (LETT |i| (QSADD1 |i|) . #5#)
                                      #7=(GO G190) G191 (EXIT NIL))
                                 (EXIT (LIST |eqns|))))))))
             ((|HasCategory| (QREFELT $ 6) '(|GcdDomain|))
              (SEQ (LETT |parRes|
                         (SPADCALL |lr| |vl| (QREFELT $ 55)) . #5#)
                   (EXIT (PROGN
                           (LETT #1# NIL . #5#)
                           (SEQ (LETT |pr| NIL . #5#)
                                (LETT #2# |parRes| . #5#) G190
                                (COND
                                  ((OR (ATOM #2#)
                                    (PROGN
                                      (LETT |pr| (CAR #2#) . #5#)
                                      NIL))
                                   #6#))
                                (SEQ (EXIT
                                      (LETT #1#
                                       (CONS
                                        (PROGN
                                          (LETT #3# NIL . #5#)
                                          (SEQ (LETT |f| NIL . #5#)
                                           (LETT #4# |pr| . #5#) G190
                                           (COND
                                             ((OR (ATOM #4#)
                                               (PROGN
                                                 (LETT |f|
                                                  (CAR #4#) . #5#)
                                                 NIL))
                                              #6#))
                                           (SEQ
                                            (EXIT
                                             (LETT #3#
                                              (CONS
                                               (|SYSSOLP;makeEq|
                                                (SPADCALL
                                                 (CONS
                                                  (|function|
                                                   |SYSSOLP;makeR2F|)
                                                  $)
                                                 |f| (QREFELT $ 71))
                                                |vl| $)
                                               #3#) . #5#)))
                                           (LETT #4# (CDR #4#) . #5#)
                                           #7# G191
                                           (EXIT (NREVERSE0 #3#))))
                                        #1#) . #5#)))
                                (LETT #2# (CDR #2#) . #5#) #7# G191
                                (EXIT (NREVERSE0 #1#)))))))
             ('T (LIST NIL))))))) 

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

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

(MAKEPROP '|SystemSolvePackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Polynomial| 6)
             (0 . |coerce|) (|Fraction| 7) (5 . |coerce|) (|List| 17)
             (|Polynomial| 9) (10 . |variables|) (|Boolean|) (15 . =)
             (21 . |retract|) (|Symbol|)
             (|MPolyCatRationalFunctionFactorizer|
                 (|IndexedExponents| 17) 17 6 12)
             (26 . |pushdown|) (32 . |last|) (37 . |numer|)
             (42 . |variables|) (47 . |member?|)
             (|SparseUnivariatePolynomial| $) (53 . |univariate|)
             (|NonNegativeInteger|) (|SparseUnivariatePolynomial| 7)
             (59 . |degree|) (64 . |One|) (68 . |coerce|) (73 . |Zero|)
             (77 . |Zero|) (81 . |coefficient|)
             (87 . |leadingCoefficient|) (92 . /) (98 . -)
             (|Equation| 9) (103 . |equation|) (109 . |new|)
             (113 . |Zero|) (117 . |Zero|) (121 . |degree|)
             (|Factored| 7)
             (|GeneralizedMultivariateFactorize| 17
                 (|IndexedExponents| 17) 6 6 7)
             (127 . |factor|)
             (|Record| (|:| |factor| 7) (|:| |exponent| 80))
             (|List| 46) (132 . |factors|) (137 . |denom|)
             (142 . |One|) (146 . |One|) (150 . =) (|List| 74)
             (|List| 9) |SYSSOLP;triangularSystems;LLL;7|
             (156 . |zero?|) (161 . |concat|)
             (167 . |removeDuplicates|) (172 . |One|) (|List| 37)
             |SYSSOLP;solve;FSL;11| |SYSSOLP;solve;FL;8| (176 . |lhs|)
             (181 . |rhs|) (186 . -) |SYSSOLP;solve;EL;9|
             |SYSSOLP;solve;ESL;10| (192 . |primitivePart|)
             (|Mapping| 9 6) (|PolynomialFunctions2| 6 9) (198 . |map|)
             (|Union| 77 '"failed")
             (|Record| (|:| |particular| 72) (|:| |basis| (|List| 77)))
             (|List| 7)
             (|LinearSystemPolynomialPackage| 6 (|IndexedExponents| 17)
                 17 7)
             (204 . |linSolve|) (|Vector| 9) (210 . |zero|) (215 . =)
             (|Integer|) (221 . |elt|) (227 . *) (233 . +)
             (239 . |setelt|) (246 . |elt|) (252 . =)
             (258 . |setUnion|) (|List| 60) |SYSSOLP;solve;LLL;18|
             |SYSSOLP;solve;LL;14| |SYSSOLP;solve;LL;15|
             |SYSSOLP;solve;LLL;16| (264 . |totalDegree|)
             (270 . |elt|))
          '#(|triangularSystems| 276 |solve| 282) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 94
                                '(1 7 0 6 8 1 9 0 7 10 1 12 11 0 13 2
                                  11 14 0 0 15 1 12 9 0 16 2 18 12 12
                                  17 19 1 11 17 0 20 1 9 7 0 21 1 7 11
                                  0 22 2 11 14 17 0 23 2 7 24 0 17 25 1
                                  27 26 0 28 0 6 0 29 1 7 0 17 30 0 6 0
                                  31 0 9 0 32 2 27 7 0 26 33 1 27 7 0
                                  34 2 9 0 7 7 35 1 9 0 0 36 2 37 0 9 9
                                  38 0 17 0 39 0 37 0 40 0 7 0 41 2 7
                                  26 0 17 42 1 44 43 7 45 1 43 47 0 48
                                  1 9 7 0 49 0 9 0 50 0 7 0 51 2 7 14 0
                                  0 52 1 9 14 0 56 2 11 0 0 0 57 1 11 0
                                  0 58 0 37 0 59 1 37 9 0 63 1 37 9 0
                                  64 2 9 0 0 0 65 2 7 0 0 17 68 2 70 12
                                  69 7 71 2 75 73 74 11 76 1 77 0 26 78
                                  2 77 14 0 0 79 2 77 9 0 80 81 2 9 0 0
                                  0 82 2 9 0 0 0 83 3 77 9 0 80 9 84 2
                                  11 17 0 80 85 2 37 0 9 9 86 2 11 0 0
                                  0 87 2 7 26 0 11 93 2 60 37 0 80 94 2
                                  0 53 54 11 55 2 0 88 60 11 92 2 0 88
                                  54 11 89 1 0 88 60 91 1 0 88 54 90 2
                                  0 60 37 17 67 2 0 60 9 17 61 1 0 60 9
                                  62 1 0 60 37 66)))))
          '|lookupComplete|)) 
