
(/VERSIONCHECK 2) 

(DEFUN |PFBR;hensel| (|pp| |vv| |r| |factors| $)
  (PROG (#0=#:G1911 #1=#:G1845 #2=#:G1843 #3=#:G1844 |prime| |pn|
                    #4=#:G1815 #5=#:G1912 #6=#:G1875 #7=#:G1873
                    #8=#:G1874 |Ecart| |step| #9=#:G1913 |b|
                    #10=#:G1915 #11=#:G1914 |c| #12=#:G1917 |a|
                    #13=#:G1916 |pp1| #14=#:G1918 #15=#:G1892
                    #16=#:G1890 #17=#:G1891 |proddegree| |origFactors|
                    |foundFactors| #18=#:G1910 |u1| #19=#:G1919 |u|
                    #20=#:G1920 #21=#:G1902 #22=#:G1900 #23=#:G1901
                    #24=#:G1899 #25=#:G1897 #26=#:G1898 |totdegree|
                    |n|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |origFactors| |factors|
                            . #27=(|PFBR;hensel|))
                      (LETT |totdegree| 0 . #27#)
                      (LETT |proddegree|
                            (PROGN
                              (LETT #3# NIL . #27#)
                              (SEQ (LETT |u| NIL . #27#)
                                   (LETT #0#
                                    (SPADCALL |pp| (QREFELT $ 12)) . #27#)
                                   G190
                                   (COND
                                     ((OR (ATOM #0#)
                                       (PROGN
                                         (LETT |u| (CAR #0#) . #27#)
                                         NIL))
                                      #28=(GO G191)))
                                   (SEQ
                                    (EXIT
                                     (PROGN
                                       (LETT #1#
                                        (SPADCALL |u| |vv|
                                         (QREFELT $ 14)) . #27#)
                                       (COND
                                         (#3#
                                          (LETT #2#
                                           (MAX #2# #1#) . #27#))
                                         ('T
                                          (PROGN
                                            (LETT #2# #1# . #27#)
                                            (LETT #3# 'T . #27#)))))))
                                   (LETT #0# (CDR #0#) . #27#)
                                   #29=(GO G190) G191 (EXIT NIL))
                              (COND
                                (#3# #2#)
                                ('T (|IdentityError| '|max|)))) . #27#)
                      (LETT |n| 1 . #27#)
                      (LETT |prime|
                            (SPADCALL (SPADCALL |vv| (QREFELT $ 15))
                                (SPADCALL |r| (QREFELT $ 16))
                                (QREFELT $ 17)) . #27#)
                      (LETT |foundFactors| NIL . #27#)
                      (SEQ G190
                           (COND
                             ((NULL (COND
                                      ((< |proddegree| |totdegree|)
                                       'NIL)
                                      ('T 'T)))
                              #28#))
                           (SEQ (LETT |pn|
                                      (SPADCALL |prime| |n|
                                       (QREFELT $ 19)) . #27#)
                                (LETT |Ecart|
                                      (SPADCALL
                                       (SPADCALL |pp|
                                        (PROGN
                                          (LETT #8# NIL . #27#)
                                          (SEQ (LETT #4# NIL . #27#)
                                           (LETT #5# |factors| . #27#)
                                           G190
                                           (COND
                                             ((OR (ATOM #5#)
                                               (PROGN
                                                 (LETT #4#
                                                  (CAR #5#) . #27#)
                                                 NIL))
                                              #28#))
                                           (SEQ
                                            (EXIT
                                             (PROGN
                                               (LETT #6# #4# . #27#)
                                               (COND
                                                 (#8#
                                                  (LETT #7#
                                                   (SPADCALL #7# #6#
                                                    (QREFELT $ 20)) . #27#))
                                                 ('T
                                                  (PROGN
                                                    (LETT #7#
                                                     #6# . #27#)
                                                    (LETT #8#
                                                     'T . #27#)))))))
                                           (LETT #5# (CDR #5#) . #27#)
                                           #29# G191 (EXIT NIL))
                                          (COND
                                            (#8# #7#)
                                            ('T (|spadConstant| $ 21))))
                                        (QREFELT $ 22))
                                       |pn| (QREFELT $ 24)) . #27#)
                                (EXIT (COND
                                        ((QEQCAR |Ecart| 1)
                                         (|error|
                                          "failed lifting in hensel in PFBR"))
                                        ((SPADCALL (QCDR |Ecart|)
                                          (QREFELT $ 26))
                                         (PROGN
                                           (LETT #18#
                                            (CONS 0
                                             (LIST
                                              (APPEND |foundFactors|
                                               |factors|))) . #27#)
                                           (GO #18#)))
                                        ('T
                                         (SEQ
                                          (LETT |step|
                                           (SPADCALL |origFactors|
                                            (SPADCALL
                                             (CONS #'|PFBR;hensel!0|
                                              (VECTOR $ |r| |vv|))
                                             (QCDR |Ecart|)
                                             (QREFELT $ 29))
                                            (QREFELT $ 33)) . #27#)
                                          (EXIT
                                           (COND
                                             ((QEQCAR |step| 1)
                                              (PROGN
                                                (LETT #18#
                                                 (CONS 1 "failed") . #27#)
                                                (GO #18#)))
                                             ('T
                                              (SEQ
                                               (LETT |factors|
                                                (PROGN
                                                  (LETT #9# NIL . #27#)
                                                  (SEQ
                                                   (LETT |b|
                                                    NIL . #27#)
                                                   (LETT #10#
                                                    (QCDR |step|) . #27#)
                                                   (LETT |a|
                                                    NIL . #27#)
                                                   (LETT #11#
                                                    |factors| . #27#)
                                                   G190
                                                   (COND
                                                     ((OR (ATOM #11#)
                                                       (PROGN
                                                         (LETT |a|
                                                          (CAR #11#) . #27#)
                                                         NIL)
                                                       (ATOM #10#)
                                                       (PROGN
                                                         (LETT |b|
                                                          (CAR #10#) . #27#)
                                                         NIL))
                                                      #28#))
                                                   (SEQ
                                                    (EXIT
                                                     (LETT #9#
                                                      (CONS
                                                       (SPADCALL |a|
                                                        (SPADCALL |b|
                                                         |pn|
                                                         (QREFELT $ 34))
                                                        (QREFELT $ 35))
                                                       #9#) . #27#)))
                                                   (LETT #11#
                                                    (PROG1 (CDR #11#)
                                                      (LETT #10#
                                                       (CDR #10#) . #27#)) . #27#)
                                                   #29# G191
                                                   (EXIT
                                                    (NREVERSE0 #9#)))) . #27#)
                                               (SEQ
                                                (LETT |c| NIL . #27#)
                                                (LETT #12#
                                                 |origFactors| . #27#)
                                                (LETT |a| NIL . #27#)
                                                (LETT #13#
                                                 |factors| . #27#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #13#)
                                                    (PROGN
                                                      (LETT |a|
                                                       (CAR #13#) . #27#)
                                                      NIL)
                                                    (ATOM #12#)
                                                    (PROGN
                                                      (LETT |c|
                                                       (CAR #12#) . #27#)
                                                      NIL))
                                                   #28#))
                                                (SEQ
                                                 (LETT |pp1|
                                                  (SPADCALL |pp| |a|
                                                   (QREFELT $ 36)) . #27#)
                                                 (EXIT
                                                  (COND
                                                    ((QEQCAR |pp1| 1)
                                                     "next")
                                                    ('T
                                                     (SEQ
                                                      (LETT |pp|
                                                       (QCDR |pp1|) . #27#)
                                                      (LETT
                                                       |proddegree|
                                                       (- |proddegree|
                                                        (PROGN
                                                          (LETT #17#
                                                           NIL . #27#)
                                                          (SEQ
                                                           (LETT |u|
                                                            NIL . #27#)
                                                           (LETT #14#
                                                            (SPADCALL
                                                             |a|
                                                             (QREFELT $
                                                              12)) . #27#)
                                                           G190
                                                           (COND
                                                             ((OR
                                                               (ATOM
                                                                #14#)
                                                               (PROGN
                                                                 (LETT
                                                                  |u|
                                                                  (CAR
                                                                   #14#) . #27#)
                                                                 NIL))
                                                              #28#))
                                                           (SEQ
                                                            (EXIT
                                                             (PROGN
                                                               (LETT
                                                                #15#
                                                                (SPADCALL
                                                                 |u|
                                                                 |vv|
                                                                 (QREFELT
                                                                  $ 14)) . #27#)
                                                               (COND
                                                                 (#17#
                                                                  (LETT
                                                                   #16#
                                                                   (MAX
                                                                    #16#
                                                                    #15#) . #27#))
                                                                 ('T
                                                                  (PROGN
                                                                    (LETT
                                                                     #16#
                                                                     #15# . #27#)
                                                                    (LETT
                                                                     #17#
                                                                     'T . #27#)))))))
                                                           (LETT #14#
                                                            (CDR #14#) . #27#)
                                                           #29# G191
                                                           (EXIT NIL))
                                                          (COND
                                                            (#17# #16#)
                                                            ('T
                                                             (|IdentityError|
                                                              '|max|))))) . #27#)
                                                      (LETT |factors|
                                                       (SPADCALL |a|
                                                        |factors|
                                                        (QREFELT $ 38)) . #27#)
                                                      (LETT
                                                       |origFactors|
                                                       (SPADCALL |c|
                                                        |origFactors|
                                                        (QREFELT $ 38)) . #27#)
                                                      (EXIT
                                                       (LETT
                                                        |foundFactors|
                                                        (CONS |a|
                                                         |foundFactors|) . #27#)))))))
                                                (LETT #13#
                                                 (PROG1 (CDR #13#)
                                                   (LETT #12#
                                                    (CDR #12#) . #27#)) . #27#)
                                                #29# G191 (EXIT NIL))
                                               (EXIT
                                                (COND
                                                  ((<
                                                    (LENGTH |factors|)
                                                    2)
                                                   (PROGN
                                                     (LETT #18#
                                                      (CONS 0
                                                       (LIST
                                                        (COND
                                                          ((NULL
                                                            |factors|)
                                                           |foundFactors|)
                                                          ('T
                                                           (CONS |pp|
                                                            |foundFactors|))))) . #27#)
                                                     (GO #18#)))
                                                  ('T
                                                   (SEQ
                                                    (LETT |totdegree|
                                                     (PROGN
                                                       (LETT #26#
                                                        NIL . #27#)
                                                       (SEQ
                                                        (LETT |u1|
                                                         NIL . #27#)
                                                        (LETT #19#
                                                         |factors| . #27#)
                                                        G190
                                                        (COND
                                                          ((OR
                                                            (ATOM #19#)
                                                            (PROGN
                                                              (LETT
                                                               |u1|
                                                               (CAR
                                                                #19#) . #27#)
                                                              NIL))
                                                           #28#))
                                                        (SEQ
                                                         (EXIT
                                                          (PROGN
                                                            (LETT #24#
                                                             (PROGN
                                                               (LETT
                                                                #23#
                                                                NIL . #27#)
                                                               (SEQ
                                                                (LETT
                                                                 |u|
                                                                 NIL . #27#)
                                                                (LETT
                                                                 #20#
                                                                 (SPADCALL
                                                                  |u1|
                                                                  (QREFELT
                                                                   $
                                                                   12)) . #27#)
                                                                G190
                                                                (COND
                                                                  ((OR
                                                                    (ATOM
                                                                     #20#)
                                                                    (PROGN
                                                                      (LETT
                                                                       |u|
                                                                       (CAR
                                                                        #20#) . #27#)
                                                                      NIL))
                                                                   #28#))
                                                                (SEQ
                                                                 (EXIT
                                                                  (PROGN
                                                                    (LETT
                                                                     #21#
                                                                     (SPADCALL
                                                                      |u|
                                                                      |vv|
                                                                      (QREFELT
                                                                       $
                                                                       14)) . #27#)
                                                                    (COND
                                                                      (#23#
                                                                       (LETT
                                                                        #22#
                                                                        (MAX
                                                                         #22#
                                                                         #21#) . #27#))
                                                                      ('T
                                                                       (PROGN
                                                                         (LETT
                                                                          #22#
                                                                          #21# . #27#)
                                                                         (LETT
                                                                          #23#
                                                                          'T . #27#)))))))
                                                                (LETT
                                                                 #20#
                                                                 (CDR
                                                                  #20#) . #27#)
                                                                #29#
                                                                G191
                                                                (EXIT
                                                                 NIL))
                                                               (COND
                                                                 (#23#
                                                                  #22#)
                                                                 ('T
                                                                  (|IdentityError|
                                                                   '|max|)))) . #27#)
                                                            (COND
                                                              (#26#
                                                               (LETT
                                                                #25#
                                                                (+ #25#
                                                                 #24#) . #27#))
                                                              ('T
                                                               (PROGN
                                                                 (LETT
                                                                  #25#
                                                                  #24# . #27#)
                                                                 (LETT
                                                                  #26#
                                                                  'T . #27#)))))))
                                                        (LETT #19#
                                                         (CDR #19#) . #27#)
                                                        #29# G191
                                                        (EXIT NIL))
                                                       (COND
                                                         (#26# #25#)
                                                         ('T 0))) . #27#)
                                                    (EXIT
                                                     (LETT |n|
                                                      (+ |n| 1) . #27#)))))))))))))))
                           NIL #29# G191 (EXIT NIL))
                      (EXIT (CONS 1 "failed"))))
           #18# (EXIT #18#))))) 

(DEFUN |PFBR;hensel!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
      (QREFELT (QREFELT $$ 0) 27))) 

(DEFUN |PFBR;factorSFBRlcUnitInner| (|lvpp| |pp| |r| $)
  (PROG (|ppR| |fDown| #0=#:G1952 #1=#:G1953 |fSame| #2=#:G1954 |uu|
               #3=#:G1955 |factors| |hen| #4=#:G1956 |u| #5=#:G1957)
    (RETURN
      (SEQ (LETT |ppR|
                 (SPADCALL
                     (CONS #'|PFBR;factorSFBRlcUnitInner!0|
                           (VECTOR |r| $ |lvpp|))
                     |pp| (QREFELT $ 29))
                 . #6=(|PFBR;factorSFBRlcUnitInner|))
           (EXIT (COND
                   ((OR (< (SPADCALL |ppR| (QREFELT $ 43))
                           (SPADCALL |pp| (QREFELT $ 43)))
                        (< 0
                           (SPADCALL
                               (SPADCALL |ppR|
                                   (SPADCALL |ppR| (QREFELT $ 46))
                                   (QREFELT $ 47))
                               (QREFELT $ 43))))
                    (CONS 1 "failed"))
                   ('T
                    (SEQ (LETT |factors|
                               (COND
                                 ((NULL (CDR |lvpp|))
                                  (SEQ (LETT |fDown|
                                        (SPADCALL
                                         (SPADCALL
                                          (CONS
                                           #'|PFBR;factorSFBRlcUnitInner!1|
                                           $)
                                          |ppR| (QREFELT $ 57))
                                         (QREFELT $ 59)) . #6#)
                                       (EXIT
                                        (CONS
                                         (|PFBR;raise|
                                          (SPADCALL
                                           (SPADCALL |fDown|
                                            (QREFELT $ 61))
                                           (QVELT
                                            (|SPADfirst|
                                             (SPADCALL |fDown|
                                              (QREFELT $ 65)))
                                            1)
                                           (QREFELT $ 66))
                                          $)
                                         (PROGN
                                           (LETT #0# NIL . #6#)
                                           (SEQ (LETT |u| NIL . #6#)
                                            (LETT #1#
                                             (CDR
                                              (SPADCALL |fDown|
                                               (QREFELT $ 65))) . #6#)
                                            G190
                                            (COND
                                              ((OR (ATOM #1#)
                                                (PROGN
                                                  (LETT |u|
                                                   (CAR #1#) . #6#)
                                                  NIL))
                                               #7=(GO G191)))
                                            (SEQ
                                             (EXIT
                                              (LETT #0#
                                               (CONS
                                                (|PFBR;raise|
                                                 (QVELT |u| 1) $)
                                                #0#) . #6#)))
                                            (LETT #1# (CDR #1#) . #6#)
                                            #8=(GO G190) G191
                                            (EXIT (NREVERSE0 #0#))))))))
                                 ('T
                                  (SEQ (LETT |fSame|
                                        (SPADCALL (CDR |lvpp|) |ppR|
                                         (QREFELT $ 67)) . #6#)
                                       (EXIT
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL |fSame|
                                           (QREFELT $ 68))
                                          (QVELT
                                           (|SPADfirst|
                                            (SPADCALL |fSame|
                                             (QREFELT $ 71)))
                                           1)
                                          (QREFELT $ 20))
                                         (PROGN
                                           (LETT #2# NIL . #6#)
                                           (SEQ (LETT |uu| NIL . #6#)
                                            (LETT #3#
                                             (CDR
                                              (SPADCALL |fSame|
                                               (QREFELT $ 71))) . #6#)
                                            G190
                                            (COND
                                              ((OR (ATOM #3#)
                                                (PROGN
                                                  (LETT |uu|
                                                   (CAR #3#) . #6#)
                                                  NIL))
                                               #7#))
                                            (SEQ
                                             (EXIT
                                              (LETT #2#
                                               (CONS (QVELT |uu| 1)
                                                #2#) . #6#)))
                                            (LETT #3# (CDR #3#) . #6#)
                                            #8# G191
                                            (EXIT (NREVERSE0 #2#))))))))) . #6#)
                         (EXIT (COND
                                 ((EQL (LENGTH |factors|) 1)
                                  (CONS 0
                                        (SPADCALL (|spadConstant| $ 21)
                                         (LIST
                                          (VECTOR (CONS 2 "irred") |pp|
                                           1))
                                         (QREFELT $ 72))))
                                 ('T
                                  (SEQ (LETT |hen|
                                        (|PFBR;hensel| |pp|
                                         (|SPADfirst| |lvpp|) |r|
                                         |factors| $) . #6#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |hen| 1)
                                           (CONS 1 "failed"))
                                          ('T
                                           (CONS 0
                                            (SPADCALL
                                             (|spadConstant| $ 21)
                                             (PROGN
                                               (LETT #4# NIL . #6#)
                                               (SEQ
                                                (LETT |u| NIL . #6#)
                                                (LETT #5#
                                                 (QCAR (QCDR |hen|)) . #6#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #5#)
                                                    (PROGN
                                                      (LETT |u|
                                                       (CAR #5#) . #6#)
                                                      NIL))
                                                   #7#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #4#
                                                   (CONS
                                                    (VECTOR
                                                     (CONS 2 "irred")
                                                     |u| 1)
                                                    #4#) . #6#)))
                                                (LETT #5#
                                                 (CDR #5#) . #6#)
                                                #8# G191
                                                (EXIT (NREVERSE0 #4#))))
                                             (QREFELT $ 72)))))))))))))))))) 

(DEFUN |PFBR;factorSFBRlcUnitInner!1| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 54))) 

(DEFUN |PFBR;factorSFBRlcUnitInner!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 1) |PFBR;factorSFBRlcUnitInner|)
    (RETURN
      (PROGN
        (SPADCALL |#1| (SPADCALL (QREFELT $$ 2) (QREFELT $ 42))
            (QREFELT $$ 0) (QREFELT $ 27)))))) 

(DEFUN |PFBR;factorSFBRlcUnit;LSupF;3| (|lvpp| |pp| $)
  (PROG (|tempAns| |val1| |val| #0=#:G1965)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |val| (|spadConstant| $ 73)
                            . #1=(|PFBR;factorSFBRlcUnit;LSupF;3|))
                      (EXIT (SEQ G190 (COND ((NULL 'T) (GO G191)))
                                 (SEQ (LETT |tempAns|
                                       (|PFBR;factorSFBRlcUnitInner|
                                        |lvpp| |pp| |val| $) . #1#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |tempAns| 1)
                                          (SEQ
                                           (LETT |val1|
                                            (SPADCALL |val|
                                             (QREFELT $ 74)) . #1#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |val1| 1)
                                               (|error|
                                                "at this point, we know we have a finite field"))
                                              ('T
                                               (LETT |val|
                                                (QCDR |val1|) . #1#))))))
                                         ('T
                                          (PROGN
                                            (LETT #0#
                                             (QCDR |tempAns|) . #1#)
                                            (GO #0#))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #0# (EXIT #0#))))) 

(DEFUN |PFBR;factorSFBRlcUnit;LSupF;4| (|lvpp| |pp| $)
  (PROG (|tempAns| |val| #0=#:G1969)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |val| (SPADCALL (QREFELT $ 75))
                            . #1=(|PFBR;factorSFBRlcUnit;LSupF;4|))
                      (EXIT (SEQ G190 (COND ((NULL 'T) (GO G191)))
                                 (SEQ (LETT |tempAns|
                                       (|PFBR;factorSFBRlcUnitInner|
                                        |lvpp| |pp| |val| $) . #1#)
                                      (EXIT
                                       (COND
                                         ((QEQCAR |tempAns| 1)
                                          (LETT |val|
                                           (SPADCALL (QREFELT $ 75)) . #1#))
                                         ('T
                                          (PROGN
                                            (LETT #0#
                                             (QCDR |tempAns|) . #1#)
                                            (GO #0#))))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #0# (EXIT #0#))))) 

(DEFUN |PFBR;randomR;R;5| ($) (SPADCALL (QREFELT $ 76))) 

(DEFUN |PFBR;randomR;R;6| ($) (SPADCALL (|random|) (QREFELT $ 78))) 

(DEFUN |PFBR;bivariateSLPEBR;LSupVarSetU;7| (|lpolys| |pp| |v| $)
  (PROG (#0=#:G1987 |u| #1=#:G1988 |lpolysR| |ppR| |ans| #2=#:G1989 |w|
            #3=#:G1990)
    (RETURN
      (SEQ (LETT |lpolysR|
                 (PROGN
                   (LETT #0# NIL
                         . #4=(|PFBR;bivariateSLPEBR;LSupVarSetU;7|))
                   (SEQ (LETT |u| NIL . #4#) (LETT #1# |lpolys| . #4#)
                        G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |u| (CAR #1#) . #4#) NIL))
                           #5=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL (ELT $ 79) |u|
                                      (QREFELT $ 83))
                                     #0#) . #4#)))
                        (LETT #1# (CDR #1#) . #4#) #6=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #4#)
           (LETT |ppR| (SPADCALL (ELT $ 79) |pp| (QREFELT $ 83)) . #4#)
           (LETT |ans| (SPADCALL |lpolysR| |ppR| (QREFELT $ 84)) . #4#)
           (EXIT (COND
                   ((QEQCAR |ans| 1) (CONS 1 "failed"))
                   ('T
                    (CONS 0
                          (PROGN
                            (LETT #2# NIL . #4#)
                            (SEQ (LETT |w| NIL . #4#)
                                 (LETT #3# (QCDR |ans|) . #4#) G190
                                 (COND
                                   ((OR (ATOM #3#)
                                     (PROGN
                                       (LETT |w| (CAR #3#) . #4#)
                                       NIL))
                                    #5#))
                                 (SEQ (EXIT
                                       (LETT #2#
                                        (CONS
                                         (SPADCALL
                                          (CONS
                                           #'|PFBR;bivariateSLPEBR;LSupVarSetU;7!0|
                                           (VECTOR $ |v|))
                                          |w| (QREFELT $ 89))
                                         #2#) . #4#)))
                                 (LETT #3# (CDR #3#) . #4#) #6# G191
                                 (EXIT (NREVERSE0 #2#)))))))))))) 

(DEFUN |PFBR;bivariateSLPEBR;LSupVarSetU;7!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 86))) 

(DEFUN |PFBR;bivariateSLPEBR;LSupVarSetU;8| (|lpolys| |pp| |v| $)
  (SPADCALL |lpolys| |pp| (QREFELT $ 93))) 

(DEFUN |PFBR;chooseFSQViableSubstitutions| (|lvpp| |pp| $)
  (PROG (#0=#:G2002 |v| #1=#:G2003 |substns| |ppR| #2=#:G1999)
    (RETURN
      (SEQ (SEQ (EXIT (SEQ G190 (COND ((NULL 'T) #3=(GO G191)))
                           (SEQ (LETT |substns|
                                      (PROGN
                                        (LETT #0# NIL
                                         . #4=(|PFBR;chooseFSQViableSubstitutions|))
                                        (SEQ (LETT |v| NIL . #4#)
                                         (LETT #1# |lvpp| . #4#) G190
                                         (COND
                                           ((OR (ATOM #1#)
                                             (PROGN
                                               (LETT |v|
                                                (CAR #1#) . #4#)
                                               NIL))
                                            #3#))
                                         (SEQ
                                          (EXIT
                                           (LETT #0#
                                            (CONS
                                             (SPADCALL (QREFELT $ 75))
                                             #0#) . #4#)))
                                         (LETT #1# (CDR #1#) . #4#)
                                         #5=(GO G190) G191
                                         (EXIT (NREVERSE0 #0#)))) . #4#)
                                (EXIT (COND
                                        ((SPADCALL
                                          (SPADCALL
                                           (SPADCALL |pp|
                                            (QREFELT $ 94))
                                           |lvpp| |substns|
                                           (QREFELT $ 96))
                                          (QREFELT $ 97))
                                         "next")
                                        ('T
                                         (SEQ
                                          (LETT |ppR|
                                           (SPADCALL
                                            (CONS
                                             #'|PFBR;chooseFSQViableSubstitutions!0|
                                             (VECTOR $ |substns|
                                              |lvpp|))
                                            |pp| (QREFELT $ 57)) . #4#)
                                          (EXIT
                                           (COND
                                             ((< 0
                                               (SPADCALL
                                                (SPADCALL |ppR|
                                                 (SPADCALL |ppR|
                                                  (QREFELT $ 98))
                                                 (QREFELT $ 99))
                                                (QREFELT $ 100)))
                                              "next")
                                             ('T
                                              (PROGN
                                                (LETT #2#
                                                 |$NoValue| . #4#)
                                                (GO #2#))))))))))
                           NIL #5# G191 (EXIT NIL)))
                #2# (EXIT #2#))
           (EXIT (CONS |substns| |ppR|)))))) 

(DEFUN |PFBR;chooseFSQViableSubstitutions!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFBR;chooseFSQViableSubstitutions|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 96))
            (QREFELT $ 54)))))) 

(DEFUN |PFBR;chooseSLPEViableSubstitutions| (|lvpolys| |lpolys| |pp| $)
  (PROG (#0=#:G2023 #1=#:G2024 |substns| #2=#:G2025 #3=#:G2008
            #4=#:G2006 #5=#:G2007 #6=#:G2026 |u| #7=#:G2027 |lpolysR|
            |v| #8=#:G2028 #9=#:G2013 #10=#:G2011 #11=#:G2012
            #12=#:G2015 |uu| #13=#:G2020 |ppR|)
    (RETURN
      (SEQ (SEQ (EXIT (SEQ G190 (COND ((NULL 'T) #14=(GO G191)))
                           (SEQ (LETT |substns|
                                      (PROGN
                                        (LETT #0# NIL
                                         . #15=(|PFBR;chooseSLPEViableSubstitutions|))
                                        (SEQ (LETT |v| NIL . #15#)
                                         (LETT #1# |lvpolys| . #15#)
                                         G190
                                         (COND
                                           ((OR (ATOM #1#)
                                             (PROGN
                                               (LETT |v|
                                                (CAR #1#) . #15#)
                                               NIL))
                                            #14#))
                                         (SEQ
                                          (EXIT
                                           (LETT #0#
                                            (CONS
                                             (SPADCALL (QREFELT $ 75))
                                             #0#) . #15#)))
                                         (LETT #1# (CDR #1#) . #15#)
                                         #16=(GO G190) G191
                                         (EXIT (NREVERSE0 #0#)))) . #15#)
                                (EXIT (COND
                                        ((OR
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL |pp|
                                             (QREFELT $ 94))
                                            |lvpolys| |substns|
                                            (QREFELT $ 96))
                                           (QREFELT $ 97))
                                          (PROGN
                                            (LETT #5# NIL . #15#)
                                            (SEQ (LETT |u| NIL . #15#)
                                             (LETT #2# |lpolys| . #15#)
                                             G190
                                             (COND
                                               ((OR (ATOM #2#)
                                                 (PROGN
                                                   (LETT |u|
                                                    (CAR #2#) . #15#)
                                                   NIL))
                                                #14#))
                                             (SEQ
                                              (EXIT
                                               (PROGN
                                                 (LETT #3#
                                                  (SPADCALL
                                                   (SPADCALL
                                                    (SPADCALL |u|
                                                     (QREFELT $ 94))
                                                    |lvpolys| |substns|
                                                    (QREFELT $ 96))
                                                   (QREFELT $ 97)) . #15#)
                                                 (COND
                                                   (#5#
                                                    (LETT #4#
                                                     (COND
                                                       (#4# 'T)
                                                       ('T #3#)) . #15#))
                                                   ('T
                                                    (PROGN
                                                      (LETT #4#
                                                       #3# . #15#)
                                                      (LETT #5#
                                                       'T . #15#)))))))
                                             (LETT #2#
                                              (CDR #2#) . #15#)
                                             #16# G191 (EXIT NIL))
                                            (COND (#5# #4#) ('T 'NIL))))
                                         "next")
                                        ('T
                                         (SEQ
                                          (LETT |lpolysR|
                                           (PROGN
                                             (LETT #6# NIL . #15#)
                                             (SEQ (LETT |u| NIL . #15#)
                                              (LETT #7#
                                               |lpolys| . #15#)
                                              G190
                                              (COND
                                                ((OR (ATOM #7#)
                                                  (PROGN
                                                    (LETT |u|
                                                     (CAR #7#) . #15#)
                                                    NIL))
                                                 #14#))
                                              (SEQ
                                               (EXIT
                                                (LETT #6#
                                                 (CONS
                                                  (SPADCALL
                                                   (CONS
                                                    #'|PFBR;chooseSLPEViableSubstitutions!0|
                                                    (VECTOR $ |substns|
                                                     |lvpolys|))
                                                   |u| (QREFELT $ 57))
                                                  #6#) . #15#)))
                                              (LETT #7#
                                               (CDR #7#) . #15#)
                                              #16# G191
                                              (EXIT (NREVERSE0 #6#)))) . #15#)
                                          (LETT |uu| |lpolysR| . #15#)
                                          (SEQ
                                           (EXIT
                                            (SEQ G190
                                             (COND
                                               ((NULL
                                                 (COND
                                                   ((NULL |uu|) 'NIL)
                                                   ('T 'T)))
                                                #14#))
                                             (SEQ
                                              (EXIT
                                               (COND
                                                 ((PROGN
                                                    (LETT #11#
                                                     NIL . #15#)
                                                    (SEQ
                                                     (LETT |v|
                                                      NIL . #15#)
                                                     (LETT #8#
                                                      (CDR |uu|) . #15#)
                                                     G190
                                                     (COND
                                                       ((OR (ATOM #8#)
                                                         (PROGN
                                                           (LETT |v|
                                                            (CAR #8#) . #15#)
                                                           NIL))
                                                        #14#))
                                                     (SEQ
                                                      (EXIT
                                                       (PROGN
                                                         (LETT #9#
                                                          (< 0
                                                           (SPADCALL
                                                            (SPADCALL
                                                             (|SPADfirst|
                                                              |uu|)
                                                             |v|
                                                             (QREFELT $
                                                              99))
                                                            (QREFELT $
                                                             100))) . #15#)
                                                         (COND
                                                           (#11#
                                                            (LETT #10#
                                                             (COND
                                                               (#10#
                                                                'T)
                                                               ('T #9#)) . #15#))
                                                           ('T
                                                            (PROGN
                                                              (LETT
                                                               #10#
                                                               #9# . #15#)
                                                              (LETT
                                                               #11#
                                                               'T . #15#)))))))
                                                     (LETT #8#
                                                      (CDR #8#) . #15#)
                                                     #16# G191
                                                     (EXIT NIL))
                                                    (COND
                                                      (#11# #10#)
                                                      ('T 'NIL)))
                                                  (PROGN
                                                    (LETT #12#
                                                     |$NoValue| . #15#)
                                                    (GO #12#)))
                                                 ('T
                                                  (LETT |uu|
                                                   (CDR |uu|) . #15#)))))
                                             NIL #16# G191 (EXIT NIL)))
                                           #12# (EXIT #12#))
                                          (COND
                                            ((NULL (NULL |uu|))
                                             (EXIT "next")))
                                          (EXIT
                                           (PROGN
                                             (LETT #13#
                                              |$NoValue| . #15#)
                                             (GO #13#))))))))
                           NIL #16# G191 (EXIT NIL)))
                #13# (EXIT #13#))
           (LETT |ppR|
                 (SPADCALL
                     (CONS #'|PFBR;chooseSLPEViableSubstitutions!1|
                           (VECTOR $ |substns| |lvpolys|))
                     |pp| (QREFELT $ 57)) . #15#)
           (EXIT (VECTOR |substns| |lpolysR| |ppR|)))))) 

(DEFUN |PFBR;chooseSLPEViableSubstitutions!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFBR;chooseSLPEViableSubstitutions|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 96))
            (QREFELT $ 54)))))) 

(DEFUN |PFBR;chooseSLPEViableSubstitutions!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PFBR;chooseSLPEViableSubstitutions|)
    (RETURN
      (PROGN
        (SPADCALL
            (SPADCALL |#1| (QREFELT $$ 2) (QREFELT $$ 1)
                (QREFELT $ 96))
            (QREFELT $ 54)))))) 

(DEFUN |PFBR;raise| (|supR| $)
  (SPADCALL (CONS #'|PFBR;raise!0| $) |supR| (QREFELT $ 103))) 

(DEFUN |PFBR;raise!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 16))) 

(DEFUN |PFBR;lower| (|pp| $)
  (SPADCALL (CONS #'|PFBR;lower!0| $) |pp| (QREFELT $ 57))) 

(DEFUN |PFBR;lower!0| (|#1| $) (SPADCALL |#1| (QREFELT $ 54))) 

(DEFUN |PFBR;SLPEBR| (|lpolys| |lvpolys| |pp| |lvpp| $)
  (PROG (|v| #0=#:G2055 #1=#:G2056 |m| #2=#:G2057 |ans1| |d| #3=#:G2058
             |a1| #4=#:G2060 |a| #5=#:G2059 |ans| #6=#:G2061 |pp1|
             #7=#:G2062 #8=#:G2063 |u| #9=#:G2064 |lpolysR| |ppR|
             #10=#:G2054 #11=#:G2065 |uu| #12=#:G2066 |cVS| |ansR|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (NULL (LETT |m|
                                      (SPADCALL |lvpp| |lvpolys|
                                       (QREFELT $ 104))
                                      . #13=(|PFBR;SLPEBR|))))
                    (SEQ (LETT |v| (|SPADfirst| |m|) . #13#)
                         (LETT |lvpp|
                               (SPADCALL |v| |lvpp| (QREFELT $ 105)) . #13#)
                         (LETT |pp1|
                               (SPADCALL
                                   (SPADCALL
                                    (CONS #'|PFBR;SLPEBR!0|
                                     (VECTOR $ |v|))
                                    |pp| (QREFELT $ 110))
                                   (QREFELT $ 112)) . #13#)
                         (LETT |ans|
                               (PROGN
                                 (LETT #0# NIL . #13#)
                                 (SEQ (LETT |u| NIL . #13#)
                                      (LETT #1# |lpolys| . #13#) G190
                                      (COND
                                        ((OR (ATOM #1#)
                                          (PROGN
                                            (LETT |u| (CAR #1#) . #13#)
                                            NIL))
                                         #14=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (LETT #0#
                                         (CONS (|spadConstant| $ 113)
                                          #0#) . #13#)))
                                      (LETT #1# (CDR #1#) . #13#)
                                      #15=(GO G190) G191
                                      (EXIT (NREVERSE0 #0#)))) . #13#)
                         (SEQ (LETT |m| NIL . #13#)
                              (LETT #2#
                                    (NREVERSE
                                     (SPADCALL |pp1| (QREFELT $ 115))) . #13#)
                              G190
                              (COND
                                ((OR (ATOM #2#)
                                     (PROGN
                                       (LETT |m| (CAR #2#) . #13#)
                                       NIL))
                                 #14#))
                              (SEQ (LETT |ans1|
                                    (|PFBR;SLPEBR| |lpolys| |lvpolys|
                                     (SPADCALL |m| (QREFELT $ 116))
                                     |lvpp| $) . #13#)
                                   (EXIT
                                    (COND
                                      ((QEQCAR |ans1| 1)
                                       (PROGN
                                         (LETT #10#
                                          (CONS 1 "failed") . #13#)
                                         (GO #10#)))
                                      ('T
                                       (SEQ
                                        (LETT |d|
                                         (SPADCALL |m| (QREFELT $ 117)) . #13#)
                                        (EXIT
                                         (LETT |ans|
                                          (PROGN
                                            (LETT #3# NIL . #13#)
                                            (SEQ (LETT |a1| NIL . #13#)
                                             (LETT #4#
                                              (QCDR |ans1|) . #13#)
                                             (LETT |a| NIL . #13#)
                                             (LETT #5# |ans| . #13#)
                                             G190
                                             (COND
                                               ((OR (ATOM #5#)
                                                 (PROGN
                                                   (LETT |a|
                                                    (CAR #5#) . #13#)
                                                   NIL)
                                                 (ATOM #4#)
                                                 (PROGN
                                                   (LETT |a1|
                                                    (CAR #4#) . #13#)
                                                   NIL))
                                                #14#))
                                             (SEQ
                                              (EXIT
                                               (LETT #3#
                                                (CONS
                                                 (SPADCALL
                                                  (SPADCALL |a1| |d|
                                                   (QREFELT $ 118))
                                                  |a| (QREFELT $ 119))
                                                 #3#) . #13#)))
                                             (LETT #5#
                                              (PROG1 (CDR #5#)
                                                (LETT #4#
                                                 (CDR #4#) . #13#)) . #13#)
                                             #15# G191
                                             (EXIT (NREVERSE0 #3#)))) . #13#)))))))
                              (LETT #2# (CDR #2#) . #13#) #15# G191
                              (EXIT NIL))
                         (EXIT (CONS 0
                                     (PROGN
                                       (LETT #6# NIL . #13#)
                                       (SEQ (LETT |pp1| NIL . #13#)
                                        (LETT #7# |ans| . #13#) G190
                                        (COND
                                          ((OR (ATOM #7#)
                                            (PROGN
                                              (LETT |pp1|
                                               (CAR #7#) . #13#)
                                              NIL))
                                           #14#))
                                        (SEQ
                                         (EXIT
                                          (LETT #6#
                                           (CONS
                                            (SPADCALL
                                             (CONS #'|PFBR;SLPEBR!1|
                                              (VECTOR $ |v|))
                                             (SPADCALL |pp1|
                                              (QREFELT $ 112))
                                             (QREFELT $ 122))
                                            #6#) . #13#)))
                                        (LETT #7# (CDR #7#) . #13#)
                                        #15# G191
                                        (EXIT (NREVERSE0 #6#))))))))
                   ('T
                    (COND
                      ((NULL |lvpolys|)
                       (SEQ (LETT |lpolysR|
                                  (PROGN
                                    (LETT #8# NIL . #13#)
                                    (SEQ (LETT |u| NIL . #13#)
                                     (LETT #9# |lpolys| . #13#) G190
                                     (COND
                                       ((OR (ATOM #9#)
                                         (PROGN
                                           (LETT |u| (CAR #9#) . #13#)
                                           NIL))
                                        #14#))
                                     (SEQ
                                      (EXIT
                                       (LETT #8#
                                        (CONS
                                         (SPADCALL (ELT $ 54) |u|
                                          (QREFELT $ 57))
                                         #8#) . #13#)))
                                     (LETT #9# (CDR #9#) . #13#) #15#
                                     G191 (EXIT (NREVERSE0 #8#)))) . #13#)
                            (LETT |ppR|
                                  (SPADCALL (ELT $ 54) |pp|
                                      (QREFELT $ 57)) . #13#)
                            (LETT |ansR|
                                  (SPADCALL |lpolysR| |ppR|
                                      (QREFELT $ 123)) . #13#)
                            (EXIT (COND
                                    ((QEQCAR |ansR| 1)
                                     (PROGN
                                       (LETT #10#
                                        (CONS 1 "failed") . #13#)
                                       (GO #10#)))
                                    ('T
                                     (CONS 0
                                      (PROGN
                                        (LETT #11# NIL . #13#)
                                        (SEQ (LETT |uu| NIL . #13#)
                                         (LETT #12#
                                          (QCDR |ansR|) . #13#)
                                         G190
                                         (COND
                                           ((OR (ATOM #12#)
                                             (PROGN
                                               (LETT |uu|
                                                (CAR #12#) . #13#)
                                               NIL))
                                            #14#))
                                         (SEQ
                                          (EXIT
                                           (LETT #11#
                                            (CONS
                                             (SPADCALL
                                              (CONS #'|PFBR;SLPEBR!2|
                                               $)
                                              |uu| (QREFELT $ 103))
                                             #11#) . #13#)))
                                         (LETT #12# (CDR #12#) . #13#)
                                         #15# G191
                                         (EXIT (NREVERSE0 #11#))))))))))
                      ('T
                       (SEQ (LETT |cVS|
                                  (|PFBR;chooseSLPEViableSubstitutions|
                                      |lvpolys| |lpolys| |pp| $) . #13#)
                            (LETT |ansR|
                                  (SPADCALL (QVELT |cVS| 1)
                                      (QVELT |cVS| 2) (QREFELT $ 123)) . #13#)
                            (EXIT (COND
                                    ((QEQCAR |ansR| 1)
                                     (CONS 1 "failed"))
                                    ((EQL (LENGTH |lvpolys|) 1)
                                     (SPADCALL |lpolys| |pp|
                                      (|SPADfirst| |lvpolys|)
                                      (QREFELT $ 91)))
                                    ('T
                                     (SPADCALL |lpolys| |pp|
                                      (QREFELT $ 93)))))))))))
           #10# (EXIT #10#))))) 

(DEFUN |PFBR;SLPEBR!2| (|#1| $) (SPADCALL |#1| (QREFELT $ 16))) 

(DEFUN |PFBR;SLPEBR!1| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 85))) 

(DEFUN |PFBR;SLPEBR!0| (|#1| $$)
  (SPADCALL |#1| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 106))) 

(DEFUN |PFBR;solveLinearPolynomialEquationByRecursion;LSupU;14|
       (|lpolys| |pp| $)
  (PROG (#0=#:G2072 |u| #1=#:G2073 #2=#:G2074 #3=#:G2075 |lvpolys|
            #4=#:G2076 |z| #5=#:G2077 |lvpp|)
    (RETURN
      (SEQ (LETT |lvpolys|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #0# NIL
                                 . #6=(|PFBR;solveLinearPolynomialEquationByRecursion;LSupU;14|))
                           (SEQ (LETT |u| NIL . #6#)
                                (LETT #1# |lpolys| . #6#) G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |u| (CAR #1#) . #6#)
                                      NIL))
                                   #7=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (PROGN
                                           (LETT #2# NIL . #6#)
                                           (SEQ (LETT |z| NIL . #6#)
                                            (LETT #3#
                                             (SPADCALL |u|
                                              (QREFELT $ 12)) . #6#)
                                            G190
                                            (COND
                                              ((OR (ATOM #3#)
                                                (PROGN
                                                  (LETT |z|
                                                   (CAR #3#) . #6#)
                                                  NIL))
                                               #7#))
                                            (SEQ
                                             (EXIT
                                              (LETT #2#
                                               (CONS
                                                (SPADCALL |z|
                                                 (QREFELT $ 124))
                                                #2#) . #6#)))
                                            (LETT #3# (CDR #3#) . #6#)
                                            #8=(GO G190) G191
                                            (EXIT (NREVERSE0 #2#))))
                                         (QREFELT $ 125))
                                        #0#) . #6#)))
                                (LETT #1# (CDR #1#) . #6#) #8# G191
                                (EXIT (NREVERSE0 #0#))))
                         (QREFELT $ 125))
                     (QREFELT $ 126)) . #6#)
           (LETT |lvpp|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #4# NIL . #6#)
                           (SEQ (LETT |z| NIL . #6#)
                                (LETT #5#
                                      (SPADCALL |pp| (QREFELT $ 12)) . #6#)
                                G190
                                (COND
                                  ((OR (ATOM #5#)
                                    (PROGN
                                      (LETT |z| (CAR #5#) . #6#)
                                      NIL))
                                   #7#))
                                (SEQ (EXIT
                                      (LETT #4#
                                       (CONS
                                        (SPADCALL |z| (QREFELT $ 124))
                                        #4#) . #6#)))
                                (LETT #5# (CDR #5#) . #6#) #8# G191
                                (EXIT (NREVERSE0 #4#))))
                         (QREFELT $ 125))
                     (QREFELT $ 126)) . #6#)
           (EXIT (|PFBR;SLPEBR| |lpolys| |lvpolys| |pp| |lvpp| $)))))) 

(DEFUN |PFBR;factorByRecursion;SupF;15| (|pp| $)
  (PROG (#0=#:G2088 |z| #1=#:G2089 |lv| |c| #2=#:G2082)
    (RETURN
      (SEQ (LETT |lv|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #0# NIL
                                 . #3=(|PFBR;factorByRecursion;SupF;15|))
                           (SEQ (LETT |z| NIL . #3#)
                                (LETT #1#
                                      (SPADCALL |pp| (QREFELT $ 12)) . #3#)
                                G190
                                (COND
                                  ((OR (ATOM #1#)
                                    (PROGN
                                      (LETT |z| (CAR #1#) . #3#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL |z| (QREFELT $ 124))
                                        #0#) . #3#)))
                                (LETT #1# (CDR #1#) . #3#) (GO G190)
                                G191 (EXIT (NREVERSE0 #0#))))
                         (QREFELT $ 125))
                     (QREFELT $ 126)) . #3#)
           (EXIT (COND
                   ((NULL |lv|)
                    (SPADCALL (CONS (|function| |PFBR;raise|) $)
                        (SPADCALL (|PFBR;lower| |pp| $)
                            (QREFELT $ 128))
                        (QREFELT $ 131)))
                   ('T
                    (SEQ (LETT |c|
                               (SPADCALL |pp| (QREFELT $ 132)) . #3#)
                         (EXIT (COND
                                 ((SPADCALL |c| (QREFELT $ 133))
                                  (SPADCALL
                                      (SPADCALL |pp| (QREFELT $ 135))
                                      (ELT $ 136) (QREFELT $ 139)))
                                 ('T
                                  (SEQ (LETT |pp|
                                        (PROG2
                                         (LETT #2#
                                          (SPADCALL |pp| |c|
                                           (QREFELT $ 24)) . #3#)
                                         (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 0)
                                           (|SparseUnivariatePolynomial|
                                            (QREFELT $ 9))
                                           #2#)) . #3#)
                                       (EXIT
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |pp|
                                           (QREFELT $ 135))
                                          (ELT $ 136) (QREFELT $ 139))
                                         (SPADCALL
                                          (CONS
                                           #'|PFBR;factorByRecursion;SupF;15!0|
                                           $)
                                          (SPADCALL |c|
                                           (QREFELT $ 141))
                                          (QREFELT $ 144))
                                         (QREFELT $ 145))))))))))))))) 

(DEFUN |PFBR;factorByRecursion;SupF;15!0| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 140))) 

(DEFUN |PFBR;factorSquareFreeByRecursion;SupF;16| (|pp| $)
  (PROG (#0=#:G2119 |z| #1=#:G2120 |lv| |lcpp| |cVS| |factorsR| |nfact|
            #2=#:G2118 |oldnfact| #3=#:G2121 #4=#:G2122 |ppAdjust|
            |lvppList| |v| #5=#:G2124 |u| #6=#:G2123 |hen| OK
            #7=#:G2107 #8=#:G2125 #9=#:G2126 |lc| |lcppPow| #10=#:G2109
            |factors| #11=#:G2099 #12=#:G2127 |w| #13=#:G2128)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |lv|
                            (SPADCALL
                                (SPADCALL
                                    (PROGN
                                      (LETT #0# NIL
                                       . #14=(|PFBR;factorSquareFreeByRecursion;SupF;16|))
                                      (SEQ (LETT |z| NIL . #14#)
                                       (LETT #1#
                                        (SPADCALL |pp| (QREFELT $ 12)) . #14#)
                                       G190
                                       (COND
                                         ((OR (ATOM #1#)
                                           (PROGN
                                             (LETT |z|
                                              (CAR #1#) . #14#)
                                             NIL))
                                          #15=(GO G191)))
                                       (SEQ
                                        (EXIT
                                         (LETT #0#
                                          (CONS
                                           (SPADCALL |z|
                                            (QREFELT $ 124))
                                           #0#) . #14#)))
                                       (LETT #1# (CDR #1#) . #14#)
                                       #16=(GO G190) G191
                                       (EXIT (NREVERSE0 #0#))))
                                    (QREFELT $ 125))
                                (QREFELT $ 126)) . #14#)
                      (EXIT (COND
                              ((NULL |lv|)
                               (SPADCALL
                                   (CONS (|function| |PFBR;raise|) $)
                                   (SPADCALL (|PFBR;lower| |pp| $)
                                    (QREFELT $ 128))
                                   (QREFELT $ 131)))
                              ((SPADCALL
                                   (LETT |lcpp|
                                    (SPADCALL |pp| (QREFELT $ 94)) . #14#)
                                   (QREFELT $ 133))
                               (SPADCALL |lv| |pp| (QREFELT $ 67)))
                              ('T
                               (SEQ (LETT |oldnfact| 999999 . #14#)
                                    (SEQ
                                     (EXIT
                                      (SEQ G190 (COND ((NULL 'T) #15#))
                                       (SEQ
                                        (LETT |cVS|
                                         (|PFBR;chooseFSQViableSubstitutions|
                                          |lv| |pp| $) . #14#)
                                        (LETT |factorsR|
                                         (SPADCALL (QCDR |cVS|)
                                          (QREFELT $ 59)) . #14#)
                                        (LETT |nfact|
                                         (SPADCALL |factorsR|
                                          (QREFELT $ 147)) . #14#)
                                        (EXIT
                                         (COND
                                           ((EQL |nfact| 1)
                                            (PROGN
                                              (LETT #2#
                                               (SPADCALL
                                                (|spadConstant| $ 21)
                                                (LIST
                                                 (VECTOR
                                                  (CONS 2 "irred") |pp|
                                                  1))
                                                (QREFELT $ 72)) . #14#)
                                              (GO #2#)))
                                           ((< |oldnfact| |nfact|)
                                            "next")
                                           ('T
                                            (SEQ
                                             (LETT |oldnfact|
                                              |nfact| . #14#)
                                             (LETT |factors|
                                              (PROGN
                                                (LETT #3# NIL . #14#)
                                                (SEQ
                                                 (LETT |u| NIL . #14#)
                                                 (LETT #4#
                                                  (SPADCALL |factorsR|
                                                   (QREFELT $ 65)) . #14#)
                                                 G190
                                                 (COND
                                                   ((OR (ATOM #4#)
                                                     (PROGN
                                                       (LETT |u|
                                                        (CAR #4#) . #14#)
                                                       NIL))
                                                    #15#))
                                                 (SEQ
                                                  (EXIT
                                                   (LETT #3#
                                                    (CONS
                                                     (SPADCALL
                                                      (PROG2
                                                       (LETT #11#
                                                        (SPADCALL
                                                         |lcpp|
                                                         (SPADCALL
                                                          (QVELT |u| 1)
                                                          (QREFELT $
                                                           148))
                                                         (QREFELT $
                                                          149)) . #14#)
                                                       (QCDR #11#)
                                                        (|check-union|
                                                         (QEQCAR #11#
                                                          0)
                                                         (QREFELT $ 9)
                                                         #11#))
                                                      (|PFBR;raise|
                                                       (QVELT |u| 1) $)
                                                      (QREFELT $ 150))
                                                     #3#) . #14#)))
                                                 (LETT #4#
                                                  (CDR #4#) . #14#)
                                                 #16# G191
                                                 (EXIT (NREVERSE0 #3#)))) . #14#)
                                             (LETT |ppAdjust|
                                              (SPADCALL
                                               (LETT |lcppPow|
                                                (SPADCALL |lcpp|
                                                 (LENGTH
                                                  (CDR |factors|))
                                                 (QREFELT $ 151)) . #14#)
                                               |pp| (QREFELT $ 150)) . #14#)
                                             (LETT |lvppList|
                                              |lv| . #14#)
                                             (LETT OK 'T . #14#)
                                             (SEQ (LETT |v| NIL . #14#)
                                              (LETT #5#
                                               (QCAR |cVS|) . #14#)
                                              (LETT |u| NIL . #14#)
                                              (LETT #6#
                                               |lvppList| . #14#)
                                              G190
                                              (COND
                                                ((OR (ATOM #6#)
                                                  (PROGN
                                                    (LETT |u|
                                                     (CAR #6#) . #14#)
                                                    NIL)
                                                  (ATOM #5#)
                                                  (PROGN
                                                    (LETT |v|
                                                     (CAR #5#) . #14#)
                                                    NIL))
                                                 #15#))
                                              (SEQ
                                               (LETT |hen|
                                                (|PFBR;hensel|
                                                 |ppAdjust| |u| |v|
                                                 |factors| $) . #14#)
                                               (EXIT
                                                (COND
                                                  ((QEQCAR |hen| 1)
                                                   (SEQ
                                                    (LETT OK
                                                     'NIL . #14#)
                                                    (EXIT "leave")))
                                                  ('T
                                                   (LETT |factors|
                                                    (QCAR (QCDR |hen|)) . #14#)))))
                                              (LETT #6#
                                               (PROG1 (CDR #6#)
                                                 (LETT #5#
                                                  (CDR #5#) . #14#)) . #14#)
                                              #16# G191 (EXIT NIL))
                                             (EXIT
                                              (COND
                                                (OK
                                                 (PROGN
                                                   (LETT #7#
                                                    |$NoValue| . #14#)
                                                   (GO #7#))))))))))
                                       NIL #16# G191 (EXIT NIL)))
                                     #7# (EXIT #7#))
                                    (LETT |factors|
                                     (PROGN
                                       (LETT #8# NIL . #14#)
                                       (SEQ (LETT |w| NIL . #14#)
                                        (LETT #9# |factors| . #14#)
                                        G190
                                        (COND
                                          ((OR (ATOM #9#)
                                            (PROGN
                                              (LETT |w|
                                               (CAR #9#) . #14#)
                                              NIL))
                                           #15#))
                                        (SEQ
                                         (EXIT
                                          (LETT #8#
                                           (CONS
                                            (SEQ
                                             (LETT |lc|
                                              (SPADCALL |w|
                                               (QREFELT $ 132)) . #14#)
                                             (LETT |lcppPow|
                                              (PROG2
                                               (LETT #11#
                                                (SPADCALL |lcppPow|
                                                 |lc| (QREFELT $ 152)) . #14#)
                                               (QCDR #11#)
                                                (|check-union|
                                                 (QEQCAR #11# 0)
                                                 (QREFELT $ 9) #11#)) . #14#)
                                             (EXIT
                                              (PROG2
                                               (LETT #10#
                                                (SPADCALL |w| |lc|
                                                 (QREFELT $ 24)) . #14#)
                                               (QCDR #10#)
                                                (|check-union|
                                                 (QEQCAR #10# 0)
                                                 (|SparseUnivariatePolynomial|
                                                  (QREFELT $ 9))
                                                 #10#))))
                                            #8#) . #14#)))
                                        (LETT #9# (CDR #9#) . #14#)
                                        #16# G191
                                        (EXIT (NREVERSE0 #8#)))) . #14#)
                                    (COND
                                      ((NULL
                                        (SPADCALL |lcppPow|
                                         (QREFELT $ 133)))
                                       (EXIT
                                        (|error|
                                         "internal error in factorSquareFreeByRecursion"))))
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL
                                       (PROG2
                                        (LETT #11#
                                         (SPADCALL |lcppPow|
                                          (QREFELT $ 153)) . #14#)
                                        (QCDR #11#)
                                         (|check-union| (QEQCAR #11# 0)
                                          (QREFELT $ 9) #11#))
                                       (QREFELT $ 140))
                                      (PROGN
                                        (LETT #12# NIL . #14#)
                                        (SEQ (LETT |w| NIL . #14#)
                                         (LETT #13# |factors| . #14#)
                                         G190
                                         (COND
                                           ((OR (ATOM #13#)
                                             (PROGN
                                               (LETT |w|
                                                (CAR #13#) . #14#)
                                               NIL))
                                            #15#))
                                         (SEQ
                                          (EXIT
                                           (LETT #12#
                                            (CONS
                                             (VECTOR (CONS 2 "irred")
                                              |w| 1)
                                             #12#) . #14#)))
                                         (LETT #13# (CDR #13#) . #14#)
                                         #16# G191
                                         (EXIT (NREVERSE0 #12#))))
                                      (QREFELT $ 72)))))))))
           #2# (EXIT #2#))))) 

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

(DEFUN |PolynomialFactorizationByRecursion;| (|#1| |#2| |#3| |#4|)
  (PROG (DV$1 DV$2 DV$3 DV$4 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|PolynomialFactorizationByRecursion|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT |dv$|
              (LIST '|PolynomialFactorizationByRecursion| DV$1 DV$2
                    DV$3 DV$4) . #0#)
        (LETT $ (GETREFV 154) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache|
            '|PolynomialFactorizationByRecursion|
            (LIST DV$1 DV$2 DV$3 DV$4) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (COND
          ((|HasCategory| |#1| '(|StepThrough|))
           (QSETREFV $ 67
               (CONS (|dispatchFunction|
                         |PFBR;factorSFBRlcUnit;LSupF;3|)
                     $)))
          ('T
           (QSETREFV $ 67
               (CONS (|dispatchFunction|
                         |PFBR;factorSFBRlcUnit;LSupF;4|)
                     $))))
        (COND
          ((|HasSignature| |#1|
               (LIST '|random| (LIST (|devaluate| |#1|))))
           (QSETREFV $ 75
               (CONS (|dispatchFunction| |PFBR;randomR;R;5|) $)))
          ('T
           (QSETREFV $ 75
               (CONS (|dispatchFunction| |PFBR;randomR;R;6|) $))))
        (COND
          ((|HasCategory| |#1| '(|FiniteFieldCategory|))
           (QSETREFV $ 91
               (CONS (|dispatchFunction|
                         |PFBR;bivariateSLPEBR;LSupVarSetU;7|)
                     $)))
          ('T
           (QSETREFV $ 91
               (CONS (|dispatchFunction|
                         |PFBR;bivariateSLPEBR;LSupVarSetU;8|)
                     $))))
        $)))) 

(MAKEPROP '|PolynomialFactorizationByRecursion| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|List| 9)
             (|SparseUnivariatePolynomial| 9) (0 . |coefficients|)
             (|NonNegativeInteger|) (5 . |degree|) (11 . |coerce|)
             (16 . |coerce|) (21 . -) (|PositiveInteger|) (27 . **)
             (33 . *) (39 . |One|) (43 . -) (|Union| $ '"failed")
             (49 . |exquo|) (|Boolean|) (55 . |zero?|) (60 . |eval|)
             (|Mapping| 9 9) (67 . |map|) (|Union| 31 '"failed")
             (|List| 32) (|SparseUnivariatePolynomial| $)
             (73 . |solveLinearPolynomialEquation|) (79 . *) (85 . +)
             (91 . |exquo|) (|List| 11) (97 . |remove|) (103 . |One|)
             (107 . |One|) (|List| 8) (111 . |first|) (116 . |degree|)
             (121 . |Zero|) (125 . |Zero|) (129 . |differentiate|)
             (134 . |gcd|) (140 . |Zero|)
             (|SparseUnivariatePolynomial| 6) (144 . |Zero|)
             (148 . |Zero|) (|Factored| 11) (152 . |Zero|)
             (156 . |retract|) (|Mapping| 6 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 11 6 49)
             (161 . |map|) (|Factored| 32)
             (167 . |factorSquareFreePolynomial|) (|Factored| 49)
             (172 . |unit|) (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 62) (|:| |fctr| 49) (|:| |xpnt| 77))
             (|List| 63) (177 . |factorList|) (182 . *)
             (188 . |factorSFBRlcUnit|) (194 . |unit|)
             (|Record| (|:| |flg| 62) (|:| |fctr| 11) (|:| |xpnt| 77))
             (|List| 69) (199 . |factorList|) (204 . |makeFR|)
             (210 . |init|) (214 . |nextItem|) (219 . |randomR|)
             (223 . |random|) (|Integer|) (227 . |coerce|)
             (232 . |univariate|) (|SparseUnivariatePolynomial| 49)
             (|Mapping| 49 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 11 49 80)
             (237 . |map|) (243 . |solveLinearPolynomialEquation|)
             (249 . |multivariate|) (255 . |multivariate|)
             (|Mapping| 9 49)
             (|UnivariatePolynomialCategoryFunctions2| 49 80 9 11)
             (261 . |map|) (|Union| 37 '"failed")
             (267 . |bivariateSLPEBR|)
             (|LinearPolynomialEquationByFractions| 9)
             (274 . |solveLinearPolynomialEquationByFractions|)
             (280 . |leadingCoefficient|) (|List| 6) (285 . |eval|)
             (292 . |zero?|) (297 . |differentiate|) (302 . |gcd|)
             (308 . |degree|) (|Mapping| 9 6)
             (|UnivariatePolynomialCategoryFunctions2| 6 49 9 11)
             (313 . |map|) (319 . |setDifference|) (325 . |remove|)
             (331 . |univariate|) (|SparseUnivariatePolynomial| 11)
             (|Mapping| 11 9)
             (|UnivariatePolynomialCategoryFunctions2| 9 11 11 107)
             (337 . |map|)
             (|CommuteUnivariatePolynomialCategory| 9 11 107)
             (343 . |swap|) (348 . |Zero|) (|List| $)
             (352 . |monomials|) (357 . |leadingCoefficient|)
             (362 . |degree|) (367 . |monomial|) (373 . +)
             (|Mapping| 9 11)
             (|UnivariatePolynomialCategoryFunctions2| 11 107 9 11)
             (379 . |map|) (385 . |solveLinearPolynomialEquation|)
             (391 . |variables|) (396 . |concat|)
             (401 . |removeDuplicates!|)
             |PFBR;solveLinearPolynomialEquationByRecursion;LSupU;14|
             (406 . |factorPolynomial|) (|Mapping| 11 49)
             (|FactoredFunctions2| 49 11) (411 . |map|)
             (417 . |content|) (422 . |unit?|) (|Factored| $)
             (427 . |squareFree|)
             |PFBR;factorSquareFreeByRecursion;SupF;16|
             (|Mapping| 52 11) (|FactoredFunctionUtilities| 11)
             (432 . |refine|) (438 . |coerce|) (443 . |factor|)
             (|Factored| 9) (|FactoredFunctions2| 9 11) (448 . |map|)
             (454 . |mergeFactors|) |PFBR;factorByRecursion;SupF;15|
             (460 . |numberOfFactors|) (465 . |leadingCoefficient|)
             (470 . |exquo|) (476 . *) (482 . **) (488 . |exquo|)
             (494 . |recip|))
          '#(|solveLinearPolynomialEquationByRecursion| 499 |randomR|
             505 |factorSquareFreeByRecursion| 509 |factorSFBRlcUnit|
             514 |factorByRecursion| 520 |bivariateSLPEBR| 525)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 153
                                '(1 11 10 0 12 2 9 13 0 8 14 1 9 0 8 15
                                  1 9 0 6 16 2 9 0 0 0 17 2 9 0 0 18 19
                                  2 11 0 0 0 20 0 11 0 21 2 11 0 0 0 22
                                  2 11 23 0 9 24 1 11 25 0 26 3 9 0 0 8
                                  6 27 2 11 0 28 0 29 2 9 30 31 32 33 2
                                  11 0 0 9 34 2 11 0 0 0 35 2 11 23 0 0
                                  36 2 37 0 11 0 38 0 6 0 39 0 9 0 40 1
                                  41 8 0 42 1 11 13 0 43 0 6 0 44 0 7 0
                                  45 1 11 0 0 46 2 11 0 0 0 47 0 9 0 48
                                  0 49 0 50 0 11 0 51 0 52 0 53 1 9 6 0
                                  54 2 56 49 55 11 57 1 6 58 32 59 1 60
                                  49 0 61 1 60 64 0 65 2 49 0 0 0 66 2
                                  0 52 41 11 67 1 52 11 0 68 1 52 70 0
                                  71 2 52 0 11 70 72 0 6 0 73 1 6 23 0
                                  74 0 0 6 75 0 6 0 76 1 6 0 77 78 1 9
                                  49 0 79 2 82 80 81 11 83 2 49 30 31
                                  32 84 2 9 0 32 8 85 2 9 0 49 8 86 2
                                  88 11 87 80 89 3 0 90 37 11 8 91 2 92
                                  90 37 11 93 1 11 9 0 94 3 9 0 0 41 95
                                  96 1 9 25 0 97 1 49 0 0 98 2 49 0 0 0
                                  99 1 49 13 0 100 2 102 11 101 49 103
                                  2 41 0 0 0 104 2 41 0 8 0 105 2 9 32
                                  0 8 106 2 109 107 108 11 110 1 111
                                  107 107 112 0 107 0 113 1 107 114 0
                                  115 1 107 11 0 116 1 107 13 0 117 2
                                  107 0 11 13 118 2 107 0 0 0 119 2 121
                                  11 120 107 122 2 6 30 31 32 123 1 9
                                  41 0 124 1 41 0 114 125 1 41 0 0 126
                                  1 6 58 32 128 2 130 52 129 60 131 1
                                  11 9 0 132 1 9 25 0 133 1 11 134 0
                                  135 2 138 52 52 137 139 1 11 0 9 140
                                  1 9 134 0 141 2 143 52 108 142 144 2
                                  138 52 52 52 145 1 60 13 0 147 1 49 6
                                  0 148 2 9 23 0 6 149 2 11 0 9 0 150 2
                                  9 0 0 13 151 2 9 23 0 0 152 1 9 23 0
                                  153 2 0 90 37 11 127 0 0 6 75 1 0 52
                                  11 136 2 0 52 41 11 67 1 0 52 11 146
                                  3 0 90 37 11 8 91)))))
          '|lookupComplete|)) 
