
(/VERSIONCHECK 2) 

(DEFUN |MFINFACT;convertPUP| (|lfg| $)
  (PROG (#0=#:G1855 |lff| #1=#:G1856)
    (RETURN
      (SEQ (CONS (QCAR |lfg|)
                 (PROGN
                   (LETT #0# NIL . #2=(|MFINFACT;convertPUP|))
                   (SEQ (LETT |lff| NIL . #2#)
                        (LETT #1# (QCDR |lfg|) . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |lff| (CAR #1#) . #2#)
                                 NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (CONS
                                      (SPADCALL (QCAR |lff|)
                                       (QREFELT $ 13))
                                      (QCDR |lff|))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#))))))))) 

(DEFUN |MFINFACT;supFactor| (|um| |dx| $)
  (PROG (|cf| #0=#:G1896 #1=#:G1860 #2=#:G1858 #3=#:G1859 |lvar| |mdeg|
              |f1| #4=#:G1866 |lfg| #5=#:G1895 |om| |sqfacs| |lcont|
              |flead| #6=#:G1897 |ff| #7=#:G1898 |sqqfact| |fact|
              #8=#:G1899 |ffactor| |ffexp| |ffcont| |coefs| #9=#:G1900
              |xx| #10=#:G1901 |fc| #11=#:G1902 #12=#:G1880 #13=#:G1878
              #14=#:G1879 |ldeg| |lf| #15=#:G1903 |lfp| #16=#:G1904
              |auxfl| |factorlist| |f| #17=#:G1905 #18=#:G1889
              #19=#:G1888 #20=#:G1886 #21=#:G1887 |lcfacs| #22=#:G1891)
    (RETURN
      (SEQ (EXIT (COND
                   ((EQL (SPADCALL |um| (QREFELT $ 15)) 0)
                    (|MFINFACT;convertPUP|
                        (|MFINFACT;mFactor|
                            (SPADCALL |um| (QREFELT $ 16)) |dx| $)
                        $))
                   ('T
                    (SEQ (LETT |lvar|
                               (PROGN
                                 (LETT #3# NIL
                                       . #23=(|MFINFACT;supFactor|))
                                 (SEQ (LETT |cf| NIL . #23#)
                                      (LETT #0#
                                       (SPADCALL |um| (QREFELT $ 18)) . #23#)
                                      G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |cf|
                                             (CAR #0#) . #23#)
                                            NIL))
                                         #24=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #1#
                                           (SPADCALL |cf|
                                            (QREFELT $ 20)) . #23#)
                                          (COND
                                            (#3#
                                             (LETT #2#
                                              (SPADCALL #2# #1#
                                               (QREFELT $ 21)) . #23#))
                                            ('T
                                             (PROGN
                                               (LETT #2# #1# . #23#)
                                               (LETT #3# 'T . #23#)))))))
                                      (LETT #0# (CDR #0#) . #23#)
                                      #25=(GO G190) G191 (EXIT NIL))
                                 (COND
                                   (#3# #2#)
                                   ('T (|IdentityError| '|setUnion|)))) . #23#)
                         (LETT |flead|
                               (CONS (|spadConstant| $ 25) NIL) . #23#)
                         (LETT |factorlist| NIL . #23#)
                         (LETT |mdeg|
                               (SPADCALL |um| (QREFELT $ 26)) . #23#)
                         (COND
                           ((< 0 |mdeg|)
                            (SEQ (LETT |f1|
                                       (SPADCALL (|spadConstant| $ 32)
                                        |mdeg| (QREFELT $ 33)) . #23#)
                                 (LETT |um|
                                       (PROG2
                                        (LETT #4#
                                         (SPADCALL |um| |f1|
                                          (QREFELT $ 35)) . #23#)
                                        (QCDR #4#)
                                         (|check-union| (QEQCAR #4# 0)
                                          (|SparseUnivariatePolynomial|
                                           (|SparseMultivariatePolynomial|
                                            (|SparseUnivariatePolynomial|
                                             (QREFELT $ 8))
                                            (QREFELT $ 6)))
                                          #4#)) . #23#)
                                 (LETT |factorlist|
                                       (CONS
                                        (CONS
                                         (SPADCALL
                                          (|spadConstant| $ 32) 1
                                          (QREFELT $ 33))
                                         |mdeg|)
                                        |factorlist|) . #23#)
                                 (EXIT (COND
                                         ((EQL
                                           (SPADCALL |um|
                                            (QREFELT $ 15))
                                           0)
                                          (PROGN
                                            (LETT #5#
                                             (SEQ
                                              (LETT |lfg|
                                               (|MFINFACT;convertPUP|
                                                (|MFINFACT;mFactor|
                                                 (SPADCALL |um|
                                                  (QREFELT $ 16))
                                                 |dx| $)
                                                $) . #23#)
                                              (EXIT
                                               (CONS (QCAR |lfg|)
                                                (APPEND |factorlist|
                                                 (QCDR |lfg|))))) . #23#)
                                            (GO #5#))))))))
                         (LETT |om|
                               (SPADCALL
                                   (CONS #'|MFINFACT;supFactor!0|
                                    (VECTOR $ (QREFELT $ 10)))
                                   |um| (QREFELT $ 39)) . #23#)
                         (LETT |sqfacs|
                               (SPADCALL |om| (QREFELT $ 41)) . #23#)
                         (LETT |lcont|
                               (SPADCALL
                                   (CONS #'|MFINFACT;supFactor!1|
                                    (VECTOR $ (QREFELT $ 10)))
                                   (SPADCALL |sqfacs| (QREFELT $ 43))
                                   (QREFELT $ 46)) . #23#)
                         (COND
                           ((SPADCALL |lcont| (QREFELT $ 48))
                            (LETT |flead|
                                  (|MFINFACT;convertPUP|
                                      (|MFINFACT;constantCase|
                                       (SPADCALL |lcont|
                                        (QREFELT $ 16))
                                       NIL $)
                                      $) . #23#))
                           ('T
                            (LETT |flead|
                                  (|MFINFACT;supFactor| |lcont| |dx| $) . #23#)))
                         (LETT |factorlist| (QCDR |flead|) . #23#)
                         (LETT |sqqfact|
                               (PROGN
                                 (LETT #6# NIL . #23#)
                                 (SEQ (LETT |ff| NIL . #23#)
                                      (LETT #7#
                                       (SPADCALL |sqfacs|
                                        (QREFELT $ 51)) . #23#)
                                      G190
                                      (COND
                                        ((OR (ATOM #7#)
                                          (PROGN
                                            (LETT |ff|
                                             (CAR #7#) . #23#)
                                            NIL))
                                         #24#))
                                      (SEQ
                                       (EXIT
                                        (LETT #6#
                                         (CONS
                                          (CONS
                                           (SPADCALL
                                            (CONS
                                             #'|MFINFACT;supFactor!2|
                                             (VECTOR $ (QREFELT $ 10)))
                                            (QCAR |ff|) (QREFELT $ 46))
                                           (QCDR |ff|))
                                          #6#) . #23#)))
                                      (LETT #7# (CDR #7#) . #23#) #25#
                                      G191 (EXIT (NREVERSE0 #6#)))) . #23#)
                         (SEQ (LETT |fact| NIL . #23#)
                              (LETT #8# |sqqfact| . #23#) G190
                              (COND
                                ((OR (ATOM #8#)
                                     (PROGN
                                       (LETT |fact| (CAR #8#) . #23#)
                                       NIL))
                                 #24#))
                              (SEQ (LETT |ffactor|
                                    (QCAR |fact|) . #23#)
                                   (LETT |ffexp| (QCDR |fact|) . #23#)
                                   (LETT |ffcont|
                                    (SPADCALL |ffactor| (QREFELT $ 52)) . #23#)
                                   (LETT |coefs|
                                    (SPADCALL |ffactor| (QREFELT $ 18)) . #23#)
                                   (LETT |ldeg|
                                    (PROGN
                                      (LETT #9# NIL . #23#)
                                      (SEQ (LETT |xx| NIL . #23#)
                                       (LETT #10# |lvar| . #23#) G190
                                       (COND
                                         ((OR (ATOM #10#)
                                           (PROGN
                                             (LETT |xx|
                                              (CAR #10#) . #23#)
                                             NIL))
                                          #24#))
                                       (SEQ
                                        (EXIT
                                         (LETT #9#
                                          (CONS
                                           (PROGN
                                             (LETT #14# NIL . #23#)
                                             (SEQ
                                              (LETT |fc| NIL . #23#)
                                              (LETT #11#
                                               |coefs| . #23#)
                                              G190
                                              (COND
                                                ((OR (ATOM #11#)
                                                  (PROGN
                                                    (LETT |fc|
                                                     (CAR #11#) . #23#)
                                                    NIL))
                                                 #24#))
                                              (SEQ
                                               (EXIT
                                                (PROGN
                                                  (LETT #12#
                                                   (SPADCALL |fc| |xx|
                                                    (QREFELT $ 53)) . #23#)
                                                  (COND
                                                    (#14#
                                                     (LETT #13#
                                                      (MAX #13# #12#) . #23#))
                                                    ('T
                                                     (PROGN
                                                       (LETT #13#
                                                        #12# . #23#)
                                                       (LETT #14#
                                                        'T . #23#)))))))
                                              (LETT #11#
                                               (CDR #11#) . #23#)
                                              #25# G191 (EXIT NIL))
                                             (COND
                                               (#14# #13#)
                                               ('T
                                                (|IdentityError|
                                                 '|max|))))
                                           #9#) . #23#)))
                                       (LETT #10# (CDR #10#) . #23#)
                                       #25# G191
                                       (EXIT (NREVERSE0 #9#)))) . #23#)
                                   (COND
                                     ((SPADCALL
                                       (SPADCALL |ffactor|
                                        (QREFELT $ 54))
                                       (QREFELT $ 55))
                                      (LETT |lf|
                                       (|MFINFACT;mfconst| |ffactor|
                                        |dx| |lvar| |ldeg| $) . #23#))
                                     ('T
                                      (LETT |lf|
                                       (|MFINFACT;mfpol| |ffactor| |dx|
                                        |lvar| |ldeg| $) . #23#)))
                                   (LETT |auxfl|
                                    (PROGN
                                      (LETT #15# NIL . #23#)
                                      (SEQ (LETT |lfp| NIL . #23#)
                                       (LETT #16# |lf| . #23#) G190
                                       (COND
                                         ((OR (ATOM #16#)
                                           (PROGN
                                             (LETT |lfp|
                                              (CAR #16#) . #23#)
                                             NIL))
                                          #24#))
                                       (SEQ
                                        (EXIT
                                         (LETT #15#
                                          (CONS (CONS |lfp| |ffexp|)
                                           #15#) . #23#)))
                                       (LETT #16# (CDR #16#) . #23#)
                                       #25# G191
                                       (EXIT (NREVERSE0 #15#)))) . #23#)
                                   (EXIT
                                    (LETT |factorlist|
                                     (APPEND |factorlist| |auxfl|) . #23#)))
                              (LETT #8# (CDR #8#) . #23#) #25# G191
                              (EXIT NIL))
                         (LETT |lcfacs|
                               (PROGN
                                 (LETT #21# NIL . #23#)
                                 (SEQ (LETT |f| NIL . #23#)
                                      (LETT #17# |factorlist| . #23#)
                                      G190
                                      (COND
                                        ((OR (ATOM #17#)
                                          (PROGN
                                            (LETT |f|
                                             (CAR #17#) . #23#)
                                            NIL))
                                         #24#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #19#
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL (QCAR |f|)
                                              (QREFELT $ 54))
                                             (QREFELT $ 56))
                                            (PROG1
                                             (LETT #18#
                                              (QCDR |f|) . #23#)
                                              (|check-subtype|
                                               (>= #18# 0)
                                               '(|NonNegativeInteger|)
                                               #18#))
                                            (QREFELT $ 57)) . #23#)
                                          (COND
                                            (#21#
                                             (LETT #20#
                                              (SPADCALL #20# #19#
                                               (QREFELT $ 58)) . #23#))
                                            ('T
                                             (PROGN
                                               (LETT #20# #19# . #23#)
                                               (LETT #21# 'T . #23#)))))))
                                      (LETT #17# (CDR #17#) . #23#)
                                      #25# G191 (EXIT NIL))
                                 (COND
                                   (#21# #20#)
                                   ('T (|spadConstant| $ 59)))) . #23#)
                         (EXIT (CONS (PROG2
                                      (LETT #22#
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |um| (QREFELT $ 54))
                                         (QREFELT $ 56))
                                        |lcfacs| (QREFELT $ 60)) . #23#)
                                      (QCDR #22#)
                                       (|check-union| (QEQCAR #22# 0)
                                        (|SparseUnivariatePolynomial|
                                         (QREFELT $ 8))
                                        #22#))
                                     |factorlist|))))))
           #5# (EXIT #5#))))) 

(DEFUN |MFINFACT;supFactor!2| (|#1| $$)
  (|MFINFACT;pushdown| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |MFINFACT;supFactor!1| (|#1| $$)
  (|MFINFACT;pushdown| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |MFINFACT;supFactor!0| (|#1| $$)
  (|MFINFACT;pushup| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |MFINFACT;factor;SupF;3| (|um| $)
  (PROG (|lv| |ld| #0=#:G1815 #1=#:G1915 #2=#:G1908 #3=#:G1906
              #4=#:G1907 |dx| |cm| |flist| |u| #5=#:G1916 #6=#:G1912
              #7=#:G1910 #8=#:G1911)
    (RETURN
      (SEQ (LETT |lv| (SPADCALL |um| (QREFELT $ 62))
                 . #9=(|MFINFACT;factor;SupF;3|))
           (LETT |ld| (SPADCALL |um| |lv| (QREFELT $ 64)) . #9#)
           (LETT |dx|
                 (PROGN
                   (LETT #4# NIL . #9#)
                   (SEQ (LETT #0# NIL . #9#) (LETT #1# |ld| . #9#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT #0# (CAR #1#) . #9#) NIL))
                           #10=(GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #2# #0# . #9#)
                                     (COND
                                       (#4#
                                        (LETT #3# (MIN #3# #2#) . #9#))
                                       ('T
                                        (PROGN
                                          (LETT #3# #2# . #9#)
                                          (LETT #4# 'T . #9#)))))))
                        (LETT #1# (CDR #1#) . #9#) #11=(GO G190) G191
                        (EXIT NIL))
                   (COND (#4# #3#) (#12='T (|IdentityError| '|min|)))) . #9#)
           (SETELT $ 10
                   (SPADCALL |lv| (SPADCALL |dx| |ld| (QREFELT $ 66))
                       (QREFELT $ 67)))
           (LETT |cm|
                 (SPADCALL
                     (CONS #'|MFINFACT;factor;SupF;3!0|
                           (VECTOR $ (QREFELT $ 10)))
                     |um| (QREFELT $ 46)) . #9#)
           (LETT |flist| (|MFINFACT;supFactor| |cm| |dx| $) . #9#)
           (EXIT (SPADCALL
                     (SPADCALL
                         (|MFINFACT;pushupconst| (QCAR |flist|)
                             (QREFELT $ 10) $)
                         (QREFELT $ 68))
                     (PROGN
                       (LETT #8# NIL . #9#)
                       (SEQ (LETT |u| NIL . #9#)
                            (LETT #5# (QCDR |flist|) . #9#) G190
                            (COND
                              ((OR (ATOM #5#)
                                   (PROGN
                                     (LETT |u| (CAR #5#) . #9#)
                                     NIL))
                               #10#))
                            (SEQ (EXIT (PROGN
                                         (LETT #6#
                                          (SPADCALL
                                           (SPADCALL
                                            (CONS
                                             #'|MFINFACT;factor;SupF;3!1|
                                             (VECTOR $ (QREFELT $ 10)))
                                            (QCAR |u|) (QREFELT $ 39))
                                           (QCDR |u|) (QREFELT $ 69)) . #9#)
                                         (COND
                                           (#8#
                                            (LETT #7#
                                             (SPADCALL #7# #6#
                                              (QREFELT $ 70)) . #9#))
                                           ('T
                                            (PROGN
                                              (LETT #7# #6# . #9#)
                                              (LETT #8# 'T . #9#)))))))
                            (LETT #5# (CDR #5#) . #9#) #11# G191
                            (EXIT NIL))
                       (COND (#8# #7#) (#12# (|spadConstant| $ 71))))
                     (QREFELT $ 72))))))) 

(DEFUN |MFINFACT;factor;SupF;3!1| (|#1| $$)
  (|MFINFACT;pushup| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |MFINFACT;factor;SupF;3!0| (|#1| $$)
  (|MFINFACT;pushdown| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |MFINFACT;mFactor| (|m| |dx| $)
  (PROG (|lmdeg| |n| #0=#:G1953 #1=#:G1921 #2=#:G1919 #3=#:G1920 |om|
                 |sqfacs| |flead| #4=#:G1954 |ff| #5=#:G1955 |sqqfact|
                 |fact| #6=#:G1956 |ffexp| |lterm| #7=#:G1957 |lcont|
                 #8=#:G1930 #9=#:G1958 |varch| |x| |lvar| |pc|
                 #10=#:G1936 |ffactor| |lcterm| #11=#:G1959 |ldeg|
                 |lcum| |um| |lf| #12=#:G1960 |lfp| #13=#:G1961 |auxfl|
                 |factorlist|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |m| (QREFELT $ 55))
              (|MFINFACT;constantCase| |m| NIL $))
             ('T
              (SEQ (LETT |lvar| (SPADCALL |m| (QREFELT $ 20))
                         . #14=(|MFINFACT;mFactor|))
                   (LETT |flead|
                         (CONS (|spadConstant| $ 59) NIL) . #14#)
                   (LETT |factorlist| NIL . #14#)
                   (LETT |lmdeg|
                         (SPADCALL |m| |lvar| (QREFELT $ 74)) . #14#)
                   (EXIT (COND
                           ((PROGN
                              (LETT #3# NIL . #14#)
                              (SEQ (LETT |n| NIL . #14#)
                                   (LETT #0# |lmdeg| . #14#) G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |n| (CAR #0#) . #14#)
                                         NIL))
                                      #15=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #1# (< 0 |n|) . #14#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (COND (#2# 'T) ('T #1#)) . #14#))
                                         ('T
                                          (PROGN
                                            (LETT #2# #1# . #14#)
                                            (LETT #3# 'T . #14#)))))))
                                   (LETT #0# (CDR #0#) . #14#)
                                   #16=(GO G190) G191 (EXIT NIL))
                              (COND (#3# #2#) ('T 'NIL)))
                            (|MFINFACT;simplify| |m| |dx| |lvar|
                                |lmdeg| $))
                           ('T
                            (SEQ (LETT |om|
                                       (|MFINFACT;pushup| |m|
                                        (QREFELT $ 10) $) . #14#)
                                 (LETT |sqfacs|
                                       (SPADCALL |om| (QREFELT $ 75)) . #14#)
                                 (LETT |lcont|
                                       (|MFINFACT;pushdown|
                                        (SPADCALL |sqfacs|
                                         (QREFELT $ 77))
                                        (QREFELT $ 10) $) . #14#)
                                 (COND
                                   ((SPADCALL |lcont| (QREFELT $ 55))
                                    (LETT |flead|
                                     (|MFINFACT;constantCase| |lcont|
                                      NIL $) . #14#))
                                   ('T
                                    (LETT |flead|
                                     (|MFINFACT;mFactor| |lcont| |dx|
                                      $) . #14#)))
                                 (LETT |factorlist|
                                       (QCDR |flead|) . #14#)
                                 (LETT |sqqfact|
                                       (PROGN
                                         (LETT #4# NIL . #14#)
                                         (SEQ (LETT |ff| NIL . #14#)
                                          (LETT #5#
                                           (SPADCALL |sqfacs|
                                            (QREFELT $ 80)) . #14#)
                                          G190
                                          (COND
                                            ((OR (ATOM #5#)
                                              (PROGN
                                                (LETT |ff|
                                                 (CAR #5#) . #14#)
                                                NIL))
                                             #15#))
                                          (SEQ
                                           (EXIT
                                            (LETT #4#
                                             (CONS
                                              (CONS
                                               (|MFINFACT;pushdown|
                                                (QCAR |ff|)
                                                (QREFELT $ 10) $)
                                               (QCDR |ff|))
                                              #4#) . #14#)))
                                          (LETT #5# (CDR #5#) . #14#)
                                          #16# G191
                                          (EXIT (NREVERSE0 #4#)))) . #14#)
                                 (SEQ (LETT |fact| NIL . #14#)
                                      (LETT #6# |sqqfact| . #14#) G190
                                      (COND
                                        ((OR (ATOM #6#)
                                          (PROGN
                                            (LETT |fact|
                                             (CAR #6#) . #14#)
                                            NIL))
                                         #15#))
                                      (SEQ
                                       (LETT |ffactor|
                                        (QCAR |fact|) . #14#)
                                       (LETT |ffexp|
                                        (QCDR |fact|) . #14#)
                                       (EXIT
                                        (COND
                                          ((SPADCALL |ffactor|
                                            (QREFELT $ 55))
                                           (SEQ
                                            (LETT |lterm| NIL . #14#)
                                            (LETT #7#
                                             (QCDR
                                              (|MFINFACT;constantCase|
                                               |ffactor| NIL $)) . #14#)
                                            G190
                                            (COND
                                              ((OR (ATOM #7#)
                                                (PROGN
                                                  (LETT |lterm|
                                                   (CAR #7#) . #14#)
                                                  NIL))
                                               #15#))
                                            (SEQ
                                             (EXIT
                                              (LETT |factorlist|
                                               (CONS
                                                (CONS (QCAR |lterm|)
                                                 (* (QCDR |lterm|)
                                                  |ffexp|))
                                                |factorlist|) . #14#)))
                                            (LETT #7# (CDR #7#) . #14#)
                                            #16# G191 (EXIT NIL)))
                                          ('T
                                           (SEQ
                                            (LETT |lvar|
                                             (SPADCALL |ffactor|
                                              (QREFELT $ 20)) . #14#)
                                            (LETT |x|
                                             (SPADCALL |lvar| 1
                                              (QREFELT $ 67)) . #14#)
                                            (LETT |ldeg|
                                             (SPADCALL |ffactor| |lvar|
                                              (QREFELT $ 81)) . #14#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL 1 |ldeg|
                                                 (QREFELT $ 84))
                                                (SEQ
                                                 (LETT |x|
                                                  (SPADCALL |lvar|
                                                   (SPADCALL 1 |ldeg|
                                                    (QREFELT $ 66))
                                                   (QREFELT $ 67)) . #14#)
                                                 (LETT |lcont|
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL |ffactor|
                                                     |x|
                                                     (QREFELT $ 86))
                                                    (QREFELT $ 18))
                                                   (QREFELT $ 88)) . #14#)
                                                 (LETT |ffactor|
                                                  (PROG2
                                                   (LETT #8#
                                                    (SPADCALL |ffactor|
                                                     |lcont|
                                                     (QREFELT $ 89)) . #14#)
                                                   (QCDR #8#)
                                                    (|check-union|
                                                     (QEQCAR #8# 0)
                                                     (|SparseMultivariatePolynomial|
                                                      (|SparseUnivariatePolynomial|
                                                       (QREFELT $ 8))
                                                      (QREFELT $ 6))
                                                     #8#)) . #14#)
                                                 (LETT |factorlist|
                                                  (CONS
                                                   (CONS |ffactor|
                                                    |ffexp|)
                                                   |factorlist|) . #14#)
                                                 (EXIT
                                                  (SEQ
                                                   (LETT |lcterm|
                                                    NIL . #14#)
                                                   (LETT #9#
                                                    (QCDR
                                                     (|MFINFACT;mFactor|
                                                      |lcont| |dx| $)) . #14#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #9#)
                                                       (PROGN
                                                         (LETT |lcterm|
                                                          (CAR #9#) . #14#)
                                                         NIL))
                                                      #15#))
                                                   (SEQ
                                                    (EXIT
                                                     (LETT |factorlist|
                                                      (CONS
                                                       (CONS
                                                        (QCAR |lcterm|)
                                                        (*
                                                         (QCDR
                                                          |lcterm|)
                                                         |ffexp|))
                                                       |factorlist|) . #14#)))
                                                   (LETT #9#
                                                    (CDR #9#) . #14#)
                                                   #16# G191
                                                   (EXIT NIL)))))
                                               ('T
                                                (SEQ
                                                 (LETT |varch|
                                                  (|MFINFACT;varChoose|
                                                   |ffactor| |lvar|
                                                   |ldeg| $) . #14#)
                                                 (LETT |um|
                                                  (QVELT |varch| 0) . #14#)
                                                 (LETT |ldeg|
                                                  (CDR |ldeg|) . #14#)
                                                 (LETT |lvar|
                                                  (CDR |lvar|) . #14#)
                                                 (COND
                                                   ((NULL
                                                     (SPADCALL
                                                      (SPADCALL
                                                       (QVELT |varch|
                                                        1)
                                                       1
                                                       (QREFELT $ 67))
                                                      |x|
                                                      (QREFELT $ 90)))
                                                    (SEQ
                                                     (LETT |lvar|
                                                      (QVELT |varch| 1) . #14#)
                                                     (LETT |x|
                                                      (SPADCALL |lvar|
                                                       1
                                                       (QREFELT $ 67)) . #14#)
                                                     (LETT |lvar|
                                                      (CDR |lvar|) . #14#)
                                                     (LETT |pc|
                                                      (SPADCALL
                                                       (SPADCALL |um|
                                                        (QREFELT $ 18))
                                                       (QREFELT $ 88)) . #14#)
                                                     (COND
                                                       ((NULL
                                                         (SPADCALL |pc|
                                                          (|spadConstant|
                                                           $ 32)
                                                          (QREFELT $
                                                           91)))
                                                        (SEQ
                                                         (LETT |um|
                                                          (PROG2
                                                           (LETT #10#
                                                            (SPADCALL
                                                             |um| |pc|
                                                             (QREFELT $
                                                              92)) . #14#)
                                                           (QCDR #10#)
                                                            (|check-union|
                                                             (QEQCAR
                                                              #10# 0)
                                                             (|SparseUnivariatePolynomial|
                                                              (|SparseMultivariatePolynomial|
                                                               (|SparseUnivariatePolynomial|
                                                                (QREFELT
                                                                 $ 8))
                                                               (QREFELT
                                                                $ 6)))
                                                             #10#)) . #14#)
                                                         (LETT
                                                          |ffactor|
                                                          (SPADCALL
                                                           |um| |x|
                                                           (QREFELT $
                                                            93)) . #14#)
                                                         (EXIT
                                                          (SEQ
                                                           (LETT
                                                            |lcterm|
                                                            NIL . #14#)
                                                           (LETT #11#
                                                            (QCDR
                                                             (|MFINFACT;mFactor|
                                                              |pc| |dx|
                                                              $)) . #14#)
                                                           G190
                                                           (COND
                                                             ((OR
                                                               (ATOM
                                                                #11#)
                                                               (PROGN
                                                                 (LETT
                                                                  |lcterm|
                                                                  (CAR
                                                                   #11#) . #14#)
                                                                 NIL))
                                                              #15#))
                                                           (SEQ
                                                            (EXIT
                                                             (LETT
                                                              |factorlist|
                                                              (CONS
                                                               (CONS
                                                                (QCAR
                                                                 |lcterm|)
                                                                (*
                                                                 (QCDR
                                                                  |lcterm|)
                                                                 |ffexp|))
                                                               |factorlist|) . #14#)))
                                                           (LETT #11#
                                                            (CDR #11#) . #14#)
                                                           #16# G191
                                                           (EXIT NIL))))))
                                                     (EXIT
                                                      (LETT |ldeg|
                                                       (SPADCALL
                                                        |ffactor|
                                                        |lvar|
                                                        (QREFELT $ 81)) . #14#)))))
                                                 (LETT |lcum|
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL |um|
                                                     (QREFELT $ 54))
                                                    (QREFELT $ 56))
                                                   (QREFELT $ 94)) . #14#)
                                                 (COND
                                                   ((NULL
                                                     (SPADCALL |lcum|
                                                      (|spadConstant| $
                                                       30)
                                                      (QREFELT $ 95)))
                                                    (SEQ
                                                     (LETT |um|
                                                      (SPADCALL
                                                       (SPADCALL
                                                        (SPADCALL
                                                         (SPADCALL
                                                          |lcum|
                                                          (QREFELT $
                                                           96))
                                                         (QREFELT $ 97))
                                                        (QREFELT $ 98))
                                                       |um|
                                                       (QREFELT $ 99)) . #14#)
                                                     (EXIT
                                                      (PROGN
                                                        (RPLACA |flead|
                                                         (SPADCALL
                                                          (SPADCALL
                                                           |lcum|
                                                           (QREFELT $
                                                            97))
                                                          (QCAR
                                                           |flead|)
                                                          (QREFELT $
                                                           58)))
                                                        (QCAR |flead|))))))
                                                 (COND
                                                   ((SPADCALL
                                                     (SPADCALL |um|
                                                      (QREFELT $ 54))
                                                     (QREFELT $ 55))
                                                    (LETT |lf|
                                                     (|MFINFACT;mfconst|
                                                      |um| |dx| |lvar|
                                                      |ldeg| $) . #14#))
                                                   ('T
                                                    (LETT |lf|
                                                     (|MFINFACT;mfpol|
                                                      |um| |dx| |lvar|
                                                      |ldeg| $) . #14#)))
                                                 (LETT |auxfl|
                                                  (PROGN
                                                    (LETT #12#
                                                     NIL . #14#)
                                                    (SEQ
                                                     (LETT |lfp|
                                                      NIL . #14#)
                                                     (LETT #13#
                                                      |lf| . #14#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #13#)
                                                         (PROGN
                                                           (LETT |lfp|
                                                            (CAR #13#) . #14#)
                                                           NIL))
                                                        #15#))
                                                     (SEQ
                                                      (EXIT
                                                       (LETT #12#
                                                        (CONS
                                                         (CONS
                                                          (SPADCALL
                                                           |lfp| |x|
                                                           (QREFELT $
                                                            93))
                                                          |ffexp|)
                                                         #12#) . #14#)))
                                                     (LETT #13#
                                                      (CDR #13#) . #14#)
                                                     #16# G191
                                                     (EXIT
                                                      (NREVERSE0 #12#)))) . #14#)
                                                 (EXIT
                                                  (LETT |factorlist|
                                                   (APPEND |factorlist|
                                                    |auxfl|) . #14#)))))))))))
                                      (LETT #6# (CDR #6#) . #14#) #16#
                                      G191 (EXIT NIL))
                                 (PROGN
                                   (RPLACD |flead| |factorlist|)
                                   (QCDR |flead|))
                                 (EXIT |flead|)))))))))))) 

(DEFUN |MFINFACT;pM| (|lum| $)
  (PROG (|x| |i| #0=#:G1980 #1=#:G1963 #2=#:G1964 |e| #3=#:G1966 |q|
             #4=#:G1971 |p| #5=#:G1979)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |x|
                            (SPADCALL (|spadConstant| $ 30) 1
                                (QREFELT $ 100))
                            . #6=(|MFINFACT;pM|))
                      (SEQ (LETT |i| 1 . #6#)
                           (LETT #0# (SPADCALL (QREFELT $ 101)) . #6#)
                           G190
                           (COND ((QSGREATERP |i| #0#) #7=(GO G191)))
                           (SEQ (EXIT (SEQ
                                       (LETT |p|
                                        (SPADCALL |x|
                                         (SPADCALL
                                          (SPADCALL
                                           (PROG1 (LETT #1# |i| . #6#)
                                             (|check-subtype| (> #1# 0)
                                              '(|PositiveInteger|) #1#))
                                           (QREFELT $ 103))
                                          (QREFELT $ 97))
                                         (QREFELT $ 104)) . #6#)
                                       (EXIT
                                        (COND
                                          ((SPADCALL |p| |lum|
                                            (QREFELT $ 107))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #5# |p| . #6#)
                                                (GO #5#)) . #6#)
                                             (GO #2#)))))))
                                #2# (EXIT #2#))
                           (LETT |i| (QSADD1 |i|) . #6#) #8=(GO G190)
                           G191 (EXIT NIL))
                      (EXIT (SEQ (LETT |e| 2 . #6#) G190 NIL
                                 (SEQ (LETT |p|
                                       (SPADCALL
                                        (PROG1 (LETT #3# |e| . #6#)
                                          (|check-subtype| (> #3# 0)
                                           '(|PositiveInteger|) #3#))
                                        (QREFELT $ 109)) . #6#)
                                      (EXIT
                                       (COND
                                         ((SPADCALL |p| |lum|
                                           (QREFELT $ 107))
                                          (PROGN
                                            (LETT #5# |p| . #6#)
                                            (GO #5#)))
                                         ('T
                                          (SEQ G190
                                           (COND
                                             ((NULL
                                               (SEQ
                                                (LETT |q|
                                                 (SPADCALL |p|
                                                  (QREFELT $ 111)) . #6#)
                                                (EXIT
                                                 (COND
                                                   ((QEQCAR |q| 1)
                                                    'NIL)
                                                   ('T 'T)))))
                                              #7#))
                                           (SEQ
                                            (LETT |p|
                                             (PROG2
                                              (LETT #4# |q| . #6#)
                                              (QCDR #4#)
                                               (|check-union|
                                                (QEQCAR #4# 0)
                                                (|SparseUnivariatePolynomial|
                                                 (QREFELT $ 8))
                                                #4#)) . #6#)
                                            (EXIT
                                             (COND
                                               ((SPADCALL |p| |lum|
                                                 (QREFELT $ 107))
                                                (PROGN
                                                  (LETT #5# |p| . #6#)
                                                  (GO #5#))))))
                                           NIL #8# G191 (EXIT NIL))))))
                                 (LETT |e| (QSADD1 |e|) . #6#) #8# G191
                                 (EXIT NIL)))))
           #5# (EXIT #5#))))) 

(DEFUN |MFINFACT;pushdcoef| (|t| $)
  (SPADCALL (CONS #'|MFINFACT;pushdcoef!0| $) |t| (QREFELT $ 114))) 

(DEFUN |MFINFACT;pushdcoef!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 97))) 

(DEFUN |MFINFACT;intfact| (|um| |lvar| |ldeg| |tleadpol| |ltry| $)
  (PROG (|polcase| #0=#:G2017 #1=#:G2018 |leadpol| |vfchoo| |nfact|
            |lval| |leadval| |distf| #2=#:G2016 |dist| |lpol| |dd|
            #3=#:G2019 |i| |unifact| #4=#:G2004 |ffin| #5=#:G2020 |ff|
            #6=#:G2021 |factfin|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |polcase|
                            (COND
                              ((NULL (QCDR |tleadpol|)) 'NIL)
                              ('T 'T))
                            . #7=(|MFINFACT;intfact|))
                      (LETT |vfchoo|
                            (COND
                              (|polcase|
                                  (SEQ (LETT |leadpol|
                                        (PROGN
                                          (LETT #0# NIL . #7#)
                                          (SEQ (LETT |ff| NIL . #7#)
                                           (LETT #1#
                                            (QCDR |tleadpol|) . #7#)
                                           G190
                                           (COND
                                             ((OR (ATOM #1#)
                                               (PROGN
                                                 (LETT |ff|
                                                  (CAR #1#) . #7#)
                                                 NIL))
                                              #8=(GO G191)))
                                           (SEQ
                                            (EXIT
                                             (LETT #0#
                                              (CONS (QCAR |ff|) #0#) . #7#)))
                                           (LETT #1# (CDR #1#) . #7#)
                                           #9=(GO G190) G191
                                           (EXIT (NREVERSE0 #0#)))) . #7#)
                                       (EXIT
                                        (|MFINFACT;intChoose| |um|
                                         |lvar| (QCAR |tleadpol|)
                                         |leadpol| |ltry| $))))
                              (#10='T
                               (|MFINFACT;intChoose| |um| |lvar|
                                   (|spadConstant| $ 59) NIL NIL $))) . #7#)
                      (LETT |unifact| (QVELT |vfchoo| 1) . #7#)
                      (LETT |nfact| (LENGTH |unifact|) . #7#)
                      (EXIT (COND
                              ((EQL |nfact| 1) (LIST |um|))
                              (#10#
                               (SEQ (LETT |ltry|
                                     (QVELT |vfchoo| 0) . #7#)
                                    (LETT |lval|
                                     (|SPADfirst| |ltry|) . #7#)
                                    (LETT |dd|
                                     (QVELT |vfchoo| 2) . #7#)
                                    (LETT |lpol| NIL . #7#)
                                    (LETT |leadval| NIL . #7#)
                                    (COND
                                      (|polcase|
                                       (SEQ
                                        (LETT |leadval|
                                         (QVELT |vfchoo| 3) . #7#)
                                        (LETT |distf|
                                         (SPADCALL (QVELT |vfchoo| 2)
                                          |unifact| |tleadpol|
                                          |leadval| |lvar| |lval|
                                          (QREFELT $ 121)) . #7#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |distf| 1)
                                            (PROGN
                                              (LETT #2#
                                               (|MFINFACT;intfact| |um|
                                                |lvar| |ldeg|
                                                |tleadpol| |ltry| $) . #7#)
                                              (GO #2#)))
                                           (#10#
                                            (SEQ
                                             (LETT |dist|
                                              (QCDR |distf|) . #7#)
                                             (LETT |lpol|
                                              (QVELT |dist| 0) . #7#)
                                             (LETT |dd|
                                              (QVELT |dist| 1) . #7#)
                                             (EXIT
                                              (LETT |unifact|
                                               (QVELT |dist| 2) . #7#)))))))))
                                    (COND
                                      ((NULL
                                        (SPADCALL |dd|
                                         (|spadConstant| $ 59)
                                         (QREFELT $ 122)))
                                       (SEQ
                                        (LETT |unifact|
                                         (PROGN
                                           (LETT #3# NIL . #7#)
                                           (SEQ (LETT |i| 1 . #7#) G190
                                            (COND
                                              ((QSGREATERP |i| |nfact|)
                                               #8#))
                                            (SEQ
                                             (EXIT
                                              (LETT #3#
                                               (CONS
                                                (SPADCALL |dd|
                                                 (SPADCALL |unifact|
                                                  |i| (QREFELT $ 124))
                                                 (QREFELT $ 125))
                                                #3#) . #7#)))
                                            (LETT |i|
                                             (QSADD1 |i|) . #7#)
                                            #9# G191
                                            (EXIT (NREVERSE0 #3#)))) . #7#)
                                        (EXIT
                                         (LETT |um|
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |dd|
                                             (PROG1
                                              (LETT #4#
                                               (- |nfact| 1) . #7#)
                                               (|check-subtype|
                                                (>= #4# 0)
                                                '(|NonNegativeInteger|)
                                                #4#))
                                             (QREFELT $ 57))
                                            (QREFELT $ 98))
                                           |um| (QREFELT $ 99)) . #7#)))))
                                    (LETT |ffin|
                                     (SPADCALL |um| |lvar| |unifact|
                                      |lval| |lpol| |ldeg|
                                      (|MFINFACT;pM| |unifact| $)
                                      (QREFELT $ 128)) . #7#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |ffin| 1)
                                        (|MFINFACT;intfact| |um| |lvar|
                                         |ldeg| |tleadpol| |ltry| $))
                                       (#10#
                                        (SEQ
                                         (LETT |factfin|
                                          (QCDR |ffin|) . #7#)
                                         (COND
                                           ((NULL
                                             (SPADCALL |dd|
                                              (|spadConstant| $ 59)
                                              (QREFELT $ 122)))
                                            (LETT |factfin|
                                             (PROGN
                                               (LETT #5# NIL . #7#)
                                               (SEQ
                                                (LETT |ff| NIL . #7#)
                                                (LETT #6#
                                                 |factfin| . #7#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #6#)
                                                    (PROGN
                                                      (LETT |ff|
                                                       (CAR #6#) . #7#)
                                                      NIL))
                                                   #8#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #5#
                                                   (CONS
                                                    (SPADCALL |ff|
                                                     (QREFELT $ 129))
                                                    #5#) . #7#)))
                                                (LETT #6#
                                                 (CDR #6#) . #7#)
                                                #9# G191
                                                (EXIT (NREVERSE0 #5#)))) . #7#)))
                                         (EXIT |factfin|)))))))))))
           #2# (EXIT #2#))))) 

(DEFUN |MFINFACT;pushup| (|f| |x| $)
  (PROG (|lf| |cf| |lvf| |rr|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (QREFELT $ 55))
              (|MFINFACT;pushupconst| (SPADCALL |f| (QREFELT $ 130))
                  |x| $))
             ('T
              (SEQ (LETT |rr| (|spadConstant| $ 27)
                         . #0=(|MFINFACT;pushup|))
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |f| (|spadConstant| $ 29)
                                     (QREFELT $ 91))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |lf|
                                   (SPADCALL |f| (QREFELT $ 131)) . #0#)
                             (LETT |cf|
                                   (|MFINFACT;pushupconst|
                                    (SPADCALL |f| (QREFELT $ 56)) |x|
                                    $) . #0#)
                             (LETT |lvf|
                                   (SPADCALL |lf| (QREFELT $ 20)) . #0#)
                             (LETT |rr|
                                   (SPADCALL |rr|
                                    (SPADCALL |cf| |lvf|
                                     (SPADCALL |lf| |lvf|
                                      (QREFELT $ 81))
                                     (QREFELT $ 132))
                                    (QREFELT $ 133)) . #0#)
                             (EXIT (LETT |f|
                                    (SPADCALL |f| (QREFELT $ 134)) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |rr|)))))))) 

(DEFUN |MFINFACT;pushdown| (|g| |x| $)
  (PROG (|cf| |rf| |ug|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |g| (QREFELT $ 135))
              (SPADCALL
                  (SPADCALL (SPADCALL |g| (QREFELT $ 136))
                      (QREFELT $ 97))
                  (QREFELT $ 98)))
             ('T
              (SEQ (LETT |rf| (|spadConstant| $ 29)
                         . #0=(|MFINFACT;pushdown|))
                   (LETT |ug| (SPADCALL |g| |x| (QREFELT $ 137)) . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |ug|
                                     (|spadConstant| $ 138)
                                     (QREFELT $ 139))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |cf|
                                   (SPADCALL (|spadConstant| $ 30)
                                    (SPADCALL |ug| (QREFELT $ 140))
                                    (QREFELT $ 100)) . #0#)
                             (LETT |rf|
                                   (SPADCALL |rf|
                                    (SPADCALL |cf|
                                     (|MFINFACT;pushdcoef|
                                      (SPADCALL |ug| (QREFELT $ 141))
                                      $)
                                     (QREFELT $ 142))
                                    (QREFELT $ 143)) . #0#)
                             (EXIT (LETT |ug|
                                    (SPADCALL |ug| (QREFELT $ 144)) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |rf|)))))))) 

(DEFUN |MFINFACT;pushupconst| (|r| |x| $)
  (PROG (|rr|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |r| (QREFELT $ 145))
              (SPADCALL (SPADCALL |r| (QREFELT $ 146)) (QREFELT $ 147)))
             ('T
              (SEQ (LETT |rr| (|spadConstant| $ 27)
                         . #0=(|MFINFACT;pushupconst|))
                   (SEQ G190
                        (COND
                          ((NULL (COND
                                   ((SPADCALL |r| (|spadConstant| $ 25)
                                     (QREFELT $ 122))
                                    'NIL)
                                   ('T 'T)))
                           (GO G191)))
                        (SEQ (LETT |rr|
                                   (SPADCALL |rr|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |r| (QREFELT $ 94))
                                      (QREFELT $ 147))
                                     |x| (SPADCALL |r| (QREFELT $ 148))
                                     (QREFELT $ 149))
                                    (QREFELT $ 133)) . #0#)
                             (EXIT (LETT |r|
                                    (SPADCALL |r| (QREFELT $ 150)) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |rr|)))))))) 

(DEFUN |MFINFACT;ran| (|k1| $)
  (PROG (|i| #0=#:G2039 #1=#:G2037 #2=#:G2038)
    (RETURN
      (SEQ (PROGN
             (LETT #2# NIL . #3=(|MFINFACT;ran|))
             (SEQ (LETT |i| 0 . #3#) G190
                  (COND ((QSGREATERP |i| |k1|) (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #0#
                                     (SPADCALL
                                      (SPADCALL (QREFELT $ 151)) |i|
                                      (QREFELT $ 100)) . #3#)
                               (COND
                                 (#2# (LETT #1#
                                       (SPADCALL #1# #0#
                                        (QREFELT $ 104)) . #3#))
                                 ('T
                                  (PROGN
                                    (LETT #1# #0# . #3#)
                                    (LETT #2# 'T . #3#)))))))
                  (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191
                  (EXIT NIL))
             (COND (#2# #1#) ('T (|spadConstant| $ 25)))))))) 

(DEFUN |MFINFACT;checkzero| (|u| |um| $)
  (COND
    ((SPADCALL |u| (|spadConstant| $ 28) (QREFELT $ 152))
     (SPADCALL |um| (|spadConstant| $ 153) (QREFELT $ 154)))
    ((SPADCALL |um| (|spadConstant| $ 153) (QREFELT $ 154)) 'NIL)
    ('T
     (COND
       ((EQL (SPADCALL |u| (QREFELT $ 15))
             (SPADCALL |um| (QREFELT $ 155)))
        (|MFINFACT;checkzero| (SPADCALL |u| (QREFELT $ 156))
            (SPADCALL |um| (QREFELT $ 157)) $))
       ('T 'NIL))))) 

(DEFUN |MFINFACT;varChoose| (|m| |lvar| |ldeg| $)
  (PROG (|d| #0=#:G2050 #1=#:G2046 #2=#:G2044 #3=#:G2045 |k| |i| |x|)
    (RETURN
      (SEQ (LETT |k|
                 (PROGN
                   (LETT #3# NIL . #4=(|MFINFACT;varChoose|))
                   (SEQ (LETT |d| NIL . #4#) (LETT #0# |ldeg| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |d| (CAR #0#) . #4#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (PROGN
                                     (LETT #1# |d| . #4#)
                                     (COND
                                       (#3#
                                        (LETT #2# (MIN #2# #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 (|IdentityError| '|min|)))) . #4#)
           (EXIT (COND
                   ((EQL |k|
                         (SPADCALL |m| (|SPADfirst| |lvar|)
                             (QREFELT $ 53)))
                    (VECTOR (SPADCALL |m| (|SPADfirst| |lvar|)
                                (QREFELT $ 86))
                            |lvar| |ldeg|))
                   ('T
                    (SEQ (LETT |i|
                               (SPADCALL |k| |ldeg| (QREFELT $ 66)) . #4#)
                         (LETT |x|
                               (SPADCALL |lvar| |i| (QREFELT $ 67)) . #4#)
                         (LETT |ldeg|
                               (CONS |k|
                                     (SPADCALL |ldeg| |i|
                                      (QREFELT $ 158))) . #4#)
                         (LETT |lvar|
                               (CONS |x|
                                     (SPADCALL |lvar| |i|
                                      (QREFELT $ 159))) . #4#)
                         (EXIT (VECTOR (SPADCALL |m| |x|
                                        (QREFELT $ 86))
                                       |lvar| |ldeg|)))))))))) 

(DEFUN |MFINFACT;norm| (|lum| $)
  (PROG (|lup| #0=#:G2055 #1=#:G2053 #2=#:G2051 #3=#:G2052)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|MFINFACT;norm|))
             (SEQ (LETT |lup| NIL . #4#) (LETT #0# |lum| . #4#) G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |lup| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1#
                                     (SPADCALL |lup| (QREFELT $ 155)) . #4#)
                               (COND
                                 (#3# (LETT #2# (MAX #2# #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 (|IdentityError| '|max|)))))))) 

(DEFUN |MFINFACT;intChoose| (|um| |lvar| |clc| |plist| |ltry| $)
  (PROG (|degum| |nvar1| |ctf1| |testp| |newunifact| #0=#:G2156 |i|
                 |lval| #1=#:G2157 |pol| #2=#:G2158 |leadcomp1| |epl|
                 #3=#:G2159 #4=#:G2061 #5=#:G2059 #6=#:G2060 #7=#:G2066
                 |Dnewm| |D2newm| |range| |lcnm| |newm| |uc| #8=#:G2160
                 #9=#:G2074 #10=#:G2072 #11=#:G2073 |dx| |luniv|
                 |lunivf| |nf| |lffc1| #12=#:G2161 #13=#:G2162
                 #14=#:G2163 |ff| #15=#:G2164 #16=#:G2165 #17=#:G2166
                 #18=#:G2167 #19=#:G2168 #20=#:G2153 #21=#:G2169
                 #22=#:G2170 |leadtest| #23=#:G2171 |uf| #24=#:G2172
                 |unifact| |lffc| |leadcomp| |int| |nfatt|)
    (RETURN
      (SEQ (LETT |degum| (SPADCALL |um| (QREFELT $ 15))
                 . #25=(|MFINFACT;intChoose|))
           (LETT |nvar1| (LENGTH |lvar|) . #25#)
           (LETT |range| 0 . #25#)
           (LETT |ctf1| (|spadConstant| $ 59) . #25#)
           (LETT |testp|
                 (COND
                   ((SPADCALL |plist| NIL (QREFELT $ 160)) 'NIL)
                   ('T 'T)) . #25#)
           (LETT |leadcomp| (LETT |leadcomp1| NIL . #25#) . #25#)
           (LETT |nfatt| (+ |degum| 1) . #25#)
           (LETT |lffc| (|spadConstant| $ 59) . #25#)
           (LETT |lffc1| |lffc| . #25#) (LETT |newunifact| NIL . #25#)
           (LETT |leadtest| 'T . #25#) (LETT |int| NIL . #25#)
           (SEQ (EXIT (SEQ G190 (COND ((NULL 'T) #26=(GO G191)))
                           (SEQ (LETT |lval|
                                      (PROGN
                                        (LETT #0# NIL . #25#)
                                        (SEQ (LETT |i| 1 . #25#) G190
                                         (COND
                                           ((QSGREATERP |i| |nvar1|)
                                            #26#))
                                         (SEQ
                                          (EXIT
                                           (LETT #0#
                                            (CONS
                                             (|MFINFACT;ran| |range| $)
                                             #0#) . #25#)))
                                         (LETT |i| (QSADD1 |i|) . #25#)
                                         #27=(GO G190) G191
                                         (EXIT (NREVERSE0 #0#)))) . #25#)
                                (EXIT (COND
                                        ((SPADCALL |lval| |ltry|
                                          (QREFELT $ 162))
                                         (LETT |range|
                                          (+ 1 |range|) . #25#))
                                        ('T
                                         (SEQ
                                          (LETT |ltry|
                                           (CONS |lval| |ltry|) . #25#)
                                          (LETT |leadcomp1|
                                           (PROGN
                                             (LETT #1# NIL . #25#)
                                             (SEQ
                                              (LETT |pol| NIL . #25#)
                                              (LETT #2# |plist| . #25#)
                                              G190
                                              (COND
                                                ((OR (ATOM #2#)
                                                  (PROGN
                                                    (LETT |pol|
                                                     (CAR #2#) . #25#)
                                                    NIL))
                                                 #26#))
                                              (SEQ
                                               (EXIT
                                                (LETT #1#
                                                 (CONS
                                                  (SPADCALL
                                                   (SPADCALL |pol|
                                                    |lvar| |lval|
                                                    (QREFELT $ 163))
                                                   (QREFELT $ 130))
                                                  #1#) . #25#)))
                                              (LETT #2#
                                               (CDR #2#) . #25#)
                                              #27# G191
                                              (EXIT (NREVERSE0 #1#)))) . #25#)
                                          (COND
                                            (|testp|
                                             (COND
                                               ((PROGN
                                                  (LETT #6# NIL . #25#)
                                                  (SEQ
                                                   (LETT |epl|
                                                    NIL . #25#)
                                                   (LETT #3#
                                                    |leadcomp1| . #25#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #3#)
                                                       (PROGN
                                                         (LETT |epl|
                                                          (CAR #3#) . #25#)
                                                         NIL))
                                                      #26#))
                                                   (SEQ
                                                    (EXIT
                                                     (PROGN
                                                       (LETT #4#
                                                        (SPADCALL |epl|
                                                         (QREFELT $
                                                          164)) . #25#)
                                                       (COND
                                                         (#6#
                                                          (LETT #5#
                                                           (COND
                                                             (#5# 'T)
                                                             ('T #4#)) . #25#))
                                                         ('T
                                                          (PROGN
                                                            (LETT #5#
                                                             #4# . #25#)
                                                            (LETT #6#
                                                             'T . #25#)))))))
                                                   (LETT #3#
                                                    (CDR #3#) . #25#)
                                                   #27# G191
                                                   (EXIT NIL))
                                                  (COND
                                                    (#6# #5#)
                                                    ('T 'NIL)))
                                                (EXIT
                                                 (LETT |range|
                                                  (+ |range| 1) . #25#))))))
                                          (LETT |newm|
                                           (SPADCALL |um| |lvar| |lval|
                                            (QREFELT $ 166)) . #25#)
                                          (COND
                                            ((EQL |degum|
                                              (SPADCALL |newm|
                                               (QREFELT $ 155)))
                                             (COND
                                               ((NULL
                                                 (EQL
                                                  (SPADCALL |newm|
                                                   (QREFELT $ 167))
                                                  0))
                                                (EXIT
                                                 (LETT |range|
                                                  (+ |range| 1) . #25#)))))
                                            ('T
                                             (EXIT
                                              (LETT |range|
                                               (+ |range| 1) . #25#))))
                                          (LETT |lffc1|
                                           (SPADCALL |newm|
                                            (QREFELT $ 168)) . #25#)
                                          (LETT |newm|
                                           (PROG2
                                            (LETT #7#
                                             (SPADCALL |newm| |lffc1|
                                              (QREFELT $ 169)) . #25#)
                                            (QCDR #7#)
                                             (|check-union|
                                              (QEQCAR #7# 0)
                                              (|SparseUnivariatePolynomial|
                                               (|SparseUnivariatePolynomial|
                                                (QREFELT $ 8)))
                                              #7#)) . #25#)
                                          (COND
                                            (|testp|
                                             (COND
                                               (|leadtest|
                                                (COND
                                                  ((NULL
                                                    (SPADCALL
                                                     (SPADCALL |lffc1|
                                                      |clc|
                                                      (QREFELT $ 58))
                                                     (LENGTH |plist|)
                                                     |leadcomp1|
                                                     (QREFELT $ 170)))
                                                   (EXIT
                                                    (LETT |range|
                                                     (+ |range| 1) . #25#))))))))
                                          (LETT |Dnewm|
                                           (SPADCALL |newm|
                                            (QREFELT $ 171)) . #25#)
                                          (LETT |D2newm|
                                           (SPADCALL (ELT $ 173) |newm|
                                            (QREFELT $ 176)) . #25#)
                                          (COND
                                            ((NULL
                                              (EQL
                                               (SPADCALL
                                                (SPADCALL
                                                 (LIST |newm| |Dnewm|
                                                  |D2newm|)
                                                 (QREFELT $ 177))
                                                (QREFELT $ 155))
                                               0))
                                             (EXIT
                                              (LETT |range|
                                               (+ |range| 1) . #25#))))
                                          (LETT |lcnm|
                                           (|spadConstant| $ 30) . #25#)
                                          (SEQ
                                           (LETT |lcnm|
                                            (SPADCALL
                                             (SPADCALL |newm|
                                              (QREFELT $ 178))
                                             (QREFELT $ 94)) . #25#)
                                           (EXIT
                                            (COND
                                              ((NULL
                                                (SPADCALL |lcnm|
                                                 (|spadConstant| $ 30)
                                                 (QREFELT $ 95)))
                                               (LETT |newm|
                                                (SPADCALL
                                                 (SPADCALL
                                                  (SPADCALL |lcnm|
                                                   (QREFELT $ 96))
                                                  (QREFELT $ 97))
                                                 |newm|
                                                 (QREFELT $ 125)) . #25#)))))
                                          (LETT |dx|
                                           (PROGN
                                             (LETT #11# NIL . #25#)
                                             (SEQ
                                              (LETT |uc| NIL . #25#)
                                              (LETT #8#
                                               (SPADCALL |newm|
                                                (QREFELT $ 179)) . #25#)
                                              G190
                                              (COND
                                                ((OR (ATOM #8#)
                                                  (PROGN
                                                    (LETT |uc|
                                                     (CAR #8#) . #25#)
                                                    NIL))
                                                 #26#))
                                              (SEQ
                                               (EXIT
                                                (PROGN
                                                  (LETT #9#
                                                   (SPADCALL |uc|
                                                    (QREFELT $ 148)) . #25#)
                                                  (COND
                                                    (#11#
                                                     (LETT #10#
                                                      (MAX #10# #9#) . #25#))
                                                    ('T
                                                     (PROGN
                                                       (LETT #10#
                                                        #9# . #25#)
                                                       (LETT #11#
                                                        'T . #25#)))))))
                                              (LETT #8#
                                               (CDR #8#) . #25#)
                                              #27# G191 (EXIT NIL))
                                             (COND
                                               (#11# #10#)
                                               ('T
                                                (|IdentityError|
                                                 '|max|)))) . #25#)
                                          (LETT |luniv|
                                           (SPADCALL |newm|
                                            (QREFELT $ 182)) . #25#)
                                          (LETT |lunivf|
                                           (SPADCALL |luniv|
                                            (QREFELT $ 185)) . #25#)
                                          (LETT |nf|
                                           (LENGTH |lunivf|) . #25#)
                                          (COND
                                            ((OR (EQL |nf| 0)
                                              (< |nfatt| |nf|))
                                             (EXIT "next values")))
                                          (COND
                                            ((EQL |nf| 1)
                                             (PROGN
                                               (LETT #20#
                                                (LETT |unifact|
                                                 (LIST |newm|) . #25#) . #25#)
                                               (GO #20#))))
                                          (LETT |lffc1|
                                           (SPADCALL
                                            (SPADCALL |lcnm|
                                             (SPADCALL
                                              (SPADCALL |luniv|
                                               (QREFELT $ 186))
                                              (QREFELT $ 187))
                                             (QREFELT $ 188))
                                            |lffc1| (QREFELT $ 58)) . #25#)
                                          (EXIT
                                           (COND
                                             ((EQL |nfatt| |nf|)
                                              (SEQ
                                               (COND
                                                 (|leadtest|
                                                  (SEQ
                                                   (LETT |unifact|
                                                    (PROGN
                                                      (LETT #12#
                                                       NIL . #25#)
                                                      (SEQ
                                                       (LETT |uf|
                                                        NIL . #25#)
                                                       (LETT #13#
                                                        |lunivf| . #25#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #13#)
                                                           (PROGN
                                                             (LETT |uf|
                                                              (CAR
                                                               #13#) . #25#)
                                                             NIL))
                                                          #26#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT #12#
                                                          (CONS
                                                           (QCAR |uf|)
                                                           #12#) . #25#)))
                                                       (LETT #13#
                                                        (CDR #13#) . #25#)
                                                       #27# G191
                                                       (EXIT
                                                        (NREVERSE0
                                                         #12#)))) . #25#)
                                                   (LETT |int|
                                                    |lval| . #25#)
                                                   (LETT |lffc|
                                                    |lffc1| . #25#)
                                                   (EXIT
                                                    (COND
                                                      (|testp|
                                                       (LETT |leadcomp|
                                                        |leadcomp1| . #25#))))))
                                                 ((<
                                                   (|MFINFACT;norm|
                                                    (PROGN
                                                      (LETT #14#
                                                       NIL . #25#)
                                                      (SEQ
                                                       (LETT |ff|
                                                        NIL . #25#)
                                                       (LETT #15#
                                                        |lunivf| . #25#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #15#)
                                                           (PROGN
                                                             (LETT |ff|
                                                              (CAR
                                                               #15#) . #25#)
                                                             NIL))
                                                          #26#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT #14#
                                                          (CONS
                                                           (QCAR |ff|)
                                                           #14#) . #25#)))
                                                       (LETT #15#
                                                        (CDR #15#) . #25#)
                                                       #27# G191
                                                       (EXIT
                                                        (NREVERSE0
                                                         #14#))))
                                                    $)
                                                   (|MFINFACT;norm|
                                                    |unifact| $))
                                                  (COND
                                                    (|testp|
                                                     (COND
                                                       ((SPADCALL
                                                         (SPADCALL
                                                          |lffc1| |clc|
                                                          (QREFELT $
                                                           58))
                                                         (LENGTH
                                                          |plist|)
                                                         |leadcomp1|
                                                         (QREFELT $
                                                          170))
                                                        (SEQ
                                                         (LETT
                                                          |unifact|
                                                          (PROGN
                                                            (LETT #16#
                                                             NIL . #25#)
                                                            (SEQ
                                                             (LETT |uf|
                                                              NIL . #25#)
                                                             (LETT #17#
                                                              |lunivf| . #25#)
                                                             G190
                                                             (COND
                                                               ((OR
                                                                 (ATOM
                                                                  #17#)
                                                                 (PROGN
                                                                   (LETT
                                                                    |uf|
                                                                    (CAR
                                                                     #17#) . #25#)
                                                                   NIL))
                                                                #26#))
                                                             (SEQ
                                                              (EXIT
                                                               (LETT
                                                                #16#
                                                                (CONS
                                                                 (QCAR
                                                                  |uf|)
                                                                 #16#) . #25#)))
                                                             (LETT #17#
                                                              (CDR
                                                               #17#) . #25#)
                                                             #27# G191
                                                             (EXIT
                                                              (NREVERSE0
                                                               #16#)))) . #25#)
                                                         (LETT |int|
                                                          |lval| . #25#)
                                                         (LETT |lffc|
                                                          |lffc1| . #25#)
                                                         (EXIT
                                                          (COND
                                                            (|testp|
                                                             (LETT
                                                              |leadcomp|
                                                              |leadcomp1| . #25#))))))))
                                                    ('T
                                                     (SEQ
                                                      (LETT |unifact|
                                                       (PROGN
                                                         (LETT #18#
                                                          NIL . #25#)
                                                         (SEQ
                                                          (LETT |uf|
                                                           NIL . #25#)
                                                          (LETT #19#
                                                           |lunivf| . #25#)
                                                          G190
                                                          (COND
                                                            ((OR
                                                              (ATOM
                                                               #19#)
                                                              (PROGN
                                                                (LETT
                                                                 |uf|
                                                                 (CAR
                                                                  #19#) . #25#)
                                                                NIL))
                                                             #26#))
                                                          (SEQ
                                                           (EXIT
                                                            (LETT #18#
                                                             (CONS
                                                              (QCAR
                                                               |uf|)
                                                              #18#) . #25#)))
                                                          (LETT #19#
                                                           (CDR #19#) . #25#)
                                                          #27# G191
                                                          (EXIT
                                                           (NREVERSE0
                                                            #18#)))) . #25#)
                                                      (LETT |int|
                                                       |lval| . #25#)
                                                      (LETT |lffc|
                                                       |lffc1| . #25#)
                                                      (EXIT
                                                       (COND
                                                         (|testp|
                                                          (LETT
                                                           |leadcomp|
                                                           |leadcomp1| . #25#)))))))))
                                               (EXIT
                                                (PROGN
                                                  (LETT #20#
                                                   "foundit" . #25#)
                                                  (GO #20#)))))
                                             ((< |degum| |nfatt|)
                                              (SEQ
                                               (LETT |unifact|
                                                (PROGN
                                                  (LETT #21#
                                                   NIL . #25#)
                                                  (SEQ
                                                   (LETT |uf|
                                                    NIL . #25#)
                                                   (LETT #22#
                                                    |lunivf| . #25#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #22#)
                                                       (PROGN
                                                         (LETT |uf|
                                                          (CAR #22#) . #25#)
                                                         NIL))
                                                      #26#))
                                                   (SEQ
                                                    (EXIT
                                                     (LETT #21#
                                                      (CONS (QCAR |uf|)
                                                       #21#) . #25#)))
                                                   (LETT #22#
                                                    (CDR #22#) . #25#)
                                                   #27# G191
                                                   (EXIT
                                                    (NREVERSE0 #21#)))) . #25#)
                                               (LETT |lffc|
                                                |lffc1| . #25#)
                                               (COND
                                                 (|testp|
                                                  (LETT |leadcomp|
                                                   |leadcomp1| . #25#)))
                                               (LETT |int|
                                                |lval| . #25#)
                                               (LETT |leadtest|
                                                'NIL . #25#)
                                               (EXIT
                                                (LETT |nfatt|
                                                 |nf| . #25#))))
                                             ((< |nf| |nfatt|)
                                              (SEQ
                                               (COND
                                                 (|testp|
                                                  (LETT |leadtest|
                                                   (COND
                                                     ((SPADCALL
                                                       (SPADCALL |lffc|
                                                        |clc|
                                                        (QREFELT $ 58))
                                                       (LENGTH |plist|)
                                                       |leadcomp|
                                                       (QREFELT $ 170))
                                                      'NIL)
                                                     ('T 'T)) . #25#))
                                                 ('T
                                                  (LETT |leadtest|
                                                   'NIL . #25#)))
                                               (COND
                                                 ((NULL |leadtest|)
                                                  (SEQ
                                                   (LETT |unifact|
                                                    (PROGN
                                                      (LETT #23#
                                                       NIL . #25#)
                                                      (SEQ
                                                       (LETT |uf|
                                                        NIL . #25#)
                                                       (LETT #24#
                                                        |lunivf| . #25#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #24#)
                                                           (PROGN
                                                             (LETT |uf|
                                                              (CAR
                                                               #24#) . #25#)
                                                             NIL))
                                                          #26#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT #23#
                                                          (CONS
                                                           (QCAR |uf|)
                                                           #23#) . #25#)))
                                                       (LETT #24#
                                                        (CDR #24#) . #25#)
                                                       #27# G191
                                                       (EXIT
                                                        (NREVERSE0
                                                         #23#)))) . #25#)
                                                   (LETT |lffc|
                                                    |lffc1| . #25#)
                                                   (COND
                                                     (|testp|
                                                      (LETT |leadcomp|
                                                       |leadcomp1| . #25#)))
                                                   (EXIT
                                                    (LETT |int|
                                                     |lval| . #25#)))))
                                               (EXIT
                                                (LETT |nfatt|
                                                 |nf| . #25#)))))))))))
                           NIL #27# G191 (EXIT NIL)))
                #20# (EXIT #20#))
           (EXIT (VECTOR (CONS |int| |ltry|) |unifact| |lffc|
                         |leadcomp|)))))) 

(DEFUN |MFINFACT;constantCase| (|m| |factorlist| $)
  (PROG (|lunm| #0=#:G2181 |pp| #1=#:G2182)
    (RETURN
      (SEQ (LETT |lunm|
                 (SPADCALL (SPADCALL |m| (QREFELT $ 130)) 'NIL
                     (QREFELT $ 192))
                 . #2=(|MFINFACT;constantCase|))
           (EXIT (CONS (SPADCALL (QCAR |lunm|) (QREFELT $ 97))
                       (APPEND |factorlist|
                               (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |pp| NIL . #2#)
                                      (LETT #1# (QCDR |lunm|) . #2#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |pp| (CAR #1#) . #2#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (CONS
                                           (SPADCALL (QCAR |pp|)
                                            (QREFELT $ 98))
                                           (QCDR |pp|))
                                          #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      (GO G190) G191
                                      (EXIT (NREVERSE0 #0#))))))))))) 

(DEFUN |MFINFACT;simplify| (|m| |dm| |lvar| |lmdeg| $)
  (PROG (|x| #0=#:G2193 |i| |pol1| |factorlist| #1=#:G2188 |flead|)
    (RETURN
      (SEQ (LETT |factorlist| NIL . #2=(|MFINFACT;simplify|))
           (LETT |pol1| (|spadConstant| $ 32) . #2#)
           (SEQ (LETT |x| NIL . #2#) (LETT #0# |lvar| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |x| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (LETT |i|
                           (SPADCALL |lmdeg|
                               (SPADCALL |x| |lvar| (QREFELT $ 193))
                               (QREFELT $ 194)) . #2#)
                     (EXIT (COND
                             ((EQL |i| 0) "next value")
                             ('T
                              (SEQ (LETT |pol1|
                                    (SPADCALL |pol1|
                                     (SPADCALL (|spadConstant| $ 32)
                                      |x| |i| (QREFELT $ 195))
                                     (QREFELT $ 196)) . #2#)
                                   (EXIT
                                    (LETT |factorlist|
                                     (CONS
                                      (CONS
                                       (SPADCALL |x| (QREFELT $ 197))
                                       |i|)
                                      |factorlist|) . #2#)))))))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (LETT |m|
                 (PROG2 (LETT #1#
                              (SPADCALL |m| |pol1| (QREFELT $ 89)) . #2#)
                        (QCDR #1#)
                   (|check-union| (QEQCAR #1# 0)
                       (|SparseMultivariatePolynomial|
                           (|SparseUnivariatePolynomial| (QREFELT $ 8))
                           (QREFELT $ 6))
                       #1#)) . #2#)
           (EXIT (COND
                   ((SPADCALL |m| (QREFELT $ 55))
                    (|MFINFACT;constantCase| |m| |factorlist| $))
                   ('T
                    (SEQ (LETT |flead|
                               (|MFINFACT;mFactor| |m| |dm| $) . #2#)
                         (PROGN
                           (RPLACD |flead|
                                   (APPEND |factorlist| (QCDR |flead|)))
                           (QCDR |flead|))
                         (EXIT |flead|))))))))) 

(DEFUN |MFINFACT;mfconst| (|um| |dm| |lvar| |ldeg| $)
  (PROG (|factfin| |um1| |lum| #0=#:G2202 |lumf| #1=#:G2203)
    (RETURN
      (SEQ (LETT |factfin| NIL . #2=(|MFINFACT;mfconst|))
           (EXIT (COND
                   ((NULL |lvar|)
                    (SEQ (LETT |um1|
                               (SPADCALL (ELT $ 198) |um|
                                   (QREFELT $ 201)) . #2#)
                         (LETT |lum|
                               (SPADCALL |um1| (QREFELT $ 182)) . #2#)
                         (EXIT (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |lumf| NIL . #2#)
                                      (LETT #1#
                                       (SPADCALL |lum| (QREFELT $ 185)) . #2#)
                                      G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |lumf|
                                             (CAR #1#) . #2#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL (ELT $ 98)
                                           (QCAR |lumf|)
                                           (QREFELT $ 204))
                                          #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      (GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))))))
                   ('T
                    (|MFINFACT;intfact| |um| |lvar| |ldeg|
                        (CONS (|spadConstant| $ 25) NIL) NIL $)))))))) 

(DEFUN |MFINFACT;mfpol| (|um| |dm| |lvar| |ldeg| $)
  (PROG (|tleadpol|)
    (RETURN
      (SEQ (LETT |tleadpol|
                 (|MFINFACT;mFactor| (SPADCALL |um| (QREFELT $ 54))
                     |dm| $)
                 |MFINFACT;mfpol|)
           (EXIT (|MFINFACT;intfact| |um| |lvar| |ldeg| |tleadpol| NIL
                     $)))))) 

(DEFUN |MFINFACT;factor;PGF;20| (|m| $)
  (PROG (|lv| #0=#:G2226 |x| #1=#:G2227 |ld| #2=#:G1816 #3=#:G2228
              #4=#:G2218 #5=#:G2216 #6=#:G2217 |dx| |cm| |flist| |u|
              #7=#:G2229 #8=#:G2222 #9=#:G2220 #10=#:G2221)
    (RETURN
      (SEQ (LETT |lv| (SPADCALL |m| (QREFELT $ 205))
                 . #11=(|MFINFACT;factor;PGF;20|))
           (EXIT (COND
                   ((SPADCALL |lv| NIL (QREFELT $ 206))
                    (SPADCALL |m| NIL (QREFELT $ 210)))
                   (#12='T
                    (SEQ (LETT |ld|
                               (PROGN
                                 (LETT #0# NIL . #11#)
                                 (SEQ (LETT |x| NIL . #11#)
                                      (LETT #1# |lv| . #11#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |x| (CAR #1#) . #11#)
                                            NIL))
                                         #13=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL |m| |x|
                                           (QREFELT $ 211))
                                          #0#) . #11#)))
                                      (LETT #1# (CDR #1#) . #11#)
                                      #14=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #11#)
                         (LETT |dx|
                               (PROGN
                                 (LETT #6# NIL . #11#)
                                 (SEQ (LETT #2# NIL . #11#)
                                      (LETT #3# |ld| . #11#) G190
                                      (COND
                                        ((OR (ATOM #3#)
                                          (PROGN
                                            (LETT #2# (CAR #3#) . #11#)
                                            NIL))
                                         #13#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #4# #2# . #11#)
                                          (COND
                                            (#6#
                                             (LETT #5#
                                              (MIN #5# #4#) . #11#))
                                            ('T
                                             (PROGN
                                               (LETT #5# #4# . #11#)
                                               (LETT #6# 'T . #11#)))))))
                                      (LETT #3# (CDR #3#) . #11#) #14#
                                      G191 (EXIT NIL))
                                 (COND
                                   (#6# #5#)
                                   (#12# (|IdentityError| '|min|)))) . #11#)
                         (SETELT $ 10
                                 (SPADCALL |lv|
                                     (SPADCALL |dx| |ld|
                                      (QREFELT $ 66))
                                     (QREFELT $ 67)))
                         (LETT |cm|
                               (|MFINFACT;pushdown| |m| (QREFELT $ 10)
                                   $) . #11#)
                         (LETT |flist|
                               (|MFINFACT;mFactor| |cm| |dx| $) . #11#)
                         (EXIT (SPADCALL
                                   (|MFINFACT;pushupconst|
                                    (QCAR |flist|) (QREFELT $ 10) $)
                                   (PROGN
                                     (LETT #10# NIL . #11#)
                                     (SEQ (LETT |u| NIL . #11#)
                                      (LETT #7# (QCDR |flist|) . #11#)
                                      G190
                                      (COND
                                        ((OR (ATOM #7#)
                                          (PROGN
                                            (LETT |u| (CAR #7#) . #11#)
                                            NIL))
                                         #13#))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #8#
                                           (SPADCALL
                                            (|MFINFACT;pushup|
                                             (QCAR |u|) (QREFELT $ 10)
                                             $)
                                            (QCDR |u|) (QREFELT $ 212)) . #11#)
                                          (COND
                                            (#10#
                                             (LETT #9#
                                              (SPADCALL #9# #8#
                                               (QREFELT $ 213)) . #11#))
                                            ('T
                                             (PROGN
                                               (LETT #9# #8# . #11#)
                                               (LETT #10# 'T . #11#)))))))
                                      (LETT #7# (CDR #7#) . #11#) #14#
                                      G191 (EXIT NIL))
                                     (COND
                                       (#10# #9#)
                                       (#12# (|spadConstant| $ 83))))
                                   (QREFELT $ 214))))))))))) 

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

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

(MAKEPROP '|MultFiniteFactorize| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) '|basicVar|
             (|SparseMultivariatePolynomial| 24 6)
             (|SparseUnivariatePolynomial| 11) (0 . |coerce|)
             (|NonNegativeInteger|) (5 . |degree|) (10 . |ground|)
             (|List| 11) (15 . |coefficients|) (|List| 6)
             (20 . |variables|) (25 . |setUnion|) (31 . |Zero|)
             (35 . |Zero|) (|SparseUnivariatePolynomial| 8)
             (39 . |Zero|) (43 . |minimumDegree|) (48 . |Zero|)
             (52 . |Zero|) (56 . |Zero|) (60 . |One|) (64 . |One|)
             (68 . |One|) (72 . |monomial|) (|Union| $ '"failed")
             (78 . |exquo|) (|SparseUnivariatePolynomial| 9)
             (|Mapping| 9 11)
             (|UnivariatePolynomialCategoryFunctions2| 11 12 9 36)
             (84 . |map|) (|Factored| $) (90 . |squareFree|)
             (|Factored| 36) (95 . |unit|) (|Mapping| 11 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 36 11 12)
             (100 . |map|) (|Boolean|) (106 . |ground?|)
             (|Record| (|:| |factor| 36) (|:| |exponent| 65))
             (|List| 49) (111 . |factors|) (116 . |content|)
             (121 . |degree|) (127 . |leadingCoefficient|)
             (132 . |ground?|) (137 . |leadingCoefficient|) (142 . **)
             (148 . *) (154 . |One|) (158 . |exquo|)
             (|FactoringUtilities| 7 6 8 9) (164 . |variables|)
             (|List| 14) (169 . |degree|) (|Integer|)
             (175 . |position|) (181 . |elt|) (187 . |coerce|)
             (192 . |primeFactor|) (198 . *) (204 . |One|) (208 . *)
             |MFINFACT;factor;SupF;3| (214 . |minimumDegree|)
             (220 . |squareFree|) (|Factored| 9) (225 . |unit|)
             (|Record| (|:| |factor| 9) (|:| |exponent| 65))
             (|List| 78) (230 . |factors|) (235 . |degree|)
             (241 . |One|) (245 . |One|) (249 . |member?|)
             (|SparseUnivariatePolynomial| $) (255 . |univariate|)
             (|List| $) (261 . |gcd|) (266 . |exquo|) (272 . =)
             (278 . =) (284 . |exquo|) (290 . |multivariate|)
             (296 . |leadingCoefficient|) (301 . =) (307 . |inv|)
             (312 . |coerce|) (317 . |coerce|) (322 . *)
             (328 . |monomial|) (334 . |size|) (|PositiveInteger|)
             (338 . |index|) (343 . +) (|List| 123)
             (|GenExEuclid| 24 123) (349 . |testModulus|)
             (|FiniteFieldPolynomialPackage| 8)
             (355 . |createIrreduciblePoly|) (|Union| 24 '"failed")
             (360 . |nextIrreduciblePoly|) (|Mapping| 24 8)
             (|MPolyCatFunctions2| 6 7 (|IndexedExponents| 6) 8 24 9
                 11)
             (365 . |map|)
             (|Record| (|:| |polfac| 17) (|:| |correct| 24)
                 (|:| |corrfact| 105))
             (|Union| 115 '"failed")
             (|Record| (|:| |irr| 11) (|:| |pow| 65))
             (|Record| (|:| |contp| 24) (|:| |factors| (|List| 117)))
             (|List| 24)
             (|LeadingCoefDetermination| 6 (|IndexedExponents| 6) 24
                 11)
             (371 . |distFact|) (381 . =)
             (|SparseUnivariatePolynomial| 24) (387 . |elt|) (393 . *)
             (|Union| (|List| 12) '"failed")
             (|MultivariateLifting| (|IndexedExponents| 6) 6 24 11)
             (399 . |lifting|) (410 . |primitivePart|)
             (415 . |retract|) (420 . |leadingMonomial|)
             (425 . |monomial|) (432 . +) (438 . |reductum|)
             (443 . |ground?|) (448 . |retract|) (453 . |univariate|)
             (459 . |Zero|) (463 . =) (469 . |degree|)
             (474 . |leadingCoefficient|) (479 . *) (485 . +)
             (491 . |reductum|) (496 . |ground?|) (501 . |retract|)
             (506 . |coerce|) (511 . |degree|) (516 . |monomial|)
             (523 . |reductum|) (528 . |random|) (532 . =)
             (538 . |Zero|) (542 . =) (548 . |degree|)
             (553 . |reductum|) (558 . |reductum|) (563 . |delete|)
             (569 . |delete|) (575 . =) (|List| 119) (581 . |member?|)
             (587 . |eval|) (594 . |unit?|)
             (|FactoringUtilities| (|IndexedExponents| 6) 6 24 11)
             (599 . |completeEval|) (606 . |minimumDegree|)
             (611 . |content|) (616 . |exquo|) (622 . |polCase|)
             (629 . |differentiate|) (634 . |differentiate|)
             (639 . |differentiate|) (644 . |differentiate|)
             (|Mapping| 24 24) (649 . |map|) (655 . |gcd|)
             (660 . |leadingCoefficient|) (665 . |coefficients|)
             (|Factored| 123) (|TwoFactorize| 8)
             (670 . |generalTwoFactor|)
             (|Record| (|:| |factor| 123) (|:| |exponent| 65))
             (|List| 183) (675 . |factors|) (680 . |unit|)
             (685 . |retract|) (690 . *)
             (|Record| (|:| |irr| 24) (|:| |pow| 65))
             (|Record| (|:| |cont| 8) (|:| |factors| (|List| 189)))
             (|DistinctDegreeFactorize| 8 24) (696 . |distdfact|)
             (702 . |position|) (708 . |elt|) (714 . |monomial|)
             (721 . *) (727 . |coerce|) (732 . |ground|)
             (|Mapping| 24 11)
             (|UnivariatePolynomialCategoryFunctions2| 11 12 24 123)
             (737 . |map|) (|Mapping| 11 24)
             (|UnivariatePolynomialCategoryFunctions2| 24 123 11 12)
             (743 . |map|) (749 . |variables|) (754 . =)
             (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 207) (|:| |fctr| 9) (|:| |xpnt| 65))
             (|List| 208) (760 . |makeFR|) (766 . |degree|)
             (772 . |primeFactor|) (778 . *) (784 . *)
             |MFINFACT;factor;PGF;20|)
          '#(|factor| 790) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 215
                                '(1 12 0 11 13 1 12 14 0 15 1 12 11 0
                                  16 1 12 17 0 18 1 11 19 0 20 2 19 0 0
                                  0 21 0 7 0 22 0 8 0 23 0 24 0 25 1 12
                                  14 0 26 0 9 0 27 0 12 0 28 0 11 0 29
                                  0 8 0 30 0 9 0 31 0 11 0 32 2 12 0 11
                                  14 33 2 12 34 0 0 35 2 38 36 37 12 39
                                  1 36 40 0 41 1 42 36 0 43 2 45 12 44
                                  36 46 1 12 47 0 48 1 42 50 0 51 1 12
                                  11 0 52 2 11 14 0 6 53 1 12 11 0 54 1
                                  11 47 0 55 1 11 24 0 56 2 24 0 0 14
                                  57 2 24 0 0 0 58 0 24 0 59 2 24 34 0
                                  0 60 1 61 19 36 62 2 61 63 36 19 64 2
                                  63 65 14 0 66 2 19 6 0 65 67 1 36 0 9
                                  68 2 42 0 36 65 69 2 42 0 0 0 70 0 42
                                  0 71 2 42 0 36 0 72 2 11 63 0 19 74 1
                                  9 40 0 75 1 76 9 0 77 1 76 79 0 80 2
                                  11 63 0 19 81 0 12 0 82 0 76 0 83 2
                                  63 47 14 0 84 2 11 85 0 6 86 1 11 0
                                  87 88 2 11 34 0 0 89 2 6 47 0 0 90 2
                                  11 47 0 0 91 2 12 34 0 11 92 2 11 0
                                  85 6 93 1 24 8 0 94 2 8 47 0 0 95 1 8
                                  0 0 96 1 24 0 8 97 1 11 0 24 98 2 12
                                  0 11 0 99 2 24 0 8 14 100 0 8 14 101
                                  1 8 0 102 103 2 24 0 0 0 104 2 106 47
                                  24 105 107 1 108 24 102 109 1 108 110
                                  24 111 2 113 11 112 9 114 6 120 116
                                  24 105 118 119 19 119 121 2 24 47 0 0
                                  122 2 105 123 0 65 124 2 123 0 24 0
                                  125 7 127 126 12 19 105 119 17 63 24
                                  128 1 12 0 0 129 1 11 24 0 130 1 11 0
                                  0 131 3 9 0 0 19 63 132 2 9 0 0 0 133
                                  1 11 0 0 134 1 9 47 0 135 1 9 8 0 136
                                  2 9 85 0 6 137 0 36 0 138 2 36 47 0 0
                                  139 1 36 14 0 140 1 36 9 0 141 2 11 0
                                  24 0 142 2 11 0 0 0 143 1 36 0 0 144
                                  1 24 47 0 145 1 24 8 0 146 1 9 0 8
                                  147 1 24 14 0 148 3 9 0 0 6 14 149 1
                                  24 0 0 150 0 8 0 151 2 12 47 0 0 152
                                  0 123 0 153 2 123 47 0 0 154 1 123 14
                                  0 155 1 12 0 0 156 1 123 0 0 157 2 63
                                  0 0 65 158 2 19 0 0 65 159 2 17 47 0
                                  0 160 2 161 47 119 0 162 3 11 0 0 19
                                  119 163 1 24 47 0 164 3 165 123 12 19
                                  119 166 1 123 14 0 167 1 123 24 0 168
                                  2 123 34 0 24 169 3 120 47 24 14 119
                                  170 1 123 0 0 171 1 8 0 0 172 1 24 0
                                  0 173 1 12 0 0 174 2 123 0 175 0 176
                                  1 123 0 87 177 1 123 24 0 178 1 123
                                  119 0 179 1 181 180 123 182 1 180 184
                                  0 185 1 180 123 0 186 1 123 24 0 187
                                  2 24 0 8 0 188 2 191 190 24 47 192 2
                                  19 65 6 0 193 2 63 14 0 65 194 3 11 0
                                  0 6 14 195 2 11 0 0 0 196 1 11 0 6
                                  197 1 11 24 0 198 2 200 123 199 12
                                  201 2 203 12 202 123 204 1 9 19 0 205
                                  2 19 47 0 0 206 2 76 0 9 209 210 2 9
                                  14 0 6 211 2 76 0 9 65 212 2 76 0 0 0
                                  213 2 76 0 9 0 214 1 0 42 36 73 1 0
                                  76 9 215)))))
          '|lookupComplete|)) 
