
(/VERSIONCHECK 2) 

(DEFUN |INNMFACT;convertPUP| (|lfg| $)
  (PROG (#0=#:G1849 |lff| #1=#:G1850)
    (RETURN
      (SEQ (CONS (QCAR |lfg|)
                 (PROGN
                   (LETT #0# NIL . #2=(|INNMFACT;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 $ 18))
                                      (QCDR |lff|))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#))))))))) 

(DEFUN |INNMFACT;supFactor| (|um| |ufactor| $)
  (PROG (|cf| #0=#:G1900 #1=#:G1854 #2=#:G1852 #3=#:G1853 |lvar| |umv|
              |lfact| #4=#:G1901 |ff| #5=#:G1902 |mdeg| |f1| #6=#:G1867
              #7=#:G1899 |uum| |sqfacs| |flead| |sqqfact| |fact|
              #8=#:G1903 |ffactor| |ffexp| |lfg| |lcont| #9=#:G1904
              |lff| #10=#:G1905 |coefs| #11=#:G1906 |xx| #12=#:G1907
              |fc| #13=#:G1908 #14=#:G1881 #15=#:G1879 #16=#:G1880
              |ldeg| |lf| #17=#:G1909 |lfp| #18=#:G1910 |auxfl|
              |factorlist| |f| #19=#:G1911 #20=#:G1892 #21=#:G1890
              #22=#:G1888 #23=#:G1889 |lcfacs| #24=#:G1894)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |um| (QREFELT $ 20))
                    (|INNMFACT;convertPUP|
                        (|INNMFACT;mFactor|
                            (SPADCALL |um| (QREFELT $ 21)) |ufactor| $)
                        $))
                   ('T
                    (SEQ (LETT |lvar|
                               (PROGN
                                 (LETT #3# NIL
                                       . #25=(|INNMFACT;supFactor|))
                                 (SEQ (LETT |cf| NIL . #25#)
                                      (LETT #0#
                                       (SPADCALL |um| (QREFELT $ 23)) . #25#)
                                      G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |cf|
                                             (CAR #0#) . #25#)
                                            NIL))
                                         #26=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (PROGN
                                          (LETT #1#
                                           (SPADCALL |cf|
                                            (QREFELT $ 25)) . #25#)
                                          (COND
                                            (#3#
                                             (LETT #2#
                                              (SPADCALL #2# #1#
                                               (QREFELT $ 26)) . #25#))
                                            ('T
                                             (PROGN
                                               (LETT #2# #1# . #25#)
                                               (LETT #3# 'T . #25#)))))))
                                      (LETT #0# (CDR #0#) . #25#)
                                      #27=(GO G190) G191 (EXIT NIL))
                                 (COND
                                   (#3# #2#)
                                   ('T (|IdentityError| '|setUnion|)))) . #25#)
                         (EXIT (COND
                                 ((NULL |lvar|)
                                  (SEQ (LETT |umv|
                                        (SPADCALL (ELT $ 27) |um|
                                         (QREFELT $ 31)) . #25#)
                                       (LETT |lfact|
                                        (SPADCALL |umv| |ufactor|) . #25#)
                                       (EXIT
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL |lfact|
                                           (QREFELT $ 33))
                                          (QREFELT $ 34))
                                         (PROGN
                                           (LETT #4# NIL . #25#)
                                           (SEQ (LETT |ff| NIL . #25#)
                                            (LETT #5#
                                             (SPADCALL |lfact|
                                              (QREFELT $ 37)) . #25#)
                                            G190
                                            (COND
                                              ((OR (ATOM #5#)
                                                (PROGN
                                                  (LETT |ff|
                                                   (CAR #5#) . #25#)
                                                  NIL))
                                               #26#))
                                            (SEQ
                                             (EXIT
                                              (LETT #4#
                                               (CONS
                                                (CONS
                                                 (SPADCALL (ELT $ 38)
                                                  (QCAR |ff|)
                                                  (QREFELT $ 41))
                                                 (QCDR |ff|))
                                                #4#) . #25#)))
                                            (LETT #5# (CDR #5#) . #25#)
                                            #27# G191
                                            (EXIT (NREVERSE0 #4#))))))))
                                 ('T
                                  (SEQ (LETT |flead|
                                        (CONS (|spadConstant| $ 43)
                                         NIL) . #25#)
                                       (LETT |factorlist| NIL . #25#)
                                       (LETT |mdeg|
                                        (SPADCALL |um| (QREFELT $ 45)) . #25#)
                                       (COND
                                         ((< 0 |mdeg|)
                                          (SEQ
                                           (LETT |f1|
                                            (SPADCALL
                                             (|spadConstant| $ 51)
                                             |mdeg| (QREFELT $ 52)) . #25#)
                                           (LETT |um|
                                            (PROG2
                                             (LETT #6#
                                              (SPADCALL |um| |f1|
                                               (QREFELT $ 54)) . #25#)
                                             (QCDR #6#)
                                              (|check-union|
                                               (QEQCAR #6# 0)
                                               (|SparseUnivariatePolynomial|
                                                (QREFELT $ 9))
                                               #6#)) . #25#)
                                           (LETT |factorlist|
                                            (CONS
                                             (CONS
                                              (SPADCALL
                                               (|spadConstant| $ 51) 1
                                               (QREFELT $ 52))
                                              |mdeg|)
                                             |factorlist|) . #25#)
                                           (EXIT
                                            (COND
                                              ((EQL
                                                (SPADCALL |um|
                                                 (QREFELT $ 55))
                                                0)
                                               (PROGN
                                                 (LETT #7#
                                                  (SEQ
                                                   (LETT |lfg|
                                                    (|INNMFACT;convertPUP|
                                                     (|INNMFACT;mFactor|
                                                      (SPADCALL |um|
                                                       (QREFELT $ 21))
                                                      |ufactor| $)
                                                     $) . #25#)
                                                   (EXIT
                                                    (CONS (QCAR |lfg|)
                                                     (APPEND
                                                      |factorlist|
                                                      (QCDR |lfg|))))) . #25#)
                                                 (GO #7#))))))))
                                       (LETT |uum|
                                        (SPADCALL |um| (QREFELT $ 57)) . #25#)
                                       (LETT |um|
                                        (QVELT |uum| 1) . #25#)
                                       (LETT |sqfacs|
                                        (SPADCALL |um| (QREFELT $ 60)) . #25#)
                                       (LETT |lcont|
                                        (SPADCALL
                                         (SPADCALL (QVELT |uum| 0)
                                          (SPADCALL |sqfacs|
                                           (QREFELT $ 61))
                                          (QREFELT $ 62))
                                         (QREFELT $ 21)) . #25#)
                                       (LETT |flead|
                                        (|INNMFACT;convertPUP|
                                         (|INNMFACT;mFactor| |lcont|
                                          |ufactor| $)
                                         $) . #25#)
                                       (LETT |factorlist|
                                        (APPEND (QCDR |flead|)
                                         |factorlist|) . #25#)
                                       (LETT |sqqfact|
                                        (SPADCALL |sqfacs|
                                         (QREFELT $ 65)) . #25#)
                                       (SEQ (LETT |fact| NIL . #25#)
                                        (LETT #8# |sqqfact| . #25#)
                                        G190
                                        (COND
                                          ((OR (ATOM #8#)
                                            (PROGN
                                              (LETT |fact|
                                               (CAR #8#) . #25#)
                                              NIL))
                                           #26#))
                                        (SEQ
                                         (LETT |ffactor|
                                          (QCAR |fact|) . #25#)
                                         (LETT |ffexp|
                                          (QCDR |fact|) . #25#)
                                         (EXIT
                                          (COND
                                            ((ZEROP
                                              (SPADCALL |ffactor|
                                               (QREFELT $ 55)))
                                             (SEQ
                                              (LETT |lfg|
                                               (|INNMFACT;mFactor|
                                                (SPADCALL |ffactor|
                                                 (QREFELT $ 21))
                                                |ufactor| $) . #25#)
                                              (LETT |lcont|
                                               (SPADCALL (QCAR |lfg|)
                                                |lcont| (QREFELT $ 66)) . #25#)
                                              (EXIT
                                               (LETT |factorlist|
                                                (APPEND |factorlist|
                                                 (PROGN
                                                   (LETT #9#
                                                    NIL . #25#)
                                                   (SEQ
                                                    (LETT |lff|
                                                     NIL . #25#)
                                                    (LETT #10#
                                                     (QCDR |lfg|) . #25#)
                                                    G190
                                                    (COND
                                                      ((OR (ATOM #10#)
                                                        (PROGN
                                                          (LETT |lff|
                                                           (CAR #10#) . #25#)
                                                          NIL))
                                                       #26#))
                                                    (SEQ
                                                     (EXIT
                                                      (LETT #9#
                                                       (CONS
                                                        (CONS
                                                         (SPADCALL
                                                          (QCAR |lff|)
                                                          (QREFELT $
                                                           18))
                                                         (*
                                                          (QCDR |lff|)
                                                          |ffexp|))
                                                        #9#) . #25#)))
                                                    (LETT #10#
                                                     (CDR #10#) . #25#)
                                                    #27# G191
                                                    (EXIT
                                                     (NREVERSE0 #9#))))) . #25#))))
                                            ('T
                                             (SEQ
                                              (LETT |coefs|
                                               (SPADCALL |ffactor|
                                                (QREFELT $ 23)) . #25#)
                                              (LETT |ldeg|
                                               (PROGN
                                                 (LETT #11# NIL . #25#)
                                                 (SEQ
                                                  (LETT |xx|
                                                   NIL . #25#)
                                                  (LETT #12#
                                                   |lvar| . #25#)
                                                  G190
                                                  (COND
                                                    ((OR (ATOM #12#)
                                                      (PROGN
                                                        (LETT |xx|
                                                         (CAR #12#) . #25#)
                                                        NIL))
                                                     #26#))
                                                  (SEQ
                                                   (EXIT
                                                    (LETT #11#
                                                     (CONS
                                                      (PROGN
                                                        (LETT #16#
                                                         NIL . #25#)
                                                        (SEQ
                                                         (LETT |fc|
                                                          NIL . #25#)
                                                         (LETT #13#
                                                          |coefs| . #25#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM
                                                              #13#)
                                                             (PROGN
                                                               (LETT
                                                                |fc|
                                                                (CAR
                                                                 #13#) . #25#)
                                                               NIL))
                                                            #26#))
                                                         (SEQ
                                                          (EXIT
                                                           (PROGN
                                                             (LETT #14#
                                                              (SPADCALL
                                                               |fc|
                                                               |xx|
                                                               (QREFELT
                                                                $ 67)) . #25#)
                                                             (COND
                                                               (#16#
                                                                (LETT
                                                                 #15#
                                                                 (MAX
                                                                  #15#
                                                                  #14#) . #25#))
                                                               ('T
                                                                (PROGN
                                                                  (LETT
                                                                   #15#
                                                                   #14# . #25#)
                                                                  (LETT
                                                                   #16#
                                                                   'T . #25#)))))))
                                                         (LETT #13#
                                                          (CDR #13#) . #25#)
                                                         #27# G191
                                                         (EXIT NIL))
                                                        (COND
                                                          (#16# #15#)
                                                          ('T
                                                           (|IdentityError|
                                                            '|max|))))
                                                      #11#) . #25#)))
                                                  (LETT #12#
                                                   (CDR #12#) . #25#)
                                                  #27# G191
                                                  (EXIT
                                                   (NREVERSE0 #11#)))) . #25#)
                                              (LETT |lf|
                                               (COND
                                                 ((SPADCALL
                                                   (SPADCALL |ffactor|
                                                    (QREFELT $ 68))
                                                   (QREFELT $ 69))
                                                  (|INNMFACT;mfconst|
                                                   |ffactor| |lvar|
                                                   |ldeg| |ufactor| $))
                                                 ('T
                                                  (|INNMFACT;mfpol|
                                                   |ffactor| |lvar|
                                                   |ldeg| |ufactor| $))) . #25#)
                                              (LETT |auxfl|
                                               (PROGN
                                                 (LETT #17# NIL . #25#)
                                                 (SEQ
                                                  (LETT |lfp|
                                                   NIL . #25#)
                                                  (LETT #18#
                                                   |lf| . #25#)
                                                  G190
                                                  (COND
                                                    ((OR (ATOM #18#)
                                                      (PROGN
                                                        (LETT |lfp|
                                                         (CAR #18#) . #25#)
                                                        NIL))
                                                     #26#))
                                                  (SEQ
                                                   (EXIT
                                                    (LETT #17#
                                                     (CONS
                                                      (CONS |lfp|
                                                       |ffexp|)
                                                      #17#) . #25#)))
                                                  (LETT #18#
                                                   (CDR #18#) . #25#)
                                                  #27# G191
                                                  (EXIT
                                                   (NREVERSE0 #17#)))) . #25#)
                                              (EXIT
                                               (LETT |factorlist|
                                                (APPEND |factorlist|
                                                 |auxfl|) . #25#)))))))
                                        (LETT #8# (CDR #8#) . #25#)
                                        #27# G191 (EXIT NIL))
                                       (LETT |lcfacs|
                                        (PROGN
                                          (LETT #23# NIL . #25#)
                                          (SEQ (LETT |f| NIL . #25#)
                                           (LETT #19#
                                            |factorlist| . #25#)
                                           G190
                                           (COND
                                             ((OR (ATOM #19#)
                                               (PROGN
                                                 (LETT |f|
                                                  (CAR #19#) . #25#)
                                                 NIL))
                                              #26#))
                                           (SEQ
                                            (EXIT
                                             (PROGN
                                               (LETT #21#
                                                (SPADCALL
                                                 (SPADCALL
                                                  (SPADCALL (QCAR |f|)
                                                   (QREFELT $ 68))
                                                  (QREFELT $ 70))
                                                 (PROG1
                                                  (LETT #20#
                                                   (QCDR |f|) . #25#)
                                                   (|check-subtype|
                                                    (>= #20# 0)
                                                    '(|NonNegativeInteger|)
                                                    #20#))
                                                 (QREFELT $ 71)) . #25#)
                                               (COND
                                                 (#23#
                                                  (LETT #22#
                                                   (SPADCALL #22# #21#
                                                    (QREFELT $ 72)) . #25#))
                                                 ('T
                                                  (PROGN
                                                    (LETT #22#
                                                     #21# . #25#)
                                                    (LETT #23#
                                                     'T . #25#)))))))
                                           (LETT #19#
                                            (CDR #19#) . #25#)
                                           #27# G191 (EXIT NIL))
                                          (COND
                                            (#23# #22#)
                                            ('T (|spadConstant| $ 50)))) . #25#)
                                       (EXIT
                                        (CONS
                                         (PROG2
                                          (LETT #24#
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |um|
                                              (QREFELT $ 68))
                                             (QREFELT $ 70))
                                            |lcfacs| (QREFELT $ 73)) . #25#)
                                          (QCDR #24#)
                                           (|check-union|
                                            (QEQCAR #24# 0)
                                            (QREFELT $ 8) #24#))
                                         |factorlist|))))))))))
           #7# (EXIT #7#))))) 

(DEFUN |INNMFACT;factor;SupMF;3| (|um| |ufactor| $)
  (PROG (|flist| |u| #0=#:G1919 #1=#:G1915 #2=#:G1913 #3=#:G1914)
    (RETURN
      (SEQ (LETT |flist| (|INNMFACT;supFactor| |um| |ufactor| $)
                 . #4=(|INNMFACT;factor;SupMF;3|))
           (EXIT (SPADCALL
                     (SPADCALL (SPADCALL (QCAR |flist|) (QREFELT $ 38))
                         (QREFELT $ 18))
                     (PROGN
                       (LETT #3# NIL . #4#)
                       (SEQ (LETT |u| NIL . #4#)
                            (LETT #0# (QCDR |flist|) . #4#) G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |u| (CAR #0#) . #4#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #1#
                                          (SPADCALL (QCAR |u|)
                                           (QCDR |u|) (QREFELT $ 74)) . #4#)
                                         (COND
                                           (#3#
                                            (LETT #2#
                                             (SPADCALL #2# #1#
                                              (QREFELT $ 75)) . #4#))
                                           ('T
                                            (PROGN
                                              (LETT #2# #1# . #4#)
                                              (LETT #3# 'T . #4#)))))))
                            (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                            (EXIT NIL))
                       (COND (#3# #2#) ('T (|spadConstant| $ 76))))
                     (QREFELT $ 77))))))) 

(DEFUN |INNMFACT;checkzero| (|u| |um| $)
  (COND
    ((SPADCALL |u| (|spadConstant| $ 47) (QREFELT $ 80))
     (SPADCALL |um| (|spadConstant| $ 48) (QREFELT $ 81)))
    ((SPADCALL |um| (|spadConstant| $ 48) (QREFELT $ 81)) 'NIL)
    ('T
     (COND
       ((EQL (SPADCALL |u| (QREFELT $ 55))
             (SPADCALL |um| (QREFELT $ 82)))
        (|INNMFACT;checkzero| (SPADCALL |u| (QREFELT $ 83))
            (SPADCALL |um| (QREFELT $ 84)) $))
       ('T 'NIL))))) 

(DEFUN |INNMFACT;varChoose| (|m| |lvar| |ldeg| $)
  (PROG (|d| #0=#:G1929 #1=#:G1925 #2=#:G1923 #3=#:G1924 |k| |i| |x|)
    (RETURN
      (SEQ (LETT |k|
                 (PROGN
                   (LETT #3# NIL . #4=(|INNMFACT;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 $ 67)))
                    (VECTOR (SPADCALL |m| (|SPADfirst| |lvar|)
                                (QREFELT $ 86))
                            |lvar| |ldeg|))
                   ('T
                    (SEQ (LETT |i|
                               (SPADCALL |k| |ldeg| (QREFELT $ 88)) . #4#)
                         (LETT |x|
                               (SPADCALL |lvar| |i| (QREFELT $ 89)) . #4#)
                         (LETT |ldeg|
                               (CONS |k|
                                     (SPADCALL |ldeg| |i|
                                      (QREFELT $ 90))) . #4#)
                         (LETT |lvar|
                               (CONS |x|
                                     (SPADCALL |lvar| |i|
                                      (QREFELT $ 91))) . #4#)
                         (EXIT (VECTOR (SPADCALL |m| |x|
                                        (QREFELT $ 86))
                                       |lvar| |ldeg|)))))))))) 

(DEFUN |INNMFACT;localNorm| (|lum| $)
  (PROG (#0=#:G1941 #1=#:G1932 #2=#:G1930 #3=#:G1931 |ff| #4=#:G1942
            |i| #5=#:G1943 |cc| #6=#:G1939 #7=#:G1937 #8=#:G1938
            #9=#:G1935 #10=#:G1933 #11=#:G1934)
    (RETURN
      (SEQ (COND
             ((|domainEqual| (QREFELT $ 8) (|AlgebraicNumber|))
              (PROGN
                (LETT #3# NIL . #12=(|INNMFACT;localNorm|))
                (SEQ (LETT |ff| NIL . #12#) (LETT #0# |lum| . #12#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |ff| (CAR #0#) . #12#) NIL))
                        #13=(GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL |ff| (QREFELT $ 92)) . #12#)
                                  (COND
                                    (#3#
                                     (LETT #2# (MAX #2# #1#) . #12#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #12#)
                                       (LETT #3# 'T . #12#)))))))
                     (LETT #0# (CDR #0#) . #12#) #14=(GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#15='T (|IdentityError| '|max|)))))
             (#15#
              (PROGN
                (LETT #11# NIL . #12#)
                (SEQ (LETT |ff| NIL . #12#) (LETT #4# |lum| . #12#)
                     G190
                     (COND
                       ((OR (ATOM #4#)
                            (PROGN (LETT |ff| (CAR #4#) . #12#) NIL))
                        #13#))
                     (SEQ (EXIT (PROGN
                                  (LETT #9#
                                        (PROGN
                                          (LETT #8# NIL . #12#)
                                          (SEQ (LETT |i| 0 . #12#)
                                           (LETT #5#
                                            (SPADCALL |ff|
                                             (QREFELT $ 82)) . #12#)
                                           G190
                                           (COND
                                             ((QSGREATERP |i| #5#)
                                              #13#))
                                           (SEQ
                                            (EXIT
                                             (COND
                                               ((SEQ
                                                 (LETT |cc|
                                                  (SPADCALL |ff| |i|
                                                   (QREFELT $ 93)) . #12#)
                                                 (EXIT
                                                  (COND
                                                    ((SPADCALL |cc|
                                                      (|spadConstant| $
                                                       43)
                                                      (QREFELT $ 94))
                                                     'NIL)
                                                    ('T 'T))))
                                                (PROGN
                                                  (LETT #6#
                                                   (SPADCALL |cc|
                                                    (QREFELT $ 95)) . #12#)
                                                  (COND
                                                    (#8#
                                                     (LETT #7#
                                                      (+ #7# #6#) . #12#))
                                                    ('T
                                                     (PROGN
                                                       (LETT #7#
                                                        #6# . #12#)
                                                       (LETT #8#
                                                        'T . #12#)))))))))
                                           (LETT |i|
                                            (QSADD1 |i|) . #12#)
                                           #14# G191 (EXIT NIL))
                                          (COND (#8# #7#) ('T 0))) . #12#)
                                  (COND
                                    (#11#
                                     (LETT #10# (MAX #10# #9#) . #12#))
                                    ('T
                                     (PROGN
                                       (LETT #10# #9# . #12#)
                                       (LETT #11# 'T . #12#)))))))
                     (LETT #4# (CDR #4#) . #12#) #14# G191 (EXIT NIL))
                (COND (#11# #10#) (#15# (|IdentityError| '|max|)))))))))) 

(DEFUN |INNMFACT;intChoose|
       (|um| |lvar| |clc| |plist| |ltry| |ufactor| $)
  (PROG (|degum| |nvar1| |ctf1| |testp| |newunifact| #0=#:G2021
                 #1=#:G2022 |i| |lval| #2=#:G2023 |pol| #3=#:G2024
                 |leadcomp1| |epl| #4=#:G2025 #5=#:G1954 #6=#:G1952
                 #7=#:G1953 #8=#:G1959 |newm| |range| |luniv| |lunivf|
                 |lffc1| |nf| #9=#:G2026 #10=#:G2027 #11=#:G2028 |ff|
                 #12=#:G2029 #13=#:G2030 #14=#:G2031 #15=#:G2032
                 #16=#:G2033 #17=#:G2019 #18=#:G2034 #19=#:G2035
                 |leadtest| #20=#:G2036 |uf| #21=#:G2037 |unifact|
                 |lffc| |leadcomp| |int| |nfatt|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |degum| (SPADCALL |um| (QREFELT $ 55))
                            . #22=(|INNMFACT;intChoose|))
                      (LETT |nvar1| (LENGTH |lvar|) . #22#)
                      (LETT |range| 5 . #22#)
                      (LETT |ctf1| (|spadConstant| $ 50) . #22#)
                      (LETT |testp|
                            (COND ((NULL |plist|) 'NIL) ('T 'T)) . #22#)
                      (LETT |leadcomp|
                            (LETT |leadcomp1| NIL . #22#) . #22#)
                      (LETT |nfatt| (+ |degum| 1) . #22#)
                      (LETT |lffc| (|spadConstant| $ 50) . #22#)
                      (LETT |lffc1| |lffc| . #22#)
                      (LETT |newunifact| NIL . #22#)
                      (LETT |leadtest| 'T . #22#)
                      (LETT |int| NIL . #22#)
                      (SEQ (EXIT (SEQ G190
                                      (COND ((NULL 'T) #23=(GO G191)))
                                      (SEQ
                                       (COND
                                         (|testp|
                                          (COND
                                            ((< 10 (LENGTH |ltry|))
                                             (EXIT
                                              (PROGN
                                                (LETT #0#
                                                 (CONS 1 "failed") . #22#)
                                                (GO #0#)))))))
                                       (LETT |lval|
                                        (PROGN
                                          (LETT #1# NIL . #22#)
                                          (SEQ (LETT |i| 1 . #22#) G190
                                           (COND
                                             ((QSGREATERP |i| |nvar1|)
                                              #23#))
                                           (SEQ
                                            (EXIT
                                             (LETT #1#
                                              (CONS
                                               (SPADCALL |range|
                                                (QREFELT $ 97))
                                               #1#) . #22#)))
                                           (LETT |i|
                                            (QSADD1 |i|) . #22#)
                                           #24=(GO G190) G191
                                           (EXIT (NREVERSE0 #1#)))) . #22#)
                                       (EXIT
                                        (COND
                                          ((SPADCALL |lval| |ltry|
                                            (QREFELT $ 100))
                                           (LETT |range|
                                            (SPADCALL 2 |range|
                                             (QREFELT $ 101)) . #22#))
                                          ('T
                                           (SEQ
                                            (LETT |ltry|
                                             (CONS |lval| |ltry|) . #22#)
                                            (LETT |leadcomp1|
                                             (PROGN
                                               (LETT #2# NIL . #22#)
                                               (SEQ
                                                (LETT |pol| NIL . #22#)
                                                (LETT #3#
                                                 |plist| . #22#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #3#)
                                                    (PROGN
                                                      (LETT |pol|
                                                       (CAR #3#) . #22#)
                                                      NIL))
                                                   #23#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #2#
                                                   (CONS
                                                    (SPADCALL
                                                     (SPADCALL |pol|
                                                      |lvar| |lval|
                                                      (QREFELT $ 102))
                                                     (QREFELT $ 103))
                                                    #2#) . #22#)))
                                                (LETT #3#
                                                 (CDR #3#) . #22#)
                                                #24# G191
                                                (EXIT (NREVERSE0 #2#)))) . #22#)
                                            (COND
                                              (|testp|
                                               (COND
                                                 ((PROGN
                                                    (LETT #7#
                                                     NIL . #22#)
                                                    (SEQ
                                                     (LETT |epl|
                                                      NIL . #22#)
                                                     (LETT #4#
                                                      |leadcomp1| . #22#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #4#)
                                                         (PROGN
                                                           (LETT |epl|
                                                            (CAR #4#) . #22#)
                                                           NIL))
                                                        #23#))
                                                     (SEQ
                                                      (EXIT
                                                       (PROGN
                                                         (LETT #5#
                                                          (SPADCALL
                                                           |epl|
                                                           (QREFELT $
                                                            104)) . #22#)
                                                         (COND
                                                           (#7#
                                                            (LETT #6#
                                                             (COND
                                                               (#6# 'T)
                                                               ('T #5#)) . #22#))
                                                           ('T
                                                            (PROGN
                                                              (LETT #6#
                                                               #5# . #22#)
                                                              (LETT #7#
                                                               'T . #22#)))))))
                                                     (LETT #4#
                                                      (CDR #4#) . #22#)
                                                     #24# G191
                                                     (EXIT NIL))
                                                    (COND
                                                      (#7# #6#)
                                                      ('T 'NIL)))
                                                  (EXIT
                                                   (LETT |range|
                                                    (SPADCALL 2 |range|
                                                     (QREFELT $ 101)) . #22#))))))
                                            (LETT |newm|
                                             (SPADCALL |um| |lvar|
                                              |lval| (QREFELT $ 105)) . #22#)
                                            (COND
                                              ((EQL |degum|
                                                (SPADCALL |newm|
                                                 (QREFELT $ 82)))
                                               (COND
                                                 ((NULL
                                                   (EQL
                                                    (SPADCALL |newm|
                                                     (QREFELT $ 106))
                                                    0))
                                                  (EXIT
                                                   (LETT |range|
                                                    (SPADCALL 2 |range|
                                                     (QREFELT $ 101)) . #22#)))))
                                              ('T
                                               (EXIT
                                                (LETT |range|
                                                 (SPADCALL 2 |range|
                                                  (QREFELT $ 101)) . #22#))))
                                            (LETT |lffc1|
                                             (SPADCALL |newm|
                                              (QREFELT $ 107)) . #22#)
                                            (LETT |newm|
                                             (PROG2
                                              (LETT #8#
                                               (SPADCALL |newm| |lffc1|
                                                (QREFELT $ 108)) . #22#)
                                              (QCDR #8#)
                                               (|check-union|
                                                (QEQCAR #8# 0)
                                                (|SparseUnivariatePolynomial|
                                                 (QREFELT $ 8))
                                                #8#)) . #22#)
                                            (COND
                                              (|testp|
                                               (COND
                                                 (|leadtest|
                                                  (COND
                                                    ((NULL
                                                      (SPADCALL
                                                       (SPADCALL
                                                        |lffc1| |clc|
                                                        (QREFELT $ 72))
                                                       (LENGTH |plist|)
                                                       |leadcomp1|
                                                       (QREFELT $ 110)))
                                                     (EXIT
                                                      (LETT |range|
                                                       (SPADCALL 2
                                                        |range|
                                                        (QREFELT $ 101)) . #22#))))))))
                                            (COND
                                              ((NULL
                                                (EQL
                                                 (SPADCALL
                                                  (SPADCALL
                                                   (LIST |newm|
                                                    (SPADCALL |newm|
                                                     (QREFELT $ 111)))
                                                   (QREFELT $ 113))
                                                  (QREFELT $ 82))
                                                 0))
                                               (EXIT
                                                (LETT |range|
                                                 (SPADCALL 2 |range|
                                                  (QREFELT $ 101)) . #22#))))
                                            (LETT |luniv|
                                             (SPADCALL |newm|
                                              |ufactor|) . #22#)
                                            (LETT |lunivf|
                                             (SPADCALL |luniv|
                                              (QREFELT $ 37)) . #22#)
                                            (LETT |lffc1|
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |luniv|
                                                (QREFELT $ 33))
                                               (QREFELT $ 34))
                                              |lffc1| (QREFELT $ 72)) . #22#)
                                            (LETT |nf|
                                             (LENGTH |lunivf|) . #22#)
                                            (COND
                                              ((OR (EQL |nf| 0)
                                                (< |nfatt| |nf|))
                                               (EXIT "next values")))
                                            (COND
                                              ((EQL |nf| 1)
                                               (PROGN
                                                 (LETT #17#
                                                  (LETT |unifact|
                                                   (LIST |newm|) . #22#) . #22#)
                                                 (GO #17#))))
                                            (EXIT
                                             (COND
                                               ((EQL |nfatt| |nf|)
                                                (SEQ
                                                 (COND
                                                   (|leadtest|
                                                    (SEQ
                                                     (LETT |unifact|
                                                      (PROGN
                                                        (LETT #9#
                                                         NIL . #22#)
                                                        (SEQ
                                                         (LETT |uf|
                                                          NIL . #22#)
                                                         (LETT #10#
                                                          |lunivf| . #22#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM
                                                              #10#)
                                                             (PROGN
                                                               (LETT
                                                                |uf|
                                                                (CAR
                                                                 #10#) . #22#)
                                                               NIL))
                                                            #23#))
                                                         (SEQ
                                                          (EXIT
                                                           (LETT #9#
                                                            (CONS
                                                             (QCAR
                                                              |uf|)
                                                             #9#) . #22#)))
                                                         (LETT #10#
                                                          (CDR #10#) . #22#)
                                                         #24# G191
                                                         (EXIT
                                                          (NREVERSE0
                                                           #9#)))) . #22#)
                                                     (LETT |int|
                                                      |lval| . #22#)
                                                     (LETT |lffc|
                                                      |lffc1| . #22#)
                                                     (EXIT
                                                      (COND
                                                        (|testp|
                                                         (LETT
                                                          |leadcomp|
                                                          |leadcomp1| . #22#))))))
                                                   ((<
                                                     (|INNMFACT;localNorm|
                                                      (PROGN
                                                        (LETT #11#
                                                         NIL . #22#)
                                                        (SEQ
                                                         (LETT |ff|
                                                          NIL . #22#)
                                                         (LETT #12#
                                                          |lunivf| . #22#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM
                                                              #12#)
                                                             (PROGN
                                                               (LETT
                                                                |ff|
                                                                (CAR
                                                                 #12#) . #22#)
                                                               NIL))
                                                            #23#))
                                                         (SEQ
                                                          (EXIT
                                                           (LETT #11#
                                                            (CONS
                                                             (QCAR
                                                              |ff|)
                                                             #11#) . #22#)))
                                                         (LETT #12#
                                                          (CDR #12#) . #22#)
                                                         #24# G191
                                                         (EXIT
                                                          (NREVERSE0
                                                           #11#))))
                                                      $)
                                                     (|INNMFACT;localNorm|
                                                      |unifact| $))
                                                    (COND
                                                      (|testp|
                                                       (COND
                                                         ((SPADCALL
                                                           (SPADCALL
                                                            |lffc1|
                                                            |clc|
                                                            (QREFELT $
                                                             72))
                                                           (LENGTH
                                                            |plist|)
                                                           |leadcomp1|
                                                           (QREFELT $
                                                            110))
                                                          (SEQ
                                                           (LETT
                                                            |unifact|
                                                            (PROGN
                                                              (LETT
                                                               #13#
                                                               NIL . #22#)
                                                              (SEQ
                                                               (LETT
                                                                |uf|
                                                                NIL . #22#)
                                                               (LETT
                                                                #14#
                                                                |lunivf| . #22#)
                                                               G190
                                                               (COND
                                                                 ((OR
                                                                   (ATOM
                                                                    #14#)
                                                                   (PROGN
                                                                     (LETT
                                                                      |uf|
                                                                      (CAR
                                                                       #14#) . #22#)
                                                                     NIL))
                                                                  #23#))
                                                               (SEQ
                                                                (EXIT
                                                                 (LETT
                                                                  #13#
                                                                  (CONS
                                                                   (QCAR
                                                                    |uf|)
                                                                   #13#) . #22#)))
                                                               (LETT
                                                                #14#
                                                                (CDR
                                                                 #14#) . #22#)
                                                               #24#
                                                               G191
                                                               (EXIT
                                                                (NREVERSE0
                                                                 #13#)))) . #22#)
                                                           (LETT |int|
                                                            |lval| . #22#)
                                                           (LETT |lffc|
                                                            |lffc1| . #22#)
                                                           (EXIT
                                                            (COND
                                                              (|testp|
                                                               (LETT
                                                                |leadcomp|
                                                                |leadcomp1| . #22#))))))))
                                                      ('T
                                                       (SEQ
                                                        (LETT |unifact|
                                                         (PROGN
                                                           (LETT #15#
                                                            NIL . #22#)
                                                           (SEQ
                                                            (LETT |uf|
                                                             NIL . #22#)
                                                            (LETT #16#
                                                             |lunivf| . #22#)
                                                            G190
                                                            (COND
                                                              ((OR
                                                                (ATOM
                                                                 #16#)
                                                                (PROGN
                                                                  (LETT
                                                                   |uf|
                                                                   (CAR
                                                                    #16#) . #22#)
                                                                  NIL))
                                                               #23#))
                                                            (SEQ
                                                             (EXIT
                                                              (LETT
                                                               #15#
                                                               (CONS
                                                                (QCAR
                                                                 |uf|)
                                                                #15#) . #22#)))
                                                            (LETT #16#
                                                             (CDR #16#) . #22#)
                                                            #24# G191
                                                            (EXIT
                                                             (NREVERSE0
                                                              #15#)))) . #22#)
                                                        (LETT |int|
                                                         |lval| . #22#)
                                                        (LETT |lffc|
                                                         |lffc1| . #22#)
                                                        (EXIT
                                                         (COND
                                                           (|testp|
                                                            (LETT
                                                             |leadcomp|
                                                             |leadcomp1| . #22#)))))))))
                                                 (EXIT
                                                  (PROGN
                                                    (LETT #17#
                                                     "foundit" . #22#)
                                                    (GO #17#)))))
                                               ((< |degum| |nfatt|)
                                                (SEQ
                                                 (LETT |unifact|
                                                  (PROGN
                                                    (LETT #18#
                                                     NIL . #22#)
                                                    (SEQ
                                                     (LETT |uf|
                                                      NIL . #22#)
                                                     (LETT #19#
                                                      |lunivf| . #22#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #19#)
                                                         (PROGN
                                                           (LETT |uf|
                                                            (CAR #19#) . #22#)
                                                           NIL))
                                                        #23#))
                                                     (SEQ
                                                      (EXIT
                                                       (LETT #18#
                                                        (CONS
                                                         (QCAR |uf|)
                                                         #18#) . #22#)))
                                                     (LETT #19#
                                                      (CDR #19#) . #22#)
                                                     #24# G191
                                                     (EXIT
                                                      (NREVERSE0 #18#)))) . #22#)
                                                 (LETT |lffc|
                                                  |lffc1| . #22#)
                                                 (COND
                                                   (|testp|
                                                    (LETT |leadcomp|
                                                     |leadcomp1| . #22#)))
                                                 (LETT |int|
                                                  |lval| . #22#)
                                                 (LETT |leadtest|
                                                  'NIL . #22#)
                                                 (EXIT
                                                  (LETT |nfatt|
                                                   |nf| . #22#))))
                                               ((< |nf| |nfatt|)
                                                (SEQ
                                                 (COND
                                                   (|testp|
                                                    (LETT |leadtest|
                                                     (COND
                                                       ((SPADCALL
                                                         (SPADCALL
                                                          |lffc| |clc|
                                                          (QREFELT $
                                                           72))
                                                         (LENGTH
                                                          |plist|)
                                                         |leadcomp|
                                                         (QREFELT $
                                                          110))
                                                        'NIL)
                                                       ('T 'T)) . #22#))
                                                   ('T
                                                    (LETT |leadtest|
                                                     'NIL . #22#)))
                                                 (COND
                                                   ((NULL |leadtest|)
                                                    (SEQ
                                                     (LETT |unifact|
                                                      (PROGN
                                                        (LETT #20#
                                                         NIL . #22#)
                                                        (SEQ
                                                         (LETT |uf|
                                                          NIL . #22#)
                                                         (LETT #21#
                                                          |lunivf| . #22#)
                                                         G190
                                                         (COND
                                                           ((OR
                                                             (ATOM
                                                              #21#)
                                                             (PROGN
                                                               (LETT
                                                                |uf|
                                                                (CAR
                                                                 #21#) . #22#)
                                                               NIL))
                                                            #23#))
                                                         (SEQ
                                                          (EXIT
                                                           (LETT #20#
                                                            (CONS
                                                             (QCAR
                                                              |uf|)
                                                             #20#) . #22#)))
                                                         (LETT #21#
                                                          (CDR #21#) . #22#)
                                                         #24# G191
                                                         (EXIT
                                                          (NREVERSE0
                                                           #20#)))) . #22#)
                                                     (LETT |lffc|
                                                      |lffc1| . #22#)
                                                     (COND
                                                       (|testp|
                                                        (LETT
                                                         |leadcomp|
                                                         |leadcomp1| . #22#)))
                                                     (EXIT
                                                      (LETT |int|
                                                       |lval| . #22#)))))
                                                 (EXIT
                                                  (LETT |nfatt|
                                                   |nf| . #22#)))))))))))
                                      NIL #24# G191 (EXIT NIL)))
                           #17# (EXIT #17#))
                      (EXIT (CONS 0
                                  (VECTOR (CONS |int| |ltry|) |unifact|
                                          |lffc| |leadcomp|)))))
           #0# (EXIT #0#))))) 

(DEFUN |INNMFACT;simplify| (|m| |lvar| |lmdeg| |ufactor| $)
  (PROG (|x| #0=#:G2049 |i| |pol1| |factorlist| #1=#:G2044 |flead|)
    (RETURN
      (SEQ (LETT |factorlist| NIL . #2=(|INNMFACT;simplify|))
           (LETT |pol1| (|spadConstant| $ 51) . #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 $ 114))
                               (QREFELT $ 115)) . #2#)
                     (EXIT (COND
                             ((EQL |i| 0) "next value")
                             ('T
                              (SEQ (LETT |pol1|
                                    (SPADCALL |pol1|
                                     (SPADCALL (|spadConstant| $ 51)
                                      |x| |i| (QREFELT $ 116))
                                     (QREFELT $ 117)) . #2#)
                                   (EXIT
                                    (LETT |factorlist|
                                     (CONS
                                      (CONS
                                       (SPADCALL |x| (QREFELT $ 118))
                                       |i|)
                                      |factorlist|) . #2#)))))))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (LETT |m|
                 (PROG2 (LETT #1#
                              (SPADCALL |m| |pol1| (QREFELT $ 119)) . #2#)
                        (QCDR #1#)
                   (|check-union| (QEQCAR #1# 0) (QREFELT $ 9) #1#)) . #2#)
           (EXIT (COND
                   ((SPADCALL |m| (QREFELT $ 69))
                    (CONS (SPADCALL |m| (QREFELT $ 103)) |factorlist|))
                   ('T
                    (SEQ (LETT |flead|
                               (|INNMFACT;mFactor| |m| |ufactor| $) . #2#)
                         (PROGN
                           (RPLACD |flead|
                                   (APPEND |factorlist| (QCDR |flead|)))
                           (QCDR |flead|))
                         (EXIT |flead|))))))))) 

(DEFUN |INNMFACT;intfact|
       (|um| |lvar| |ldeg| |tleadpol| |ltry| |ufactor| $)
  (PROG (|polcase| #0=#:G2240 #1=#:G2241 |leadpol| |check| #2=#:G1946
            |vfchoo| |nfact| |lval| |leadval| |distf| #3=#:G2239 |dist|
            |lpol| |dd| #4=#:G2242 |unif| #5=#:G2243 |unifact|
            #6=#:G2227 |umd| |ffin| #7=#:G2244 |ff| #8=#:G2245
            |factfin|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |polcase|
                            (COND
                              ((NULL (QCDR |tleadpol|)) 'NIL)
                              ('T 'T))
                            . #9=(|INNMFACT;intfact|))
                      (LETT |vfchoo|
                            (COND
                              (|polcase|
                                  (SEQ (LETT |leadpol|
                                        (PROGN
                                          (LETT #0# NIL . #9#)
                                          (SEQ (LETT |ff| NIL . #9#)
                                           (LETT #1#
                                            (QCDR |tleadpol|) . #9#)
                                           G190
                                           (COND
                                             ((OR (ATOM #1#)
                                               (PROGN
                                                 (LETT |ff|
                                                  (CAR #1#) . #9#)
                                                 NIL))
                                              #10=(GO G191)))
                                           (SEQ
                                            (EXIT
                                             (LETT #0#
                                              (CONS (QCAR |ff|) #0#) . #9#)))
                                           (LETT #1# (CDR #1#) . #9#)
                                           #11=(GO G190) G191
                                           (EXIT (NREVERSE0 #0#)))) . #9#)
                                       (LETT |check|
                                        (|INNMFACT;intChoose| |um|
                                         |lvar| (QCAR |tleadpol|)
                                         |leadpol| |ltry| |ufactor| $) . #9#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |check| 1)
                                           (PROGN
                                             (LETT #3#
                                              (|INNMFACT;monicMfpol|
                                               |um| |lvar| |ldeg|
                                               |ufactor| $) . #9#)
                                             (GO #3#)))
                                          (#12='T (QCDR |check|))))))
                              (#12#
                               (PROG2 (LETT #2#
                                       (|INNMFACT;intChoose| |um|
                                        |lvar| (|spadConstant| $ 50)
                                        NIL NIL |ufactor| $) . #9#)
                                      (QCDR #2#)
                                 (|check-union| (QEQCAR #2# 0)
                                     (|Record|
                                      (|:| |inval|
                                       (|List| (|List| (QREFELT $ 8))))
                                      (|:| |unvfact|
                                       (|List|
                                        (|SparseUnivariatePolynomial|
                                         (QREFELT $ 8))))
                                      (|:| |lu| (QREFELT $ 8))
                                      (|:| |complead|
                                       (|List| (QREFELT $ 8))))
                                     #2#)))) . #9#)
                      (LETT |unifact| (QVELT |vfchoo| 1) . #9#)
                      (LETT |nfact| (LENGTH |unifact|) . #9#)
                      (EXIT (COND
                              ((EQL |nfact| 1) (LIST |um|))
                              (#12#
                               (SEQ (LETT |ltry|
                                     (QVELT |vfchoo| 0) . #9#)
                                    (LETT |lval|
                                     (|SPADfirst| |ltry|) . #9#)
                                    (LETT |dd|
                                     (QVELT |vfchoo| 2) . #9#)
                                    (LETT |leadval| NIL . #9#)
                                    (LETT |lpol| NIL . #9#)
                                    (COND
                                      (|polcase|
                                       (SEQ
                                        (LETT |leadval|
                                         (QVELT |vfchoo| 3) . #9#)
                                        (LETT |distf|
                                         (SPADCALL (QVELT |vfchoo| 2)
                                          |unifact| |tleadpol|
                                          |leadval| |lvar| |lval|
                                          (QREFELT $ 125)) . #9#)
                                        (EXIT
                                         (COND
                                           ((QEQCAR |distf| 1)
                                            (PROGN
                                              (LETT #3#
                                               (|INNMFACT;intfact| |um|
                                                |lvar| |ldeg|
                                                |tleadpol| |ltry|
                                                |ufactor| $) . #9#)
                                              (GO #3#)))
                                           (#12#
                                            (SEQ
                                             (LETT |dist|
                                              (QCDR |distf|) . #9#)
                                             (LETT |lpol|
                                              (QVELT |dist| 0) . #9#)
                                             (LETT |dd|
                                              (QVELT |dist| 1) . #9#)
                                             (EXIT
                                              (LETT |unifact|
                                               (QVELT |dist| 2) . #9#)))))))))
                                    (COND
                                      ((SPADCALL |dd|
                                        (|spadConstant| $ 50)
                                        (QREFELT $ 94))
                                       (LETT |umd| |um| . #9#))
                                      (#12#
                                       (SEQ
                                        (LETT |unifact|
                                         (PROGN
                                           (LETT #4# NIL . #9#)
                                           (SEQ (LETT |unif| NIL . #9#)
                                            (LETT #5# |unifact| . #9#)
                                            G190
                                            (COND
                                              ((OR (ATOM #5#)
                                                (PROGN
                                                  (LETT |unif|
                                                   (CAR #5#) . #9#)
                                                  NIL))
                                               #10#))
                                            (SEQ
                                             (EXIT
                                              (LETT #4#
                                               (CONS
                                                (SPADCALL |dd| |unif|
                                                 (QREFELT $ 126))
                                                #4#) . #9#)))
                                            (LETT #5# (CDR #5#) . #9#)
                                            #11# G191
                                            (EXIT (NREVERSE0 #4#)))) . #9#)
                                        (EXIT
                                         (LETT |umd|
                                          (SPADCALL
                                           (SPADCALL
                                            (QVELT
                                             (SPADCALL |dd|
                                              (QREFELT $ 127))
                                             0)
                                            (SPADCALL
                                             (SPADCALL |dd|
                                              (PROG1
                                               (LETT #6#
                                                (- |nfact| 1) . #9#)
                                                (|check-subtype|
                                                 (>= #6# 0)
                                                 '(|NonNegativeInteger|)
                                                 #6#))
                                              (QREFELT $ 71))
                                             (QREFELT $ 38))
                                            (QREFELT $ 66))
                                           |um| (QREFELT $ 128)) . #9#)))))
                                    (LETT |ffin|
                                     (SPADCALL |umd| |lvar| |unifact|
                                      |lval| |lpol| |ldeg|
                                      (QREFELT $ 16) (QREFELT $ 131)) . #9#)
                                    (EXIT
                                     (COND
                                       ((QEQCAR |ffin| 1)
                                        (|INNMFACT;intfact| |um| |lvar|
                                         |ldeg| |tleadpol| |ltry|
                                         |ufactor| $))
                                       (#12#
                                        (SEQ
                                         (LETT |factfin|
                                          (QCDR |ffin|) . #9#)
                                         (COND
                                           ((NULL
                                             (SPADCALL |dd|
                                              (|spadConstant| $ 50)
                                              (QREFELT $ 94)))
                                            (LETT |factfin|
                                             (PROGN
                                               (LETT #7# NIL . #9#)
                                               (SEQ
                                                (LETT |ff| NIL . #9#)
                                                (LETT #8#
                                                 |factfin| . #9#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #8#)
                                                    (PROGN
                                                      (LETT |ff|
                                                       (CAR #8#) . #9#)
                                                      NIL))
                                                   #10#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #7#
                                                   (CONS
                                                    (SPADCALL |ff|
                                                     (QREFELT $ 132))
                                                    #7#) . #9#)))
                                                (LETT #8#
                                                 (CDR #8#) . #9#)
                                                #11# G191
                                                (EXIT (NREVERSE0 #7#)))) . #9#)))
                                         (EXIT |factfin|)))))))))))
           #3# (EXIT #3#))))) 

(DEFUN |INNMFACT;mfconst| (|um| |lvar| |ldeg| |ufactor| $)
  (PROG (|factfin| |lum| #0=#:G2252 |uf| #1=#:G2253)
    (RETURN
      (SEQ (LETT |factfin| NIL . #2=(|INNMFACT;mfconst|))
           (EXIT (COND
                   ((NULL |lvar|)
                    (SEQ (LETT |lum|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL (ELT $ 27) |um|
                                     (QREFELT $ 31))
                                    |ufactor|)
                                   (QREFELT $ 37)) . #2#)
                         (EXIT (PROGN
                                 (LETT #0# NIL . #2#)
                                 (SEQ (LETT |uf| NIL . #2#)
                                      (LETT #1# |lum| . #2#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |uf| (CAR #1#) . #2#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS
                                          (SPADCALL (ELT $ 38)
                                           (QCAR |uf|) (QREFELT $ 41))
                                          #0#) . #2#)))
                                      (LETT #1# (CDR #1#) . #2#)
                                      (GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))))))
                   ('T
                    (|INNMFACT;intfact| |um| |lvar| |ldeg|
                        (CONS (|spadConstant| $ 43) NIL) NIL |ufactor|
                        $)))))))) 

(DEFUN |INNMFACT;monicize| (|um| |c| $)
  (PROG (#0=#:G2254 |i| |lc| |n| #1=#:G2257 |prod| |ans|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |um| (QREFELT $ 55))
                 . #2=(|INNMFACT;monicize|))
           (LETT |ans|
                 (SPADCALL (|spadConstant| $ 51) |n| (QREFELT $ 52)) . #2#)
           (LETT |n|
                 (PROG1 (LETT #0# (- |n| 1) . #2#)
                   (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                       #0#)) . #2#)
           (LETT |prod| (|spadConstant| $ 51) . #2#)
           (SEQ G190
                (COND
                  ((NULL (SEQ (LETT |um|
                                    (SPADCALL |um| (QREFELT $ 83)) . #2#)
                              (EXIT (COND
                                      ((SPADCALL |um|
                                        (|spadConstant| $ 47)
                                        (QREFELT $ 80))
                                       'NIL)
                                      ('T 'T)))))
                   (GO G191)))
                (SEQ (LETT |i| (SPADCALL |um| (QREFELT $ 55)) . #2#)
                     (LETT |lc| (SPADCALL |um| (QREFELT $ 68)) . #2#)
                     (LETT |prod|
                           (SPADCALL |prod|
                               (SPADCALL |c|
                                   (PROG1
                                    (LETT #1#
                                     (- |n| (LETT |n| |i| . #2#)) . #2#)
                                     (|check-subtype| (>= #1# 0)
                                      '(|NonNegativeInteger|) #1#))
                                   (QREFELT $ 133))
                               (QREFELT $ 117)) . #2#)
                     (EXIT (LETT |ans|
                                 (SPADCALL |ans|
                                     (SPADCALL
                                      (SPADCALL |prod| |lc|
                                       (QREFELT $ 117))
                                      |i| (QREFELT $ 52))
                                     (QREFELT $ 134)) . #2#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT |ans|))))) 

(DEFUN |INNMFACT;unmonicize| (|m| |c| $)
  (SPADCALL (SPADCALL |m| (SPADCALL |c| 1 (QREFELT $ 52))
                (QREFELT $ 135))
            (QREFELT $ 132))) 

(DEFUN |INNMFACT;monicMfpol| (|um| |lvar| |ldeg| |ufactor| $)
  (PROG (|l| |monpol| |nldeg|)
    (RETURN
      (SEQ (LETT |l| (SPADCALL |um| (QREFELT $ 68))
                 . #0=(|INNMFACT;monicMfpol|))
           (LETT |monpol| (|INNMFACT;monicize| |um| |l| $) . #0#)
           (LETT |nldeg|
                 (SPADCALL |monpol| |lvar| (QREFELT $ 136)) . #0#)
           (EXIT (SPADCALL
                     (CONS #'|INNMFACT;monicMfpol!0| (VECTOR $ |l|))
                     (|INNMFACT;mfconst| |monpol| |lvar| |nldeg|
                         |ufactor| $)
                     (QREFELT $ 139))))))) 

(DEFUN |INNMFACT;monicMfpol!0| (|#1| $$)
  (|INNMFACT;unmonicize| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |INNMFACT;mfpol| (|um| |lvar| |ldeg| |ufactor| $)
  (PROG (|tleadpol|)
    (RETURN
      (SEQ (COND
             ((|HasCategory| (QREFELT $ 8) '(|Field|))
              (|INNMFACT;monicMfpol| |um| |lvar| |ldeg| |ufactor| $))
             ('T
              (SEQ (LETT |tleadpol|
                         (|INNMFACT;mFactor|
                             (SPADCALL |um| (QREFELT $ 68)) |ufactor|
                             $)
                         |INNMFACT;mfpol|)
                   (EXIT (|INNMFACT;intfact| |um| |lvar| |ldeg|
                             |tleadpol| NIL |ufactor| $))))))))) 

(DEFUN |INNMFACT;mFactor| (|m| |ufactor| $)
  (PROG (|lmdeg| |n| #0=#:G2305 #1=#:G2271 #2=#:G2269 #3=#:G2270
                 |sqfacs| |flead| |sqqfact| |fact| #4=#:G2306 |ffexp|
                 |lcont| #5=#:G2277 #6=#:G2307 |varch| |x| |lvar| |pc|
                 #7=#:G2284 |ffactor| |lcterm| #8=#:G2308 |ldeg| |um|
                 |lf| #9=#:G2309 |lfp| #10=#:G2310 |auxfl| |factorlist|
                 |f| #11=#:G2311 #12=#:G2297 #13=#:G2295 #14=#:G2293
                 #15=#:G2294 |lcfacs| #16=#:G2299)
    (RETURN
      (SEQ (COND
             ((SPADCALL |m| (QREFELT $ 69))
              (CONS (SPADCALL |m| (QREFELT $ 103)) NIL))
             ('T
              (SEQ (LETT |lvar| (SPADCALL |m| (QREFELT $ 25))
                         . #17=(|INNMFACT;mFactor|))
                   (LETT |flead|
                         (CONS (|spadConstant| $ 43) NIL) . #17#)
                   (LETT |factorlist| NIL . #17#)
                   (LETT |lmdeg|
                         (SPADCALL |m| |lvar| (QREFELT $ 140)) . #17#)
                   (EXIT (COND
                           ((PROGN
                              (LETT #3# NIL . #17#)
                              (SEQ (LETT |n| NIL . #17#)
                                   (LETT #0# |lmdeg| . #17#) G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |n| (CAR #0#) . #17#)
                                         NIL))
                                      #18=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #1# (< 0 |n|) . #17#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (COND (#2# 'T) ('T #1#)) . #17#))
                                         ('T
                                          (PROGN
                                            (LETT #2# #1# . #17#)
                                            (LETT #3# 'T . #17#)))))))
                                   (LETT #0# (CDR #0#) . #17#)
                                   #19=(GO G190) G191 (EXIT NIL))
                              (COND (#3# #2#) ('T 'NIL)))
                            (|INNMFACT;simplify| |m| |lvar| |lmdeg|
                                |ufactor| $))
                           ('T
                            (SEQ (LETT |sqfacs|
                                       (SPADCALL |m| (QREFELT $ 142)) . #17#)
                                 (LETT |lcont|
                                       (SPADCALL |sqfacs|
                                        (QREFELT $ 144)) . #17#)
                                 (COND
                                   ((SPADCALL |lcont| (QREFELT $ 69))
                                    (PROGN
                                      (RPLACA |flead|
                                       (SPADCALL |lcont|
                                        (QREFELT $ 103)))
                                      (QCAR |flead|)))
                                   ('T
                                    (LETT |flead|
                                     (|INNMFACT;mFactor| |lcont|
                                      |ufactor| $) . #17#)))
                                 (LETT |factorlist|
                                       (QCDR |flead|) . #17#)
                                 (LETT |sqqfact|
                                       (SPADCALL |sqfacs|
                                        (QREFELT $ 147)) . #17#)
                                 (SEQ (LETT |fact| NIL . #17#)
                                      (LETT #4# |sqqfact| . #17#) G190
                                      (COND
                                        ((OR (ATOM #4#)
                                          (PROGN
                                            (LETT |fact|
                                             (CAR #4#) . #17#)
                                            NIL))
                                         #18#))
                                      (SEQ
                                       (LETT |ffactor|
                                        (QCAR |fact|) . #17#)
                                       (LETT |ffexp|
                                        (QCDR |fact|) . #17#)
                                       (LETT |lvar|
                                        (SPADCALL |ffactor|
                                         (QREFELT $ 25)) . #17#)
                                       (LETT |x|
                                        (|SPADfirst| |lvar|) . #17#)
                                       (LETT |ldeg|
                                        (SPADCALL |ffactor| |lvar|
                                         (QREFELT $ 148)) . #17#)
                                       (EXIT
                                        (COND
                                          ((SPADCALL 1 |ldeg|
                                            (QREFELT $ 153))
                                           (SEQ
                                            (LETT |x|
                                             (SPADCALL |lvar|
                                              (SPADCALL 1 |ldeg|
                                               (QREFELT $ 88))
                                              (QREFELT $ 89)) . #17#)
                                            (LETT |lcont|
                                             (SPADCALL
                                              (SPADCALL
                                               (SPADCALL |ffactor| |x|
                                                (QREFELT $ 86))
                                               (QREFELT $ 23))
                                              (QREFELT $ 154)) . #17#)
                                            (LETT |ffactor|
                                             (PROG2
                                              (LETT #5#
                                               (SPADCALL |ffactor|
                                                |lcont|
                                                (QREFELT $ 119)) . #17#)
                                              (QCDR #5#)
                                               (|check-union|
                                                (QEQCAR #5# 0)
                                                (QREFELT $ 9) #5#)) . #17#)
                                            (LETT |factorlist|
                                             (CONS
                                              (CONS |ffactor| |ffexp|)
                                              |factorlist|) . #17#)
                                            (EXIT
                                             (SEQ
                                              (LETT |lcterm|
                                               NIL . #17#)
                                              (LETT #6#
                                               (QCDR
                                                (|INNMFACT;mFactor|
                                                 |lcont| |ufactor| $)) . #17#)
                                              G190
                                              (COND
                                                ((OR (ATOM #6#)
                                                  (PROGN
                                                    (LETT |lcterm|
                                                     (CAR #6#) . #17#)
                                                    NIL))
                                                 #18#))
                                              (SEQ
                                               (EXIT
                                                (LETT |factorlist|
                                                 (CONS
                                                  (CONS (QCAR |lcterm|)
                                                   (* (QCDR |lcterm|)
                                                    |ffexp|))
                                                  |factorlist|) . #17#)))
                                              (LETT #6#
                                               (CDR #6#) . #17#)
                                              #19# G191 (EXIT NIL)))))
                                          ('T
                                           (SEQ
                                            (LETT |varch|
                                             (|INNMFACT;varChoose|
                                              |ffactor| |lvar| |ldeg|
                                              $) . #17#)
                                            (LETT |um|
                                             (QVELT |varch| 0) . #17#)
                                            (LETT |x|
                                             (|SPADfirst| |lvar|) . #17#)
                                            (LETT |ldeg|
                                             (CDR |ldeg|) . #17#)
                                            (LETT |lvar|
                                             (CDR |lvar|) . #17#)
                                            (COND
                                              ((NULL
                                                (SPADCALL
                                                 (|SPADfirst|
                                                  (QVELT |varch| 1))
                                                 |x| (QREFELT $ 155)))
                                               (SEQ
                                                (LETT |lvar|
                                                 (QVELT |varch| 1) . #17#)
                                                (LETT |x|
                                                 (|SPADfirst| |lvar|) . #17#)
                                                (EXIT
                                                 (LETT |lvar|
                                                  (CDR |lvar|) . #17#)))))
                                            (LETT |pc|
                                             (SPADCALL
                                              (SPADCALL |um|
                                               (QREFELT $ 23))
                                              (QREFELT $ 154)) . #17#)
                                            (COND
                                              ((NULL
                                                (SPADCALL |pc|
                                                 (|spadConstant| $ 51)
                                                 (QREFELT $ 156)))
                                               (SEQ
                                                (LETT |um|
                                                 (PROG2
                                                  (LETT #7#
                                                   (SPADCALL |um| |pc|
                                                    (QREFELT $ 157)) . #17#)
                                                  (QCDR #7#)
                                                   (|check-union|
                                                    (QEQCAR #7# 0)
                                                    (|SparseUnivariatePolynomial|
                                                     (QREFELT $ 9))
                                                    #7#)) . #17#)
                                                (LETT |ffactor|
                                                 (SPADCALL |um| |x|
                                                  (QREFELT $ 158)) . #17#)
                                                (EXIT
                                                 (SEQ
                                                  (LETT |lcterm|
                                                   NIL . #17#)
                                                  (LETT #8#
                                                   (QCDR
                                                    (|INNMFACT;mFactor|
                                                     |pc| |ufactor| $)) . #17#)
                                                  G190
                                                  (COND
                                                    ((OR (ATOM #8#)
                                                      (PROGN
                                                        (LETT |lcterm|
                                                         (CAR #8#) . #17#)
                                                        NIL))
                                                     #18#))
                                                  (SEQ
                                                   (EXIT
                                                    (LETT |factorlist|
                                                     (CONS
                                                      (CONS
                                                       (QCAR |lcterm|)
                                                       (*
                                                        (QCDR |lcterm|)
                                                        |ffexp|))
                                                      |factorlist|) . #17#)))
                                                  (LETT #8#
                                                   (CDR #8#) . #17#)
                                                  #19# G191 (EXIT NIL))))))
                                            (LETT |ldeg|
                                             (SPADCALL |ffactor| |lvar|
                                              (QREFELT $ 148)) . #17#)
                                            (LETT |um|
                                             (SPADCALL |um|
                                              (QREFELT $ 159)) . #17#)
                                            (COND
                                              ((SPADCALL
                                                (SPADCALL |um|
                                                 (QREFELT $ 68))
                                                (QREFELT $ 69))
                                               (LETT |lf|
                                                (|INNMFACT;mfconst|
                                                 |um| |lvar| |ldeg|
                                                 |ufactor| $) . #17#))
                                              ('T
                                               (LETT |lf|
                                                (|INNMFACT;mfpol| |um|
                                                 |lvar| |ldeg|
                                                 |ufactor| $) . #17#)))
                                            (LETT |auxfl|
                                             (PROGN
                                               (LETT #9# NIL . #17#)
                                               (SEQ
                                                (LETT |lfp| NIL . #17#)
                                                (LETT #10# |lf| . #17#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #10#)
                                                    (PROGN
                                                      (LETT |lfp|
                                                       (CAR #10#) . #17#)
                                                      NIL))
                                                   #18#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #9#
                                                   (CONS
                                                    (CONS
                                                     (SPADCALL
                                                      (SPADCALL |lfp|
                                                       |x|
                                                       (QREFELT $ 158))
                                                      (QREFELT $ 160))
                                                     |ffexp|)
                                                    #9#) . #17#)))
                                                (LETT #10#
                                                 (CDR #10#) . #17#)
                                                #19# G191
                                                (EXIT (NREVERSE0 #9#)))) . #17#)
                                            (EXIT
                                             (LETT |factorlist|
                                              (APPEND |factorlist|
                                               |auxfl|) . #17#)))))))
                                      (LETT #4# (CDR #4#) . #17#) #19#
                                      G191 (EXIT NIL))
                                 (LETT |lcfacs|
                                       (PROGN
                                         (LETT #15# NIL . #17#)
                                         (SEQ (LETT |f| NIL . #17#)
                                          (LETT #11#
                                           |factorlist| . #17#)
                                          G190
                                          (COND
                                            ((OR (ATOM #11#)
                                              (PROGN
                                                (LETT |f|
                                                 (CAR #11#) . #17#)
                                                NIL))
                                             #18#))
                                          (SEQ
                                           (EXIT
                                            (PROGN
                                              (LETT #13#
                                               (SPADCALL
                                                (SPADCALL (QCAR |f|)
                                                 (QREFELT $ 70))
                                                (PROG1
                                                 (LETT #12#
                                                  (QCDR |f|) . #17#)
                                                  (|check-subtype|
                                                   (>= #12# 0)
                                                   '(|NonNegativeInteger|)
                                                   #12#))
                                                (QREFELT $ 71)) . #17#)
                                              (COND
                                                (#15#
                                                 (LETT #14#
                                                  (SPADCALL #14# #13#
                                                   (QREFELT $ 72)) . #17#))
                                                ('T
                                                 (PROGN
                                                   (LETT #14#
                                                    #13# . #17#)
                                                   (LETT #15#
                                                    'T . #17#)))))))
                                          (LETT #11# (CDR #11#) . #17#)
                                          #19# G191 (EXIT NIL))
                                         (COND
                                           (#15# #14#)
                                           ('T (|spadConstant| $ 50)))) . #17#)
                                 (EXIT (CONS
                                        (PROG2
                                         (LETT #16#
                                          (SPADCALL
                                           (SPADCALL |m|
                                            (QREFELT $ 70))
                                           |lcfacs| (QREFELT $ 73)) . #17#)
                                         (QCDR #16#)
                                          (|check-union|
                                           (QEQCAR #16# 0)
                                           (QREFELT $ 8) #16#))
                                        |factorlist|))))))))))))) 

(DEFUN |INNMFACT;factor;PMF;16| (|m| |ufactor| $)
  (PROG (|flist| |u| #0=#:G2318 #1=#:G2315 #2=#:G2313 #3=#:G2314)
    (RETURN
      (SEQ (LETT |flist| (|INNMFACT;mFactor| |m| |ufactor| $)
                 . #4=(|INNMFACT;factor;PMF;16|))
           (EXIT (SPADCALL (SPADCALL (QCAR |flist|) (QREFELT $ 38))
                     (PROGN
                       (LETT #3# NIL . #4#)
                       (SEQ (LETT |u| NIL . #4#)
                            (LETT #0# (QCDR |flist|) . #4#) G190
                            (COND
                              ((OR (ATOM #0#)
                                   (PROGN
                                     (LETT |u| (CAR #0#) . #4#)
                                     NIL))
                               (GO G191)))
                            (SEQ (EXIT (PROGN
                                         (LETT #1#
                                          (SPADCALL (QCAR |u|)
                                           (QCDR |u|) (QREFELT $ 161)) . #4#)
                                         (COND
                                           (#3#
                                            (LETT #2#
                                             (SPADCALL #2# #1#
                                              (QREFELT $ 162)) . #4#))
                                           ('T
                                            (PROGN
                                              (LETT #2# #1# . #4#)
                                              (LETT #3# 'T . #4#)))))))
                            (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                            (EXIT NIL))
                       (COND (#3# #2#) ('T (|spadConstant| $ 152))))
                     (QREFELT $ 163))))))) 

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

(DEFUN |InnerMultFact;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|InnerMultFact|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$| (LIST '|InnerMultFact| DV$1 DV$2 DV$3 DV$4) . #0#)
        (LETT $ (GETREFV 165) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|InnerMultFact|
            (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 $ 16
            (SPADCALL (SPADCALL (EXPT 2 26) (QREFELT $ 14))
                (QREFELT $ 15)))
        $)))) 

(MAKEPROP '|InnerMultFact| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|PositiveInteger|) (0 . **)
             (|Integer|) (|IntegerPrimesPackage| 12) (6 . |prevPrime|)
             (11 . |coerce|) '|pmod| (|SparseUnivariatePolynomial| 9)
             (16 . |coerce|) (|Boolean|) (21 . |ground?|)
             (26 . |ground|) (|List| 9) (31 . |coefficients|)
             (|List| 6) (36 . |variables|) (41 . |setUnion|)
             (47 . |ground|) (|SparseUnivariatePolynomial| 8)
             (|Mapping| 8 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 17 8 28)
             (52 . |map|) (|Factored| 28) (58 . |unit|)
             (63 . |retract|)
             (|Record| (|:| |factor| 28) (|:| |exponent| 12))
             (|List| 35) (68 . |factors|) (73 . |coerce|)
             (|Mapping| 9 8)
             (|UnivariatePolynomialCategoryFunctions2| 8 28 9 17)
             (78 . |map|) (84 . |Zero|) (88 . |Zero|)
             (|NonNegativeInteger|) (92 . |minimumDegree|)
             (97 . |Zero|) (101 . |Zero|) (105 . |Zero|) (109 . |Zero|)
             (113 . |One|) (117 . |One|) (121 . |monomial|)
             (|Union| $ '"failed") (127 . |exquo|) (133 . |degree|)
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (138 . |unitNormal|) (|Factored| 17)
             (|MultivariateSquareFree| 7 6 8 9) (143 . |squareFree|)
             (148 . |unit|) (153 . *)
             (|Record| (|:| |factor| 17) (|:| |exponent| 12))
             (|List| 63) (159 . |factors|) (164 . *) (170 . |degree|)
             (176 . |leadingCoefficient|) (181 . |ground?|)
             (186 . |leadingCoefficient|) (191 . **) (197 . *)
             (203 . |exquo|) (209 . |primeFactor|) (215 . *)
             (221 . |One|) (225 . *) (|Mapping| 32 28)
             |INNMFACT;factor;SupMF;3| (231 . =) (237 . =)
             (243 . |degree|) (248 . |reductum|) (253 . |reductum|)
             (|SparseUnivariatePolynomial| $) (258 . |univariate|)
             (|List| 44) (264 . |position|) (270 . |elt|)
             (276 . |delete|) (282 . |delete|)
             (288 . |numberOfMonomials|) (293 . |coefficient|)
             (299 . =) (305 . |euclideanSize|)
             (|FactoringUtilities| 7 6 8 9) (310 . |ran|) (|List| 8)
             (|List| 98) (315 . |member?|) (321 . *) (327 . |eval|)
             (334 . |retract|) (339 . |unit?|) (344 . |completeEval|)
             (351 . |minimumDegree|) (356 . |content|) (361 . |exquo|)
             (|LeadingCoefDetermination| 6 7 8 9) (367 . |polCase|)
             (374 . |differentiate|) (|List| $) (379 . |gcd|)
             (384 . |position|) (390 . |elt|) (396 . |monomial|)
             (403 . *) (409 . |coerce|) (414 . |exquo|)
             (|Record| (|:| |polfac| 22) (|:| |correct| 8)
                 (|:| |corrfact| 122))
             (|Union| 120 '"failed") (|List| 28)
             (|Record| (|:| |irr| 9) (|:| |pow| 12))
             (|Record| (|:| |contp| 8) (|:| |factors| (|List| 123)))
             (420 . |distFact|) (430 . *) (436 . |unitNormal|)
             (441 . *) (|Union| 138 '"failed")
             (|MultivariateLifting| 7 6 8 9) (447 . |lifting|)
             (458 . |primitivePart|) (463 . **) (469 . +) (475 . |elt|)
             (481 . |degree|) (|Mapping| 17 17) (|List| 17)
             (487 . |map|) (493 . |minimumDegree|) (|Factored| $)
             (499 . |squareFree|) (|Factored| 9) (504 . |unit|)
             (|Record| (|:| |factor| 9) (|:| |exponent| 12))
             (|List| 145) (509 . |factors|) (514 . |degree|)
             (520 . |One|) (524 . |One|) (528 . |One|) (532 . |One|)
             (536 . |member?|) (542 . |gcd|) (547 . =) (553 . =)
             (559 . |exquo|) (565 . |multivariate|)
             (571 . |unitCanonical|) (576 . |unitCanonical|)
             (581 . |primeFactor|) (587 . *) (593 . *)
             |INNMFACT;factor;PMF;16|)
          '#(|factor| 599) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 164
                                '(2 10 0 0 10 11 1 13 12 12 14 1 8 0 12
                                  15 1 17 0 9 18 1 17 19 0 20 1 17 9 0
                                  21 1 17 22 0 23 1 9 24 0 25 2 24 0 0
                                  0 26 1 9 8 0 27 2 30 28 29 17 31 1 32
                                  28 0 33 1 28 8 0 34 1 32 36 0 37 1 9
                                  0 8 38 2 40 17 39 28 41 0 7 0 42 0 8
                                  0 43 1 17 44 0 45 0 9 0 46 0 17 0 47
                                  0 28 0 48 0 32 0 49 0 8 0 50 0 9 0 51
                                  2 17 0 9 44 52 2 17 53 0 0 54 1 17 44
                                  0 55 1 17 56 0 57 1 59 58 17 60 1 58
                                  17 0 61 2 17 0 0 0 62 1 58 64 0 65 2
                                  9 0 8 0 66 2 9 44 0 6 67 1 17 9 0 68
                                  1 9 19 0 69 1 9 8 0 70 2 8 0 0 44 71
                                  2 8 0 0 0 72 2 8 53 0 0 73 2 58 0 17
                                  12 74 2 58 0 0 0 75 0 58 0 76 2 58 0
                                  17 0 77 2 17 19 0 0 80 2 28 19 0 0 81
                                  1 28 44 0 82 1 17 0 0 83 1 28 0 0 84
                                  2 9 85 0 6 86 2 87 12 44 0 88 2 24 6
                                  0 12 89 2 87 0 0 12 90 2 24 0 0 12 91
                                  1 28 44 0 92 2 28 8 0 44 93 2 8 19 0
                                  0 94 1 8 44 0 95 1 96 8 12 97 2 99 19
                                  98 0 100 2 44 0 10 0 101 3 9 0 0 24
                                  98 102 1 9 8 0 103 1 8 19 0 104 3 96
                                  28 17 24 98 105 1 28 44 0 106 1 28 8
                                  0 107 2 28 53 0 8 108 3 109 19 8 44
                                  98 110 1 28 0 0 111 1 28 0 112 113 2
                                  24 12 6 0 114 2 87 44 0 12 115 3 9 0
                                  0 6 44 116 2 9 0 0 0 117 1 9 0 6 118
                                  2 9 53 0 0 119 6 109 121 8 122 124 98
                                  24 98 125 2 28 0 8 0 126 1 8 56 0 127
                                  2 17 0 9 0 128 7 130 129 17 24 122 98
                                  22 87 8 131 1 17 0 0 132 2 9 0 0 44
                                  133 2 17 0 0 0 134 2 17 0 0 0 135 2
                                  96 87 17 24 136 2 138 0 137 0 139 2 9
                                  87 0 24 140 1 9 141 0 142 1 143 9 0
                                  144 1 143 146 0 147 2 9 87 0 24 148 0
                                  17 0 149 0 28 0 150 0 32 0 151 0 143
                                  0 152 2 87 19 44 0 153 1 9 0 112 154
                                  2 6 19 0 0 155 2 9 19 0 0 156 2 17 53
                                  0 9 157 2 9 0 85 6 158 1 17 0 0 159 1
                                  9 0 0 160 2 143 0 9 12 161 2 143 0 0
                                  0 162 2 143 0 9 0 163 2 0 58 17 78 79
                                  2 0 143 9 78 164)))))
          '|lookupComplete|)) 
