
(/VERSIONCHECK 2) 

(DEFUN |GALFACT;useEisensteinCriterion?;B;1| ($) (QREFELT $ 11)) 

(DEFUN |GALFACT;useEisensteinCriterion;2B;2| (|b| $)
  (PROG (|#G4| |#G5|)
    (RETURN
      (SEQ (PROGN
             (LETT |#G4| |b|
                   . #0=(|GALFACT;useEisensteinCriterion;2B;2|))
             (LETT |#G5| (QREFELT $ 11) . #0#)
             (SETELT $ 11 |#G4|)
             (LETT |b| |#G5| . #0#))
           (EXIT |b|))))) 

(DEFUN |GALFACT;tryFunctionalDecomposition?;B;3| ($) (QREFELT $ 10)) 

(DEFUN |GALFACT;tryFunctionalDecomposition;2B;4| (|b| $)
  (PROG (|#G7| |#G8|)
    (RETURN
      (SEQ (PROGN
             (LETT |#G7| |b|
                   . #0=(|GALFACT;tryFunctionalDecomposition;2B;4|))
             (LETT |#G8| (QREFELT $ 10) . #0#)
             (SETELT $ 10 |#G7|)
             (LETT |b| |#G8| . #0#))
           (EXIT |b|))))) 

(DEFUN |GALFACT;useSingleFactorBound?;B;5| ($) (QREFELT $ 9)) 

(DEFUN |GALFACT;useSingleFactorBound;2B;6| (|b| $)
  (PROG (|#G10| |#G11|)
    (RETURN
      (SEQ (PROGN
             (LETT |#G10| |b|
                   . #0=(|GALFACT;useSingleFactorBound;2B;6|))
             (LETT |#G11| (QREFELT $ 9) . #0#)
             (SETELT $ 9 |#G10|)
             (LETT |b| |#G11| . #0#))
           (EXIT |b|))))) 

(DEFUN |GALFACT;stopMusserTrials;Pi;7| ($) (QREFELT $ 8)) 

(DEFUN |GALFACT;stopMusserTrials;2Pi;8| (|n| $)
  (PROG (|#G13| |#G14|)
    (RETURN
      (SEQ (PROGN
             (LETT |#G13| |n| . #0=(|GALFACT;stopMusserTrials;2Pi;8|))
             (LETT |#G14| (QREFELT $ 8) . #0#)
             (SETELT $ 8 |#G13|)
             (LETT |n| |#G14| . #0#))
           (EXIT |n|))))) 

(DEFUN |GALFACT;musserTrials;Pi;9| ($) (QREFELT $ 7)) 

(DEFUN |GALFACT;musserTrials;2Pi;10| (|n| $)
  (PROG (|#G16| |#G17|)
    (RETURN
      (SEQ (PROGN
             (LETT |#G16| |n| . #0=(|GALFACT;musserTrials;2Pi;10|))
             (LETT |#G17| (QREFELT $ 7) . #0#)
             (SETELT $ 7 |#G16|)
             (LETT |n| |#G17| . #0#))
           (EXIT |n|))))) 

(DEFUN |GALFACT;eisensteinIrreducible?;UPB;11| (|f| $)
  (PROG (|c| |lc| |tc| |rf| |p| #0=#:G1908 #1=#:G1907)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |rf| (SPADCALL |f| (QREFELT $ 24))
                            . #2=(|GALFACT;eisensteinIrreducible?;UPB;11|))
                      (LETT |c| (SPADCALL |rf| (QREFELT $ 26)) . #2#)
                      (EXIT (COND
                              ((OR (ZEROP |c|)
                                   (SPADCALL |c| (QREFELT $ 27)))
                               'NIL)
                              ('T
                               (SEQ (LETT |lc|
                                     (SPADCALL |f| (QREFELT $ 28)) . #2#)
                                    (LETT |tc| |lc| . #2#)
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           ((SPADCALL |rf|
                                             (QREFELT $ 29))
                                            'NIL)
                                           ('T 'T)))
                                        #3=(GO G191)))
                                     (SEQ
                                      (LETT |tc|
                                       (SPADCALL |rf| (QREFELT $ 28)) . #2#)
                                      (EXIT
                                       (LETT |rf|
                                        (SPADCALL |rf| (QREFELT $ 24)) . #2#)))
                                     NIL #4=(GO G190) G191 (EXIT NIL))
                                    (SEQ (LETT |p| NIL . #2#)
                                     (LETT #0#
                                      (SPADCALL
                                       (SPADCALL |c| (QREFELT $ 31))
                                       (QREFELT $ 35)) . #2#)
                                     G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |p| (CAR #0#) . #2#)
                                           NIL))
                                        #3#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((EQL (QCDR |p|) 1)
                                          (COND
                                            ((NULL
                                              (ZEROP
                                               (REMAINDER2 |lc|
                                                (QCAR |p|))))
                                             (COND
                                               ((NULL
                                                 (ZEROP
                                                  (REMAINDER2 |tc|
                                                   (EXPT (QCAR |p|) 2))))
                                                (PROGN
                                                  (LETT #1# 'T . #2#)
                                                  (GO #1#))))))))))
                                     (LETT #0# (CDR #0#) . #2#) #4#
                                     G191 (EXIT NIL))
                                    (EXIT 'NIL)))))))
           #1# (EXIT #1#))))) 

(DEFUN |GALFACT;numberOfFactors;LNni;12| (|ddlist| $)
  (PROG (|dd| #0=#:G1917 |d| #1=#:G1910 |n|)
    (RETURN
      (SEQ (LETT |n| 0 . #2=(|GALFACT;numberOfFactors;LNni;12|))
           (LETT |d| 0 . #2#)
           (SEQ (LETT |dd| NIL . #2#) (LETT #0# |ddlist| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |dd| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |n|
                                 (+ |n|
                                    (COND
                                      ((ZEROP
                                        (LETT |d|
                                         (SPADCALL (QCAR |dd|)
                                          (QREFELT $ 38)) . #2#))
                                       1)
                                      ('T
                                       (PROG1
                                        (LETT #1#
                                         (QUOTIENT2 |d| (QCDR |dd|)) . #2#)
                                         (|check-subtype| (>= #1# 0)
                                          '(|NonNegativeInteger|) #1#))))) . #2#)))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (EXIT |n|))))) 

(DEFUN |GALFACT;shiftSet| (|s| |shift| $)
  (PROG (#0=#:G1920 |e| #1=#:G1921)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #2=(|GALFACT;shiftSet|))
                 (SEQ (LETT |e| NIL . #2#)
                      (LETT #1# (SPADCALL |s| (QREFELT $ 44)) . #2#)
                      G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |e| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS (+ |e| |shift|) #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 45)))))) 

(DEFUN |GALFACT;reductum| (|n| $)
  (- |n| (ASH 1 (- (INTEGER-LENGTH |n|) 1)))) 

(DEFUN |GALFACT;seed| (|level| $) (- (ASH 1 |level|) 1)) 

(DEFUN |GALFACT;nextRecNum| (|levels| |level| |n| $)
  (PROG (|l| #0=#:G1931 |lr| |b|)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |l| (INTEGER-LENGTH |n|)
                                 . #1=(|GALFACT;nextRecNum|))
                           (EXIT (COND
                                   ((< |l| |levels|)
                                    (PROGN
                                      (LETT #0#
                                       (CONS 1
                                        (+ |n| (ASH 1 (- |l| 1)))) . #1#)
                                      (GO #0#))))))
                      (EXIT (COND
                              ((EQL |n|
                                    (ASH (|GALFACT;seed| |level| $)
                                     (- |levels| |level|)))
                               (CONS 0 "End of level"))
                              ('T
                               (SEQ (LETT |b| 1 . #1#)
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (EQL (- |l| |b|)
                                          (LETT |lr|
                                           (INTEGER-LENGTH
                                            (LETT |n|
                                             (|GALFACT;reductum| |n| $) . #1#)) . #1#)))
                                        (GO G191)))
                                     (SEQ
                                      (EXIT (LETT |b| (+ |b| 1) . #1#)))
                                     NIL (GO G190) G191 (EXIT NIL))
                                    (EXIT
                                     (CONS 1
                                      (+ (|GALFACT;reductum| |n| $)
                                       (ASH
                                        (|GALFACT;seed| (+ |b| 1) $)
                                        |lr|))))))))))
           #0# (EXIT #0#))))) 

(DEFUN |GALFACT;fullSet| (|n| $)
  (PROG (#0=#:G1934 |i|)
    (RETURN
      (SEQ (SPADCALL
               (PROGN
                 (LETT #0# NIL . #1=(|GALFACT;fullSet|))
                 (SEQ (LETT |i| 0 . #1#) G190
                      (COND ((QSGREATERP |i| |n|) (GO G191)))
                      (SEQ (EXIT (LETT #0# (CONS |i| #0#) . #1#)))
                      (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               (QREFELT $ 45)))))) 

(DEFUN |GALFACT;modularFactor;UPR;18| (|p| $)
  (PROG (|n| |dirred| |diffp| |i| #0=#:G1958 |ddlist| |f| #1=#:G1959
             #2=#:G1942 |degfact| |j| #3=#:G1960 |s| |trials| |d|
             #4=#:G1957 |t| #5=#:G1961 |nf| |nfc| |choice| |cprime|)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (EQL (ABS (SPADCALL |p| (QREFELT $ 26))) 1))
                    (|error| "modularFactor: the polynomial is not primitive."))
                   ('T
                    (COND
                      ((ZEROP (LETT |n| (SPADCALL |p| (QREFELT $ 38))
                                    . #6=(|GALFACT;modularFactor;UPR;18|)))
                       (CONS 0 (LIST |p|)))
                      ('T
                       (SEQ (LETT |cprime| 2 . #6#)
                            (LETT |trials| NIL . #6#)
                            (LETT |d| (|GALFACT;fullSet| |n| $) . #6#)
                            (LETT |dirred|
                                  (SPADCALL (LIST 0 |n|)
                                      (QREFELT $ 45)) . #6#)
                            (LETT |s| (SPADCALL (QREFELT $ 48)) . #6#)
                            (LETT |ddlist| NIL . #6#)
                            (LETT |degfact| 0 . #6#)
                            (LETT |nf| (+ (QREFELT $ 8) 1) . #6#)
                            (LETT |diffp|
                                  (SPADCALL |p| (QREFELT $ 49)) . #6#)
                            (SEQ (LETT |i| 1 . #6#)
                                 (LETT #0# (QREFELT $ 7) . #6#) G190
                                 (COND
                                   ((QSGREATERP |i| #0#) #7=(GO G191)))
                                 (SEQ (EXIT
                                       (COND
                                         ((< (QREFELT $ 8) |nf|)
                                          (SEQ
                                           (SEQ G190
                                            (COND
                                              ((NULL
                                                (COND
                                                  ((OR
                                                    (ZEROP
                                                     (REMAINDER2
                                                      (SPADCALL |p|
                                                       (QREFELT $ 28))
                                                      |cprime|))
                                                    (NULL
                                                     (ZEROP
                                                      (SPADCALL
                                                       (SPADCALL |p|
                                                        |diffp|
                                                        |cprime|
                                                        (QREFELT $ 51))
                                                       (QREFELT $ 38)))))
                                                   'T)
                                                  ('T 'NIL)))
                                               #7#))
                                            (SEQ
                                             (EXIT
                                              (LETT |cprime|
                                               (SPADCALL |cprime|
                                                (QREFELT $ 53)) . #6#)))
                                            NIL #8=(GO G190) G191
                                            (EXIT NIL))
                                           (LETT |ddlist|
                                            (SPADCALL |p| |cprime|
                                             (QREFELT $ 54)) . #6#)
                                           (LETT |s|
                                            (SPADCALL (LIST 0)
                                             (QREFELT $ 45)) . #6#)
                                           (SEQ (LETT |f| NIL . #6#)
                                            (LETT #1# |ddlist| . #6#)
                                            G190
                                            (COND
                                              ((OR (ATOM #1#)
                                                (PROGN
                                                  (LETT |f|
                                                   (CAR #1#) . #6#)
                                                  NIL))
                                               #7#))
                                            (SEQ
                                             (LETT |degfact|
                                              (PROG1
                                               (LETT #2#
                                                (QCDR |f|) . #6#)
                                                (|check-subtype|
                                                 (>= #2# 0)
                                                 '(|NonNegativeInteger|)
                                                 #2#)) . #6#)
                                             (EXIT
                                              (COND
                                                ((NULL
                                                  (ZEROP |degfact|))
                                                 (SEQ
                                                  (LETT |j| 1 . #6#)
                                                  (LETT #3#
                                                   (QUOTIENT2
                                                    (SPADCALL
                                                     (QCAR |f|)
                                                     (QREFELT $ 38))
                                                    |degfact|) . #6#)
                                                  G190
                                                  (COND
                                                    ((QSGREATERP |j|
                                                      #3#)
                                                     #7#))
                                                  (SEQ
                                                   (EXIT
                                                    (LETT |s|
                                                     (SPADCALL |s|
                                                      (|GALFACT;shiftSet|
                                                       |s| |degfact| $)
                                                      (QREFELT $ 55)) . #6#)))
                                                  (LETT |j|
                                                   (QSADD1 |j|) . #6#)
                                                  #8# G191 (EXIT NIL))))))
                                            (LETT #1# (CDR #1#) . #6#)
                                            #8# G191 (EXIT NIL))
                                           (LETT |trials|
                                            (CONS
                                             (CONS |cprime| |ddlist|)
                                             |trials|) . #6#)
                                           (LETT |d|
                                            (SPADCALL |d| |s|
                                             (QREFELT $ 56)) . #6#)
                                           (EXIT
                                            (COND
                                              ((SPADCALL |d| |dirred|
                                                (QREFELT $ 57))
                                               (PROGN
                                                 (LETT #4#
                                                  (CONS 0 (LIST |p|)) . #6#)
                                                 (GO #4#)))
                                              ('T
                                               (SEQ
                                                (LETT |cprime|
                                                 (SPADCALL |cprime|
                                                  (QREFELT $ 53)) . #6#)
                                                (EXIT
                                                 (LETT |nf|
                                                  (SPADCALL |ddlist|
                                                   (QREFELT $ 41)) . #6#)))))))))))
                                 (LETT |i| (QSADD1 |i|) . #6#) #8# G191
                                 (EXIT NIL))
                            (LETT |choice|
                                  (|SPADfirst| |trials|) . #6#)
                            (LETT |nfc|
                                  (SPADCALL (QCDR |choice|)
                                      (QREFELT $ 41)) . #6#)
                            (SEQ (LETT |t| NIL . #6#)
                                 (LETT #5# (CDR |trials|) . #6#) G190
                                 (COND
                                   ((OR (ATOM #5#)
                                     (PROGN
                                       (LETT |t| (CAR #5#) . #6#)
                                       NIL))
                                    #7#))
                                 (SEQ (LETT |nf|
                                       (SPADCALL (QCDR |t|)
                                        (QREFELT $ 41)) . #6#)
                                      (EXIT
                                       (COND
                                         ((< |nf| |nfc|)
                                          (SEQ (LETT |nfc| |nf| . #6#)
                                           (EXIT
                                            (LETT |choice| |t| . #6#))))
                                         ((EQL |nf| |nfc|)
                                          (COND
                                            ((< (QCAR |choice|)
                                              (QCAR |t|))
                                             (SEQ
                                              (LETT |nfc| |nf| . #6#)
                                              (EXIT
                                               (LETT |choice|
                                                |t| . #6#)))))))))
                                 (LETT #5# (CDR #5#) . #6#) #8# G191
                                 (EXIT NIL))
                            (LETT |cprime| (QCAR |choice|) . #6#)
                            (EXIT (CONS |cprime|
                                        (SPADCALL (QCDR |choice|)
                                         |cprime| (QREFELT $ 59))))))))))
           #4# (EXIT #4#))))) 

(DEFUN |GALFACT;degreePartition;LM;19| (|ddlist| $)
  (PROG (|f| #0=#:G1969 |d| #1=#:G1963 |dd| |dp|)
    (RETURN
      (SEQ (LETT |dp| (SPADCALL (QREFELT $ 63))
                 . #2=(|GALFACT;degreePartition;LM;19|))
           (LETT |d| 0 . #2#) (LETT |dd| 0 . #2#)
           (SEQ (LETT |f| NIL . #2#) (LETT #0# |ddlist| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |f| (CAR #0#) . #2#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((ZEROP (LETT |d|
                                      (SPADCALL (QCAR |f|)
                                       (QREFELT $ 38)) . #2#))
                              (LETT |dp|
                                    (SPADCALL 0 |dp| (QREFELT $ 64)) . #2#))
                             ('T
                              (SEQ (LETT |dd|
                                    (PROG1 (LETT #1# (QCDR |f|) . #2#)
                                      (|check-subtype| (>= #1# 0)
                                       '(|NonNegativeInteger|) #1#)) . #2#)
                                   (EXIT
                                    (LETT |dp|
                                     (SPADCALL |dd| |dp|
                                      (QUOTIENT2 |d| |dd|)
                                      (QREFELT $ 65)) . #2#)))))))
                (LETT #0# (CDR #0#) . #2#) (GO G190) G191 (EXIT NIL))
           (EXIT |dp|))))) 

(DEFUN |GALFACT;henselfact| (|f| |pdecomp| $)
  (PROG (#0=#:G1989 |cf| |m| |cprime| #1=#:G1981 |b| |lrf| |g|
            #2=#:G1990 #3=#:G1986 #4=#:G1984 #5=#:G1985)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((SPADCALL |f| (QREFELT $ 68))
                         (PROGN
                           (LETT #0# (LIST |f|)
                                 . #6=(|GALFACT;henselfact|))
                           (GO #0#)))
                        ((QREFELT $ 11)
                         (COND
                           ((SPADCALL |f| (QREFELT $ 36))
                            (PROGN
                              (LETT #0# (LIST |f|) . #6#)
                              (GO #0#))))))
                      (COND
                        (|pdecomp|
                            (COND
                              ((QREFELT $ 10)
                               (LETT |cf|
                                     (SPADCALL |f| (QREFELT $ 72)) . #6#))
                              (#7='T
                               (LETT |cf| (CONS 1 "failed") . #6#))))
                        (#7# (LETT |cf| (CONS 1 "failed") . #6#)))
                      (EXIT (COND
                              ((QEQCAR |cf| 1)
                               (SEQ (LETT |m|
                                     (SPADCALL |f| (QREFELT $ 61)) . #6#)
                                    (EXIT
                                     (COND
                                       ((ZEROP
                                         (LETT |cprime|
                                          (QCAR |m|) . #6#))
                                        (QCDR |m|))
                                       ('T
                                        (SEQ
                                         (LETT |b|
                                          (PROG1
                                           (LETT #1#
                                            (*
                                             (SPADCALL 2
                                              (SPADCALL |f|
                                               (QREFELT $ 28))
                                              (QREFELT $ 73))
                                             (SPADCALL |f|
                                              (QREFELT $ 75))) . #6#)
                                            (|check-subtype| (> #1# 0)
                                             '(|PositiveInteger|) #1#)) . #6#)
                                         (EXIT
                                          (SPADCALL |f| (QCDR |m|)
                                           |cprime| |b| (QREFELT $ 77)))))))))
                              (#7#
                               (SEQ (LETT |lrf| (QCDR |cf|) . #6#)
                                    (EXIT
                                     (PROGN
                                       (LETT #5# NIL . #6#)
                                       (SEQ (LETT |g| NIL . #6#)
                                        (LETT #2#
                                         (|GALFACT;henselfact|
                                          (QCAR |lrf|) 'T $) . #6#)
                                        G190
                                        (COND
                                          ((OR (ATOM #2#)
                                            (PROGN
                                              (LETT |g|
                                               (CAR #2#) . #6#)
                                              NIL))
                                           (GO G191)))
                                        (SEQ
                                         (EXIT
                                          (PROGN
                                            (LETT #3#
                                             (|GALFACT;henselfact|
                                              (SPADCALL |g|
                                               (QCDR |lrf|)
                                               (QREFELT $ 78))
                                              'NIL $) . #6#)
                                            (COND
                                              (#5#
                                               (LETT #4#
                                                (APPEND #4# #3#) . #6#))
                                              ('T
                                               (PROGN
                                                 (LETT #4# #3# . #6#)
                                                 (LETT #5# 'T . #6#)))))))
                                        (LETT #2# (CDR #2#) . #6#)
                                        (GO G190) G191 (EXIT NIL))
                                       (COND (#5# #4#) (#7# NIL))))))))))
           #0# (EXIT #0#))))) 

(DEFUN |GALFACT;completeFactor| (|f| |lf| |cprime| |pk| |r| |d| $)
  (PROG (#0=#:G1926 |i| |degg| |g0| |g| |f1| |j| |nb| #1=#:G2009
            #2=#:G2010 |lc| |f0| |dg| #3=#:G2012 |rg| #4=#:G2013
            #5=#:G2015 #6=#:G2018 |gpk| |lg| #7=#:G2023 |degf|
            #8=#:G2024 |b| |llg| #9=#:G2025 |ltrue| #10=#:G2039 |ic|
            |levels| |found?| |level|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |lc| (SPADCALL |f| (QREFELT $ 28))
                            . #11=(|GALFACT;completeFactor|))
                      (LETT |f0|
                            (SPADCALL |f| 0 (QREFELT $ 79)) . #11#)
                      (LETT |ltrue| NIL . #11#)
                      (LETT |found?| 'T . #11#) (LETT |degf| 0 . #11#)
                      (LETT |degg| 0 . #11#) (LETT |g0| 0 . #11#)
                      (LETT |g| (|spadConstant| $ 47) . #11#)
                      (LETT |rg| 0 . #11#) (LETT |nb| 0 . #11#)
                      (LETT |lg| NIL . #11#) (LETT |b| 1 . #11#)
                      (LETT |dg| (SPADCALL (QREFELT $ 48)) . #11#)
                      (LETT |llg| (CONS NIL 0) . #11#)
                      (LETT |levels| (LENGTH |lf|) . #11#)
                      (LETT |level| 1 . #11#)
                      (LETT |ic| (CONS 1 0) . #11#) (LETT |i| 0 . #11#)
                      (SEQ G190
                           (COND
                             ((NULL (< |level| |levels|))
                              #12=(GO G191)))
                           (SEQ (LETT |ic|
                                      (CONS 1
                                       (|GALFACT;seed| |level| $)) . #11#)
                                (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           (|found?| 'NIL)
                                           ('T (QEQCAR |ic| 1))))
                                        #12#))
                                     (SEQ
                                      (LETT |i|
                                       (PROG2 (LETT #0# |ic| . #11#)
                                        (QCDR #0#)
                                         (|check-union| (QEQCAR #0# 1)
                                          (|Integer|) #0#)) . #11#)
                                      (LETT |degg| 0 . #11#)
                                      (LETT |g0| 1 . #11#)
                                      (SEQ (LETT |j| 1 . #11#) G190
                                       (COND
                                         ((QSGREATERP |j| |levels|)
                                          #12#))
                                       (SEQ
                                        (EXIT
                                         (COND
                                           ((SPADCALL |i| (- |j| 1)
                                             (QREFELT $ 80))
                                            (SEQ
                                             (LETT |degg|
                                              (+ |degg|
                                               (SPADCALL
                                                (SPADCALL |lf| |j|
                                                 (QREFELT $ 81))
                                                (QREFELT $ 38))) . #11#)
                                             (EXIT
                                              (LETT |g0|
                                               (* |g0|
                                                (SPADCALL
                                                 (SPADCALL |lf| |j|
                                                  (QREFELT $ 81))
                                                 0 (QREFELT $ 79))) . #11#)))))))
                                       (LETT |j| (QSADD1 |j|) . #11#)
                                       #13=(GO G190) G191 (EXIT NIL))
                                      (LETT |g0|
                                       (SPADCALL (* |lc| |g0|) |pk|
                                        (QREFELT $ 82)) . #11#)
                                      (COND
                                        ((SPADCALL |degg| |d|
                                          (QREFELT $ 83))
                                         (COND
                                           ((QEQCAR
                                             (SPADCALL (* |lc| |f0|)
                                              |g0| (QREFELT $ 85))
                                             0)
                                            (SEQ
                                             (LETT |g|
                                              (SPADCALL |lc|
                                               (QREFELT $ 86)) . #11#)
                                             (SEQ (LETT |j| 1 . #11#)
                                              G190
                                              (COND
                                                ((QSGREATERP |j|
                                                  |levels|)
                                                 #12#))
                                              (SEQ
                                               (EXIT
                                                (COND
                                                  ((SPADCALL |i|
                                                    (- |j| 1)
                                                    (QREFELT $ 80))
                                                   (LETT |g|
                                                    (SPADCALL |g|
                                                     (SPADCALL |lf| |j|
                                                      (QREFELT $ 81))
                                                     (QREFELT $ 87)) . #11#)))))
                                              (LETT |j|
                                               (QSADD1 |j|) . #11#)
                                              #13# G191 (EXIT NIL))
                                             (LETT |g|
                                              (SPADCALL
                                               (SPADCALL |g| |pk|
                                                (QREFELT $ 88))
                                               (QREFELT $ 89)) . #11#)
                                             (LETT |f1|
                                              (SPADCALL |f| |g|
                                               (QREFELT $ 90)) . #11#)
                                             (EXIT
                                              (COND
                                                ((QEQCAR |f1| 0)
                                                 (SEQ
                                                  (LETT |found?|
                                                   'T . #11#)
                                                  (LETT |nb| 1 . #11#)
                                                  (SEQ
                                                   (LETT |j| 1 . #11#)
                                                   G190
                                                   (COND
                                                     ((QSGREATERP |j|
                                                       |levels|)
                                                      #12#))
                                                   (SEQ
                                                    (EXIT
                                                     (COND
                                                       ((SPADCALL |i|
                                                         (- |j| 1)
                                                         (QREFELT $ 80))
                                                        (SEQ
                                                         (SPADCALL |lf|
                                                          |j| |nb|
                                                          (QREFELT $
                                                           92))
                                                         (EXIT
                                                          (LETT |nb|
                                                           (+ |nb| 1) . #11#)))))))
                                                   (LETT |j|
                                                    (QSADD1 |j|) . #11#)
                                                   #13# G191
                                                   (EXIT NIL))
                                                  (LETT |lg|
                                                   |lf| . #11#)
                                                  (LETT |lf|
                                                   (SPADCALL |lf|
                                                    (PROG1
                                                     (LETT #1#
                                                      |level| . #11#)
                                                      (|check-subtype|
                                                       (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                                    (QREFELT $ 93)) . #11#)
                                                  (SPADCALL
                                                   (SPADCALL |lg|
                                                    (PROG1
                                                     (LETT #2#
                                                      (- |level| 1) . #11#)
                                                      (|check-subtype|
                                                       (>= #2# 0)
                                                       '(|NonNegativeInteger|)
                                                       #2#))
                                                    (QREFELT $ 93))
                                                   NIL (QREFELT $ 94))
                                                  (LETT |f|
                                                   (QCDR |f1|) . #11#)
                                                  (LETT |lc|
                                                   (SPADCALL |f|
                                                    (QREFELT $ 28)) . #11#)
                                                  (LETT |f0|
                                                   (SPADCALL |f| 0
                                                    (QREFELT $ 79)) . #11#)
                                                  (LETT |dg|
                                                   (SPADCALL
                                                    (CONS
                                                     #'|GALFACT;completeFactor!0|
                                                     (VECTOR $ |degg|))
                                                    |d| (QREFELT $ 99)) . #11#)
                                                  (COND
                                                    ((SPADCALL |dg|
                                                      (SPADCALL
                                                       (LIST 0 |degg|)
                                                       (QREFELT $ 45))
                                                      (QREFELT $ 57))
                                                     (LETT |lg|
                                                      (LIST |g|) . #11#))
                                                    ('T
                                                     (SEQ
                                                      (LETT |rg|
                                                       (PROG1
                                                        (LETT #3#
                                                         (MAX 2
                                                          (-
                                                           (+ |r|
                                                            |level|)
                                                           |levels|)) . #11#)
                                                         (|check-subtype|
                                                          (>= #3# 0)
                                                          '(|NonNegativeInteger|)
                                                          #3#)) . #11#)
                                                      (LETT |b|
                                                       (PROG1
                                                        (LETT #4#
                                                         (*
                                                          (SPADCALL 2
                                                           (SPADCALL
                                                            |g|
                                                            (QREFELT $
                                                             28))
                                                           (QREFELT $
                                                            73))
                                                          (SPADCALL |g|
                                                           |rg|
                                                           (QREFELT $
                                                            100))) . #11#)
                                                         (|check-subtype|
                                                          (> #4# 0)
                                                          '(|PositiveInteger|)
                                                          #4#)) . #11#)
                                                      (EXIT
                                                       (COND
                                                         ((< |pk| |b|)
                                                          (COND
                                                            ((SPADCALL
                                                              |g|
                                                              (QREFELT
                                                               $ 68))
                                                             (LETT |lg|
                                                              (LIST
                                                               |g|) . #11#))
                                                            ((QREFELT $
                                                              11)
                                                             (COND
                                                               ((SPADCALL
                                                                 |g|
                                                                 (QREFELT
                                                                  $ 36))
                                                                (LETT
                                                                 |lg|
                                                                 (LIST
                                                                  |g|) . #11#))
                                                               ('T
                                                                (SEQ
                                                                 (LETT
                                                                  |llg|
                                                                  (SPADCALL
                                                                   |g|
                                                                   |lg|
                                                                   |cprime|
                                                                   |b|
                                                                   (QREFELT
                                                                    $
                                                                    102)) . #11#)
                                                                 (LETT
                                                                  |gpk|
                                                                  (PROG1
                                                                   (LETT
                                                                    #5#
                                                                    (QCDR
                                                                     |llg|) . #11#)
                                                                    (|check-subtype|
                                                                     (>
                                                                      #5#
                                                                      0)
                                                                     '(|PositiveInteger|)
                                                                     #5#)) . #11#)
                                                                 (EXIT
                                                                  (COND
                                                                    ((<
                                                                      |gpk|
                                                                      |b|)
                                                                     (LETT
                                                                      |lg|
                                                                      (QCAR
                                                                       |llg|) . #11#))
                                                                    ('T
                                                                     (LETT
                                                                      |lg|
                                                                      (|GALFACT;completeFactor|
                                                                       |g|
                                                                       (QCAR
                                                                        |llg|)
                                                                       |cprime|
                                                                       |gpk|
                                                                       |rg|
                                                                       |dg|
                                                                       $) . #11#))))))))
                                                            ('T
                                                             (SEQ
                                                              (LETT
                                                               |llg|
                                                               (SPADCALL
                                                                |g|
                                                                |lg|
                                                                |cprime|
                                                                |b|
                                                                (QREFELT
                                                                 $ 102)) . #11#)
                                                              (LETT
                                                               |gpk|
                                                               (PROG1
                                                                (LETT
                                                                 #6#
                                                                 (QCDR
                                                                  |llg|) . #11#)
                                                                 (|check-subtype|
                                                                  (>
                                                                   #6#
                                                                   0)
                                                                  '(|PositiveInteger|)
                                                                  #6#)) . #11#)
                                                              (EXIT
                                                               (COND
                                                                 ((<
                                                                   |gpk|
                                                                   |b|)
                                                                  (LETT
                                                                   |lg|
                                                                   (QCAR
                                                                    |llg|) . #11#))
                                                                 ('T
                                                                  (LETT
                                                                   |lg|
                                                                   (|GALFACT;completeFactor|
                                                                    |g|
                                                                    (QCAR
                                                                     |llg|)
                                                                    |cprime|
                                                                    |gpk|
                                                                    |rg|
                                                                    |dg|
                                                                    $) . #11#))))))))
                                                         ('T
                                                          (LETT |lg|
                                                           (LIST |g|) . #11#)))))))
                                                  (LETT |ltrue|
                                                   (APPEND |ltrue|
                                                    |lg|) . #11#)
                                                  (LETT |r|
                                                   (PROG1
                                                    (LETT #7#
                                                     (MAX 2
                                                      (- |r|
                                                       (LENGTH |lg|))) . #11#)
                                                     (|check-subtype|
                                                      (>= #7# 0)
                                                      '(|NonNegativeInteger|)
                                                      #7#)) . #11#)
                                                  (LETT |degf|
                                                   (SPADCALL |f|
                                                    (QREFELT $ 38)) . #11#)
                                                  (LETT |d|
                                                   (SPADCALL
                                                    (CONS
                                                     #'|GALFACT;completeFactor!1|
                                                     (VECTOR $ |degf|))
                                                    |d| (QREFELT $ 99)) . #11#)
                                                  (EXIT
                                                   (COND
                                                     ((< 1 |degf|)
                                                      (SEQ
                                                       (LETT |b|
                                                        (PROG1
                                                         (LETT #8#
                                                          (*
                                                           (SPADCALL 2
                                                            |lc|
                                                            (QREFELT $
                                                             73))
                                                           (SPADCALL
                                                            |f| |r|
                                                            (QREFELT $
                                                             100))) . #11#)
                                                          (|check-subtype|
                                                           (> #8# 0)
                                                           '(|PositiveInteger|)
                                                           #8#)) . #11#)
                                                       (EXIT
                                                        (COND
                                                          ((< |pk| |b|)
                                                           (SEQ
                                                            (LETT |llg|
                                                             (SPADCALL
                                                              |f| |lf|
                                                              |cprime|
                                                              |b|
                                                              (QREFELT
                                                               $ 102)) . #11#)
                                                            (LETT |lf|
                                                             (QCAR
                                                              |llg|) . #11#)
                                                            (LETT |pk|
                                                             (PROG1
                                                              (LETT #9#
                                                               (QCDR
                                                                |llg|) . #11#)
                                                               (|check-subtype|
                                                                (> #9#
                                                                 0)
                                                                '(|PositiveInteger|)
                                                                #9#)) . #11#)
                                                            (COND
                                                              ((< |pk|
                                                                |b|)
                                                               (PROGN
                                                                 (LETT
                                                                  #10#
                                                                  (APPEND
                                                                   |lf|
                                                                   |ltrue|) . #11#)
                                                                 (GO
                                                                  #10#))))
                                                            (EXIT
                                                             (LETT
                                                              |level|
                                                              1 . #11#))))))))
                                                     ('T
                                                      (SEQ
                                                       (COND
                                                         ((EQL |degf|
                                                           1)
                                                          (LETT |ltrue|
                                                           (CONS |f|
                                                            |ltrue|) . #11#)))
                                                       (EXIT
                                                        (PROGN
                                                          (LETT #10#
                                                           |ltrue| . #11#)
                                                          (GO #10#))))))))))))))))
                                      (EXIT
                                       (LETT |ic|
                                        (|GALFACT;nextRecNum| |levels|
                                         |level| |i| $) . #11#)))
                                     NIL #13# G191 (EXIT NIL))
                                (COND
                                  (|found?|
                                      (SEQ
                                       (LETT |levels|
                                        (LENGTH |lf|) . #11#)
                                       (EXIT
                                        (LETT |found?| 'NIL . #11#)))))
                                (EXIT (COND
                                        ((NULL (QEQCAR |ic| 1))
                                         (LETT |level|
                                          (+ |level| 1) . #11#)))))
                           NIL #13# G191 (EXIT NIL))
                      (EXIT (CONS |f| |ltrue|))))
           #10# (EXIT #10#))))) 

(DEFUN |GALFACT;completeFactor!1| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;completeFactor|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;completeFactor!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;completeFactor|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;divideSet| (|s| |n| $)
  (PROG (|e| #0=#:G2047 |ee| |l|)
    (RETURN
      (SEQ (LETT |l| (LIST 0) . #1=(|GALFACT;divideSet|))
           (SEQ (LETT |e| NIL . #1#)
                (LETT #0# (SPADCALL |s| (QREFELT $ 44)) . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |e| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (LETT |ee|
                           (SPADCALL |e| |n| (QREFELT $ 103)) . #1#)
                     (EXIT (COND
                             ((QEQCAR |ee| 0)
                              (LETT |l| (CONS (QCDR |ee|) |l|) . #1#)))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |l| (QREFELT $ 45))))))) 

(DEFUN |GALFACT;btwFactor| (|f| |d| |r| |pdecomp| $)
  (PROG (|reverse?| |negativelc?| |cf| |m| |cprime| #0=#:G2080 |lc|
            |f0| #1=#:G2061 |b| |lm| #2=#:G2063 |pk| |lrf| |dh| |lg|
            #3=#:G2081 |g| |dgh| #4=#:G2068 |df| #5=#:G2070 |lfg|
            #6=#:G2071 #7=#:G2082 |fact| #8=#:G2083 |lf| |i|
            #9=#:G2084)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |df| (SPADCALL |f| (QREFELT $ 38))
                            . #10=(|GALFACT;btwFactor|))
                      (COND
                        ((NULL (EQL (SPADCALL |d| (QREFELT $ 104))
                                    |df|))
                         (EXIT (|error| "btwFact: Bad arguments"))))
                      (LETT |reverse?| 'NIL . #10#)
                      (LETT |negativelc?| 'NIL . #10#)
                      (EXIT (COND
                              ((SPADCALL |d|
                                   (SPADCALL (LIST 0 |df|)
                                    (QREFELT $ 45))
                                   (QREFELT $ 57))
                               (LIST |f|))
                              ('T
                               (SEQ (COND
                                      ((<
                                        (ABS
                                         (SPADCALL |f| 0
                                          (QREFELT $ 79)))
                                        (ABS
                                         (SPADCALL |f| (QREFELT $ 28))))
                                       (SEQ
                                        (LETT |f|
                                         (SPADCALL |f| (QREFELT $ 106)) . #10#)
                                        (EXIT
                                         (LETT |reverse?| 'T . #10#)))))
                                    (COND
                                      ((SPADCALL |f| (QREFELT $ 68))
                                       (EXIT
                                        (COND
                                          (|reverse?|
                                           (LIST
                                            (SPADCALL |f|
                                             (QREFELT $ 106))))
                                          ('T (LIST |f|)))))
                                      ((QREFELT $ 11)
                                       (COND
                                         ((SPADCALL |f| (QREFELT $ 36))
                                          (EXIT
                                           (COND
                                             (|reverse?|
                                              (LIST
                                               (SPADCALL |f|
                                                (QREFELT $ 106))))
                                             ('T (LIST |f|))))))))
                                    (COND
                                      ((< (SPADCALL |f| (QREFELT $ 28))
                                        0)
                                       (SEQ
                                        (LETT |f|
                                         (SPADCALL |f| (QREFELT $ 107)) . #10#)
                                        (EXIT
                                         (LETT |negativelc?| 'T . #10#)))))
                                    (COND
                                      (|pdecomp|
                                       (COND
                                         ((QREFELT $ 10)
                                          (LETT |cf|
                                           (SPADCALL |f|
                                            (QREFELT $ 72)) . #10#))
                                         ('T
                                          (LETT |cf|
                                           (CONS 1 "failed") . #10#))))
                                      ('T
                                       (LETT |cf|
                                        (CONS 1 "failed") . #10#)))
                                    (COND
                                      ((QEQCAR |cf| 1)
                                       (SEQ
                                        (LETT |m|
                                         (SPADCALL |f| (QREFELT $ 61)) . #10#)
                                        (EXIT
                                         (COND
                                           ((ZEROP
                                             (LETT |cprime|
                                              (QCAR |m|) . #10#))
                                            (COND
                                              (|reverse?|
                                               (COND
                                                 (|negativelc?|
                                                  (PROGN
                                                    (LETT #0#
                                                     (LIST
                                                      (SPADCALL
                                                       (SPADCALL |f|
                                                        (QREFELT $ 106))
                                                       (QREFELT $ 107))) . #10#)
                                                    (GO #0#)))
                                                 ('T
                                                  (PROGN
                                                    (LETT #0#
                                                     (LIST
                                                      (SPADCALL |f|
                                                       (QREFELT $ 106))) . #10#)
                                                    (GO #0#)))))
                                              (|negativelc?|
                                               (PROGN
                                                 (LETT #0#
                                                  (LIST
                                                   (SPADCALL |f|
                                                    (QREFELT $ 107))) . #10#)
                                                 (GO #0#)))
                                              ('T
                                               (PROGN
                                                 (LETT #0#
                                                  (LIST |f|) . #10#)
                                                 (GO #0#)))))
                                           ('T
                                            (SEQ
                                             (COND
                                               ((SPADCALL |f|
                                                 (QREFELT $ 108))
                                                (LETT |d|
                                                 (SPADCALL 1 |d|
                                                  (QREFELT $ 110)) . #10#)))
                                             (LETT |lc|
                                              (SPADCALL |f|
                                               (QREFELT $ 28)) . #10#)
                                             (LETT |f0|
                                              (SPADCALL |f| 0
                                               (QREFELT $ 79)) . #10#)
                                             (LETT |b|
                                              (PROG1
                                               (LETT #1#
                                                (*
                                                 (SPADCALL 2 |lc|
                                                  (QREFELT $ 73))
                                                 (SPADCALL |f| |r|
                                                  (QREFELT $ 100))) . #10#)
                                                (|check-subtype|
                                                 (> #1# 0)
                                                 '(|PositiveInteger|)
                                                 #1#)) . #10#)
                                             (LETT |lm|
                                              (SPADCALL |f| (QCDR |m|)
                                               |cprime| |b|
                                               (QREFELT $ 102)) . #10#)
                                             (LETT |lf|
                                              (QCAR |lm|) . #10#)
                                             (LETT |pk|
                                              (PROG1
                                               (LETT #2#
                                                (QCDR |lm|) . #10#)
                                                (|check-subtype|
                                                 (> #2# 0)
                                                 '(|PositiveInteger|)
                                                 #2#)) . #10#)
                                             (COND
                                               ((SPADCALL
                                                 (|SPADfirst| |lf|)
                                                 (QREFELT $ 111))
                                                (LETT |lf|
                                                 (CDR |lf|) . #10#)))
                                             (EXIT
                                              (COND
                                                ((NULL (< |pk| |b|))
                                                 (LETT |lf|
                                                  (|GALFACT;completeFactor|
                                                   |f| |lf| |cprime|
                                                   |pk| |r| |d| $) . #10#))))))))))
                                      ('T
                                       (SEQ
                                        (LETT |lrf| (QCDR |cf|) . #10#)
                                        (LETT |dh|
                                         (SPADCALL (QCDR |lrf|)
                                          (QREFELT $ 38)) . #10#)
                                        (LETT |lg|
                                         (|GALFACT;btwFactor|
                                          (QCAR |lrf|)
                                          (|GALFACT;divideSet| |d| |dh|
                                           $)
                                          2 'T $) . #10#)
                                        (LETT |lf| NIL . #10#)
                                        (EXIT
                                         (SEQ (LETT |i| 1 . #10#)
                                          (LETT #3#
                                           (LENGTH |lg|) . #10#)
                                          G190
                                          (COND
                                            ((QSGREATERP |i| #3#)
                                             #11=(GO G191)))
                                          (SEQ
                                           (LETT |g|
                                            (SPADCALL |lg| |i|
                                             (QREFELT $ 81)) . #10#)
                                           (LETT |dgh|
                                            (*
                                             (SPADCALL |g|
                                              (QREFELT $ 38))
                                             |dh|) . #10#)
                                           (LETT |df|
                                            (PROG2
                                             (LETT #4#
                                              (SPADCALL |df| |dgh|
                                               (QREFELT $ 112)) . #10#)
                                             (QCDR #4#)
                                              (|check-union|
                                               (QEQCAR #4# 0)
                                               (|NonNegativeInteger|)
                                               #4#)) . #10#)
                                           (LETT |lfg|
                                            (|GALFACT;btwFactor|
                                             (SPADCALL |g| (QCDR |lrf|)
                                              (QREFELT $ 78))
                                             (SPADCALL
                                              (CONS
                                               #'|GALFACT;btwFactor!0|
                                               (VECTOR $ |dgh|))
                                              |d| (QREFELT $ 99))
                                             (PROG1
                                              (LETT #5#
                                               (MAX 2 (- |r| |df|)) . #10#)
                                               (|check-subtype|
                                                (>= #5# 0)
                                                '(|NonNegativeInteger|)
                                                #5#))
                                             'NIL $) . #10#)
                                           (LETT |lf|
                                            (APPEND |lf| |lfg|) . #10#)
                                           (EXIT
                                            (LETT |r|
                                             (PROG1
                                              (LETT #6#
                                               (MAX 2
                                                (- |r| (LENGTH |lfg|))) . #10#)
                                               (|check-subtype|
                                                (>= #6# 0)
                                                '(|NonNegativeInteger|)
                                                #6#)) . #10#)))
                                          (LETT |i|
                                           (QSADD1 |i|) . #10#)
                                          #12=(GO G190) G191
                                          (EXIT NIL))))))
                                    (COND
                                      (|reverse?|
                                       (LETT |lf|
                                        (PROGN
                                          (LETT #7# NIL . #10#)
                                          (SEQ (LETT |fact| NIL . #10#)
                                           (LETT #8# |lf| . #10#) G190
                                           (COND
                                             ((OR (ATOM #8#)
                                               (PROGN
                                                 (LETT |fact|
                                                  (CAR #8#) . #10#)
                                                 NIL))
                                              #11#))
                                           (SEQ
                                            (EXIT
                                             (LETT #7#
                                              (CONS
                                               (SPADCALL |fact|
                                                (QREFELT $ 106))
                                               #7#) . #10#)))
                                           (LETT #8# (CDR #8#) . #10#)
                                           #12# G191
                                           (EXIT (NREVERSE0 #7#)))) . #10#)))
                                    (SEQ (LETT |i| 1 . #10#)
                                     (LETT #9# (LENGTH |lf|) . #10#)
                                     G190
                                     (COND
                                       ((QSGREATERP |i| #9#) #11#))
                                     (SEQ
                                      (EXIT
                                       (COND
                                         ((<
                                           (SPADCALL
                                            (SPADCALL |lf| |i|
                                             (QREFELT $ 81))
                                            (QREFELT $ 28))
                                           0)
                                          (SPADCALL |lf| |i|
                                           (SPADCALL
                                            (SPADCALL |lf| |i|
                                             (QREFELT $ 81))
                                            (QREFELT $ 107))
                                           (QREFELT $ 113))))))
                                     (LETT |i| (QSADD1 |i|) . #10#)
                                     #12# G191 (EXIT NIL))
                                    (EXIT |lf|)))))))
           #0# (EXIT #0#))))) 

(DEFUN |GALFACT;btwFactor!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFactor|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;makeFR;RF;24| (|flist| $)
  (PROG (|ctp| |ff| #0=#:G2109 |fc| #1=#:G2110 |fflist|)
    (RETURN
      (SEQ (LETT |ctp| (SPADCALL (QCAR |flist|) (QREFELT $ 31))
                 . #2=(|GALFACT;makeFR;RF;24|))
           (LETT |fflist| NIL . #2#)
           (SEQ (LETT |ff| NIL . #2#) (LETT #0# (QCDR |flist|) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |ff| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (EXIT (LETT |fflist|
                                 (CONS (VECTOR (CONS 3 "prime")
                                        (QCAR |ff|) (QCDR |ff|))
                                       |fflist|) . #2#)))
                (LETT #0# (CDR #0#) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (SEQ (LETT |fc| NIL . #2#)
                (LETT #1# (SPADCALL |ctp| (QREFELT $ 117)) . #2#) G190
                (COND
                  ((OR (ATOM #1#)
                       (PROGN (LETT |fc| (CAR #1#) . #2#) NIL))
                   #3#))
                (SEQ (EXIT (LETT |fflist|
                                 (CONS (VECTOR (QVELT |fc| 0)
                                        (SPADCALL (QVELT |fc| 1)
                                         (QREFELT $ 86))
                                        (QVELT |fc| 2))
                                       |fflist|) . #2#)))
                (LETT #1# (CDR #1#) . #2#) #4# G191 (EXIT NIL))
           (EXIT (SPADCALL
                     (SPADCALL (SPADCALL |ctp| (QREFELT $ 118))
                         (QREFELT $ 86))
                     |fflist| (QREFELT $ 122))))))) 

(DEFUN |GALFACT;quadratic| (|p| $)
  (PROG (|r| |d| |a| |b| |f| #0=#:G2119)
    (RETURN
      (SEQ (LETT |a| (SPADCALL |p| (QREFELT $ 28))
                 . #1=(|GALFACT;quadratic|))
           (LETT |b| (SPADCALL |p| 1 (QREFELT $ 79)) . #1#)
           (LETT |d|
                 (- (SPADCALL |b| 2 (QREFELT $ 126))
                    (* (SPADCALL 4 |a| (QREFELT $ 73))
                       (SPADCALL |p| 0 (QREFELT $ 79)))) . #1#)
           (LETT |r| (SPADCALL |d| (QREFELT $ 129)) . #1#)
           (EXIT (COND
                   ((QEQCAR |r| 1) (LIST |p|))
                   ('T
                    (SEQ (LETT |b| (+ |b| (QCDR |r|)) . #1#)
                         (LETT |a|
                               (SPADCALL 2 |a| (QREFELT $ 73)) . #1#)
                         (LETT |d| (GCD |a| |b|) . #1#)
                         (COND
                           ((NULL (EQL |d| 1))
                            (SEQ (LETT |a| (QUOTIENT2 |a| |d|) . #1#)
                                 (EXIT (LETT |b|
                                        (QUOTIENT2 |b| |d|) . #1#)))))
                         (LETT |f|
                               (SPADCALL
                                   (SPADCALL |a| 1 (QREFELT $ 130))
                                   (SPADCALL |b| 0 (QREFELT $ 130))
                                   (QREFELT $ 131)) . #1#)
                         (EXIT (CONS |f|
                                     (LIST
                                      (PROG2
                                       (LETT #0#
                                        (SPADCALL |p| |f|
                                         (QREFELT $ 90)) . #1#)
                                       (QCDR #0#)
                                        (|check-union| (QEQCAR #0# 0)
                                         (QREFELT $ 6) #0#))))))))))))) 

(DEFUN |GALFACT;isPowerOf2| (|n| $)
  (PROG (|qr|)
    (RETURN
      (SEQ (COND
             ((EQL |n| 1) 'T)
             ('T
              (SEQ (LETT |qr| (DIVIDE2 |n| 2) |GALFACT;isPowerOf2|)
                   (EXIT (COND
                           ((EQL (QCDR |qr|) 1) 'NIL)
                           ('T (|GALFACT;isPowerOf2| (QCAR |qr|) $))))))))))) 

(DEFUN |GALFACT;subMinusX| (|supPol| $)
  (PROG (|minusX|)
    (RETURN
      (SEQ (LETT |minusX| (SPADCALL -1 1 (QREFELT $ 133))
                 |GALFACT;subMinusX|)
           (EXIT (SPADCALL (SPADCALL |supPol| |minusX| (QREFELT $ 134))
                     (QREFELT $ 135))))))) 

(DEFUN |GALFACT;henselFact;UPBR;28| (|f| |sqf| $)
  (PROG (#0=#:G2132 |c| |lcPol| #1=#:G2165 |sfac| #2=#:G2166 |fac|
            #3=#:G2167 #4=#:G2168 |sqfflist| |sqfr| #5=#:G2169 |mult|
            |sqff| |d| #6=#:G2170 #7=#:G2171 #8=#:G2172 |pf| #9=#:G2173
            |factorlist|)
    (RETURN
      (SEQ (LETT |factorlist| NIL . #10=(|GALFACT;henselFact;UPBR;28|))
           (LETT |c| (SPADCALL |f| (QREFELT $ 26)) . #10#)
           (LETT |f|
                 (PROG2 (LETT #0#
                              (SPADCALL |f| |c| (QREFELT $ 136)) . #10#)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#)) . #10#)
           (COND
             ((< (SPADCALL |f| (QREFELT $ 28)) 0)
              (SEQ (LETT |c| (- |c|) . #10#)
                   (EXIT (LETT |f|
                               (SPADCALL |f| (QREFELT $ 107)) . #10#)))))
           (SEQ (LETT |d| (SPADCALL |f| (QREFELT $ 137)) . #10#)
                (EXIT (COND
                        ((< 0 |d|)
                         (SEQ (LETT |f|
                                    (QCAR
                                     (SPADCALL |f|
                                      (SPADCALL 1 |d| (QREFELT $ 130))
                                      (QREFELT $ 139))) . #10#)
                              (EXIT (LETT |factorlist|
                                     (LIST
                                      (CONS
                                       (SPADCALL 1 1 (QREFELT $ 130))
                                       |d|)) . #10#)))))))
           (LETT |d| (SPADCALL |f| (QREFELT $ 38)) . #10#)
           (EXIT (COND
                   ((ZEROP |d|) (CONS |c| |factorlist|))
                   ((EQL |d| 1)
                    (CONS |c| (CONS (CONS |f| 1) |factorlist|)))
                   ('T
                    (SEQ (LETT |lcPol|
                               (SPADCALL (SPADCALL |f| (QREFELT $ 28))
                                   (QREFELT $ 86)) . #10#)
                         (EXIT (COND
                                 ((SPADCALL
                                      (SPADCALL |lcPol|
                                       (QREFELT $ 107))
                                      (SPADCALL |f| (QREFELT $ 24))
                                      (QREFELT $ 140))
                                  (SEQ (SEQ (LETT |fac| NIL . #10#)
                                        (LETT #1#
                                         (SPADCALL
                                          (CONS
                                           #'|GALFACT;henselFact;UPBR;28!0|
                                           $)
                                          (SPADCALL |d|
                                           (QREFELT $ 143))
                                          (QREFELT $ 146)) . #10#)
                                        G190
                                        (COND
                                          ((OR (ATOM #1#)
                                            (PROGN
                                              (LETT |fac|
                                               (CAR #1#) . #10#)
                                              NIL))
                                           #11=(GO G191)))
                                        (SEQ
                                         (EXIT
                                          (LETT |factorlist|
                                           (CONS (CONS |fac| 1)
                                            |factorlist|) . #10#)))
                                        (LETT #1# (CDR #1#) . #10#)
                                        #12=(GO G190) G191 (EXIT NIL))
                                       (EXIT (CONS |c| |factorlist|))))
                                 ('T
                                  (SEQ (COND
                                         ((ODDP |d|)
                                          (COND
                                            ((SPADCALL |lcPol|
                                              (SPADCALL |f|
                                               (QREFELT $ 24))
                                              (QREFELT $ 140))
                                             (EXIT
                                              (SEQ
                                               (SEQ
                                                (LETT |sfac|
                                                 NIL . #10#)
                                                (LETT #2#
                                                 (SPADCALL |d|
                                                  (QREFELT $ 143)) . #10#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #2#)
                                                    (PROGN
                                                      (LETT |sfac|
                                                       (CAR #2#) . #10#)
                                                      NIL))
                                                   #11#))
                                                (SEQ
                                                 (LETT |fac|
                                                  (|GALFACT;subMinusX|
                                                   |sfac| $) . #10#)
                                                 (COND
                                                   ((<
                                                     (SPADCALL |fac|
                                                      (QREFELT $ 28))
                                                     0)
                                                    (LETT |fac|
                                                     (SPADCALL |fac|
                                                      (QREFELT $ 107)) . #10#)))
                                                 (EXIT
                                                  (LETT |factorlist|
                                                   (CONS (CONS |fac| 1)
                                                    |factorlist|) . #10#)))
                                                (LETT #2#
                                                 (CDR #2#) . #10#)
                                                #12# G191 (EXIT NIL))
                                               (EXIT
                                                (CONS |c| |factorlist|))))))))
                                       (COND
                                         ((|GALFACT;isPowerOf2| |d| $)
                                          (COND
                                            ((SPADCALL |lcPol|
                                              (SPADCALL |f|
                                               (QREFELT $ 24))
                                              (QREFELT $ 140))
                                             (EXIT
                                              (SEQ
                                               (LETT |factorlist|
                                                (CONS (CONS |f| 1)
                                                 |factorlist|) . #10#)
                                               (EXIT
                                                (CONS |c| |factorlist|))))))))
                                       (EXIT
                                        (COND
                                          (|sqf|
                                           (CONS |c|
                                            (APPEND
                                             (PROGN
                                               (LETT #3# NIL . #10#)
                                               (SEQ
                                                (LETT |pf| NIL . #10#)
                                                (LETT #4#
                                                 (|GALFACT;henselfact|
                                                  |f| 'T $) . #10#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #4#)
                                                    (PROGN
                                                      (LETT |pf|
                                                       (CAR #4#) . #10#)
                                                      NIL))
                                                   #11#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #3#
                                                   (CONS (CONS |pf| 1)
                                                    #3#) . #10#)))
                                                (LETT #4#
                                                 (CDR #4#) . #10#)
                                                #12# G191
                                                (EXIT (NREVERSE0 #3#))))
                                             |factorlist|)))
                                          ('T
                                           (SEQ
                                            (LETT |sqfflist|
                                             (SPADCALL
                                              (SPADCALL |f|
                                               (QREFELT $ 147))
                                              (QREFELT $ 150)) . #10#)
                                            (SEQ
                                             (LETT |sqfr| NIL . #10#)
                                             (LETT #5#
                                              |sqfflist| . #10#)
                                             G190
                                             (COND
                                               ((OR (ATOM #5#)
                                                 (PROGN
                                                   (LETT |sqfr|
                                                    (CAR #5#) . #10#)
                                                   NIL))
                                                #11#))
                                             (SEQ
                                              (LETT |mult|
                                               (QCDR |sqfr|) . #10#)
                                              (LETT |sqff|
                                               (QCAR |sqfr|) . #10#)
                                              (LETT |d|
                                               (SPADCALL |sqff|
                                                (QREFELT $ 38)) . #10#)
                                              (EXIT
                                               (COND
                                                 ((EQL |d| 1)
                                                  (LETT |factorlist|
                                                   (CONS
                                                    (CONS |sqff|
                                                     |mult|)
                                                    |factorlist|) . #10#))
                                                 ((EQL |d| 2)
                                                  (LETT |factorlist|
                                                   (APPEND
                                                    (PROGN
                                                      (LETT #6#
                                                       NIL . #10#)
                                                      (SEQ
                                                       (LETT |pf|
                                                        NIL . #10#)
                                                       (LETT #7#
                                                        (|GALFACT;quadratic|
                                                         |sqff| $) . #10#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #7#)
                                                           (PROGN
                                                             (LETT |pf|
                                                              (CAR #7#) . #10#)
                                                             NIL))
                                                          #11#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT #6#
                                                          (CONS
                                                           (CONS |pf|
                                                            |mult|)
                                                           #6#) . #10#)))
                                                       (LETT #7#
                                                        (CDR #7#) . #10#)
                                                       #12# G191
                                                       (EXIT
                                                        (NREVERSE0 #6#))))
                                                    |factorlist|) . #10#))
                                                 ('T
                                                  (LETT |factorlist|
                                                   (APPEND
                                                    (PROGN
                                                      (LETT #8#
                                                       NIL . #10#)
                                                      (SEQ
                                                       (LETT |pf|
                                                        NIL . #10#)
                                                       (LETT #9#
                                                        (|GALFACT;henselfact|
                                                         |sqff| 'T $) . #10#)
                                                       G190
                                                       (COND
                                                         ((OR
                                                           (ATOM #9#)
                                                           (PROGN
                                                             (LETT |pf|
                                                              (CAR #9#) . #10#)
                                                             NIL))
                                                          #11#))
                                                       (SEQ
                                                        (EXIT
                                                         (LETT #8#
                                                          (CONS
                                                           (CONS |pf|
                                                            |mult|)
                                                           #8#) . #10#)))
                                                       (LETT #9#
                                                        (CDR #9#) . #10#)
                                                       #12# G191
                                                       (EXIT
                                                        (NREVERSE0 #8#))))
                                                    |factorlist|) . #10#)))))
                                             (LETT #5#
                                              (CDR #5#) . #10#)
                                             #12# G191 (EXIT NIL))
                                            (EXIT
                                             (CONS |c| |factorlist|)))))))))))))))))) 

(DEFUN |GALFACT;henselFact;UPBR;28!0| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 135))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29| (|f| |sqf| |fd| |r| $)
  (PROG (#0=#:G2178 |c| #1=#:G2183 #2=#:G2185 |lcPol| #3=#:G2220 |sfac|
            #4=#:G2221 |fac| #5=#:G2222 #6=#:G2223 |sqfflist|
            #7=#:G2203 |sqfr| #8=#:G2224 |mult| |sqff| |d| #9=#:G2205
            #10=#:G2225 #11=#:G2226 #12=#:G2208 #13=#:G2227 |pf|
            #14=#:G2228 |factorlist| #15=#:G2211 |maxd|)
    (RETURN
      (SEQ (LETT |d| (SPADCALL |f| (QREFELT $ 38))
                 . #16=(|GALFACT;btwFact;UPBSNniR;29|))
           (COND
             ((NULL (EQL (SPADCALL |fd| (QREFELT $ 104)) |d|))
              (EXIT (|error| "btwFact: Bad arguments"))))
           (LETT |factorlist| NIL . #16#)
           (LETT |c| (SPADCALL |f| (QREFELT $ 26)) . #16#)
           (LETT |f|
                 (PROG2 (LETT #0#
                              (SPADCALL |f| |c| (QREFELT $ 136)) . #16#)
                        (QCDR #0#)
                   (|check-union| (QEQCAR #0# 0) (QREFELT $ 6) #0#)) . #16#)
           (COND
             ((< (SPADCALL |f| (QREFELT $ 28)) 0)
              (SEQ (LETT |c| (- |c|) . #16#)
                   (EXIT (LETT |f|
                               (SPADCALL |f| (QREFELT $ 107)) . #16#)))))
           (SEQ (LETT |maxd| (SPADCALL |f| (QREFELT $ 137)) . #16#)
                (EXIT (COND
                        ((< 0 |maxd|)
                         (SEQ (LETT |f|
                                    (QCAR
                                     (SPADCALL |f|
                                      (SPADCALL 1 |maxd|
                                       (QREFELT $ 130))
                                      (QREFELT $ 139))) . #16#)
                              (LETT |factorlist|
                                    (LIST
                                     (CONS
                                      (SPADCALL 1 1 (QREFELT $ 130))
                                      |maxd|)) . #16#)
                              (LETT |r|
                                    (PROG1
                                     (LETT #1#
                                      (MAX 2 (- |r| |maxd|)) . #16#)
                                      (|check-subtype| (>= #1# 0)
                                       '(|NonNegativeInteger|) #1#)) . #16#)
                              (LETT |d|
                                    (PROG2
                                     (LETT #2#
                                      (SPADCALL |d| |maxd|
                                       (QREFELT $ 112)) . #16#)
                                     (QCDR #2#)
                                      (|check-union| (QEQCAR #2# 0)
                                       (|NonNegativeInteger|) #2#)) . #16#)
                              (EXIT (LETT |fd|
                                     (SPADCALL
                                      (CONS
                                       #'|GALFACT;btwFact;UPBSNniR;29!0|
                                       (VECTOR $ |d|))
                                      |fd| (QREFELT $ 99)) . #16#)))))))
           (EXIT (COND
                   ((ZEROP |d|) (CONS |c| |factorlist|))
                   ((EQL |d| 1)
                    (CONS |c| (CONS (CONS |f| 1) |factorlist|)))
                   ('T
                    (SEQ (LETT |lcPol|
                               (SPADCALL (SPADCALL |f| (QREFELT $ 28))
                                   (QREFELT $ 86)) . #16#)
                         (EXIT (COND
                                 ((SPADCALL
                                      (SPADCALL |lcPol|
                                       (QREFELT $ 107))
                                      (SPADCALL |f| (QREFELT $ 24))
                                      (QREFELT $ 140))
                                  (SEQ (SEQ (LETT |fac| NIL . #16#)
                                        (LETT #3#
                                         (SPADCALL
                                          (CONS
                                           #'|GALFACT;btwFact;UPBSNniR;29!1|
                                           $)
                                          (SPADCALL |d|
                                           (QREFELT $ 143))
                                          (QREFELT $ 146)) . #16#)
                                        G190
                                        (COND
                                          ((OR (ATOM #3#)
                                            (PROGN
                                              (LETT |fac|
                                               (CAR #3#) . #16#)
                                              NIL))
                                           #17=(GO G191)))
                                        (SEQ
                                         (EXIT
                                          (LETT |factorlist|
                                           (CONS (CONS |fac| 1)
                                            |factorlist|) . #16#)))
                                        (LETT #3# (CDR #3#) . #16#)
                                        #18=(GO G190) G191 (EXIT NIL))
                                       (EXIT (CONS |c| |factorlist|))))
                                 ('T
                                  (SEQ (COND
                                         ((ODDP |d|)
                                          (COND
                                            ((SPADCALL |lcPol|
                                              (SPADCALL |f|
                                               (QREFELT $ 24))
                                              (QREFELT $ 140))
                                             (EXIT
                                              (SEQ
                                               (SEQ
                                                (LETT |sfac|
                                                 NIL . #16#)
                                                (LETT #4#
                                                 (SPADCALL |d|
                                                  (QREFELT $ 143)) . #16#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #4#)
                                                    (PROGN
                                                      (LETT |sfac|
                                                       (CAR #4#) . #16#)
                                                      NIL))
                                                   #17#))
                                                (SEQ
                                                 (LETT |fac|
                                                  (|GALFACT;subMinusX|
                                                   |sfac| $) . #16#)
                                                 (COND
                                                   ((<
                                                     (SPADCALL |fac|
                                                      (QREFELT $ 28))
                                                     0)
                                                    (LETT |fac|
                                                     (SPADCALL |fac|
                                                      (QREFELT $ 107)) . #16#)))
                                                 (EXIT
                                                  (LETT |factorlist|
                                                   (CONS (CONS |fac| 1)
                                                    |factorlist|) . #16#)))
                                                (LETT #4#
                                                 (CDR #4#) . #16#)
                                                #18# G191 (EXIT NIL))
                                               (EXIT
                                                (CONS |c| |factorlist|))))))))
                                       (COND
                                         ((|GALFACT;isPowerOf2| |d| $)
                                          (COND
                                            ((SPADCALL |lcPol|
                                              (SPADCALL |f|
                                               (QREFELT $ 24))
                                              (QREFELT $ 140))
                                             (EXIT
                                              (SEQ
                                               (LETT |factorlist|
                                                (CONS (CONS |f| 1)
                                                 |factorlist|) . #16#)
                                               (EXIT
                                                (CONS |c| |factorlist|))))))))
                                       (EXIT
                                        (COND
                                          (|sqf|
                                           (CONS |c|
                                            (APPEND
                                             (PROGN
                                               (LETT #5# NIL . #16#)
                                               (SEQ
                                                (LETT |pf| NIL . #16#)
                                                (LETT #6#
                                                 (|GALFACT;btwFactor|
                                                  |f| |fd| |r| 'T $) . #16#)
                                                G190
                                                (COND
                                                  ((OR (ATOM #6#)
                                                    (PROGN
                                                      (LETT |pf|
                                                       (CAR #6#) . #16#)
                                                      NIL))
                                                   #17#))
                                                (SEQ
                                                 (EXIT
                                                  (LETT #5#
                                                   (CONS (CONS |pf| 1)
                                                    #5#) . #16#)))
                                                (LETT #6#
                                                 (CDR #6#) . #16#)
                                                #18# G191
                                                (EXIT (NREVERSE0 #5#))))
                                             |factorlist|)))
                                          ('T
                                           (SEQ
                                            (LETT |sqfflist|
                                             (SPADCALL
                                              (SPADCALL |f|
                                               (QREFELT $ 147))
                                              (QREFELT $ 150)) . #16#)
                                            (COND
                                              ((EQL (LENGTH |sqfflist|)
                                                1)
                                               (LETT |r|
                                                (PROG1
                                                 (LETT #7#
                                                  (MAX
                                                   (QUOTIENT2 |r|
                                                    (QCDR
                                                     (|SPADfirst|
                                                      |sqfflist|)))
                                                   2) . #16#)
                                                  (|check-subtype|
                                                   (>= #7# 0)
                                                   '(|NonNegativeInteger|)
                                                   #7#)) . #16#))
                                              ('T (LETT |r| 2 . #16#)))
                                            (SEQ
                                             (LETT |sqfr| NIL . #16#)
                                             (LETT #8#
                                              |sqfflist| . #16#)
                                             G190
                                             (COND
                                               ((OR (ATOM #8#)
                                                 (PROGN
                                                   (LETT |sqfr|
                                                    (CAR #8#) . #16#)
                                                   NIL))
                                                #17#))
                                             (SEQ
                                              (LETT |mult|
                                               (QCDR |sqfr|) . #16#)
                                              (LETT |sqff|
                                               (QCAR |sqfr|) . #16#)
                                              (LETT |d|
                                               (SPADCALL |sqff|
                                                (QREFELT $ 38)) . #16#)
                                              (EXIT
                                               (COND
                                                 ((EQL |d| 1)
                                                  (SEQ
                                                   (LETT |factorlist|
                                                    (CONS
                                                     (CONS |sqff|
                                                      |mult|)
                                                     |factorlist|) . #16#)
                                                   (LETT |maxd|
                                                    (PROG1
                                                     (LETT #9#
                                                      (-
                                                       (SPADCALL |fd|
                                                        (QREFELT $ 104))
                                                       |mult|) . #16#)
                                                      (|check-subtype|
                                                       (>= #9# 0)
                                                       '(|NonNegativeInteger|)
                                                       #9#)) . #16#)
                                                   (EXIT
                                                    (LETT |fd|
                                                     (SPADCALL
                                                      (CONS
                                                       #'|GALFACT;btwFact;UPBSNniR;29!2|
                                                       (VECTOR $
                                                        |maxd|))
                                                      |fd|
                                                      (QREFELT $ 99)) . #16#))))
                                                 ((EQL |d| 2)
                                                  (SEQ
                                                   (LETT |factorlist|
                                                    (APPEND
                                                     (PROGN
                                                       (LETT #10#
                                                        NIL . #16#)
                                                       (SEQ
                                                        (LETT |pf|
                                                         NIL . #16#)
                                                        (LETT #11#
                                                         (|GALFACT;quadratic|
                                                          |sqff| $) . #16#)
                                                        G190
                                                        (COND
                                                          ((OR
                                                            (ATOM #11#)
                                                            (PROGN
                                                              (LETT
                                                               |pf|
                                                               (CAR
                                                                #11#) . #16#)
                                                              NIL))
                                                           #17#))
                                                        (SEQ
                                                         (EXIT
                                                          (LETT #10#
                                                           (CONS
                                                            (CONS |pf|
                                                             |mult|)
                                                            #10#) . #16#)))
                                                        (LETT #11#
                                                         (CDR #11#) . #16#)
                                                        #18# G191
                                                        (EXIT
                                                         (NREVERSE0
                                                          #10#))))
                                                     |factorlist|) . #16#)
                                                   (LETT |maxd|
                                                    (PROG1
                                                     (LETT #12#
                                                      (-
                                                       (SPADCALL |fd|
                                                        (QREFELT $ 104))
                                                       (SPADCALL 2
                                                        |mult|
                                                        (QREFELT $ 73))) . #16#)
                                                      (|check-subtype|
                                                       (>= #12# 0)
                                                       '(|NonNegativeInteger|)
                                                       #12#)) . #16#)
                                                   (EXIT
                                                    (LETT |fd|
                                                     (SPADCALL
                                                      (CONS
                                                       #'|GALFACT;btwFact;UPBSNniR;29!3|
                                                       (VECTOR $
                                                        |maxd|))
                                                      |fd|
                                                      (QREFELT $ 99)) . #16#))))
                                                 ('T
                                                  (SEQ
                                                   (LETT |factorlist|
                                                    (APPEND
                                                     (PROGN
                                                       (LETT #13#
                                                        NIL . #16#)
                                                       (SEQ
                                                        (LETT |pf|
                                                         NIL . #16#)
                                                        (LETT #14#
                                                         (|GALFACT;btwFactor|
                                                          |sqff|
                                                          (SPADCALL
                                                           (CONS
                                                            #'|GALFACT;btwFact;UPBSNniR;29!4|
                                                            (VECTOR $
                                                             |d|))
                                                           |fd|
                                                           (QREFELT $
                                                            99))
                                                          |r| 'T $) . #16#)
                                                        G190
                                                        (COND
                                                          ((OR
                                                            (ATOM #14#)
                                                            (PROGN
                                                              (LETT
                                                               |pf|
                                                               (CAR
                                                                #14#) . #16#)
                                                              NIL))
                                                           #17#))
                                                        (SEQ
                                                         (EXIT
                                                          (LETT #13#
                                                           (CONS
                                                            (CONS |pf|
                                                             |mult|)
                                                            #13#) . #16#)))
                                                        (LETT #14#
                                                         (CDR #14#) . #16#)
                                                        #18# G191
                                                        (EXIT
                                                         (NREVERSE0
                                                          #13#))))
                                                     |factorlist|) . #16#)
                                                   (LETT |maxd|
                                                    (PROG1
                                                     (LETT #15#
                                                      (-
                                                       (SPADCALL |fd|
                                                        (QREFELT $ 104))
                                                       (SPADCALL |d|
                                                        |mult|
                                                        (QREFELT $ 152))) . #16#)
                                                      (|check-subtype|
                                                       (>= #15# 0)
                                                       '(|NonNegativeInteger|)
                                                       #15#)) . #16#)
                                                   (EXIT
                                                    (LETT |fd|
                                                     (SPADCALL
                                                      (CONS
                                                       #'|GALFACT;btwFact;UPBSNniR;29!5|
                                                       (VECTOR $
                                                        |maxd|))
                                                      |fd|
                                                      (QREFELT $ 99)) . #16#)))))))
                                             (LETT #8#
                                              (CDR #8#) . #16#)
                                             #18# G191 (EXIT NIL))
                                            (EXIT
                                             (CONS |c| |factorlist|)))))))))))))))))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!5| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFact;UPBSNniR;29|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!4| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFact;UPBSNniR;29|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!3| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFact;UPBSNniR;29|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!2| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFact;UPBSNniR;29|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!1| (|#1| $)
  (SPADCALL |#1| (QREFELT $ 135))) 

(DEFUN |GALFACT;btwFact;UPBSNniR;29!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |GALFACT;btwFact;UPBSNniR;29|)
    (RETURN
      (PROGN
        (COND
          ((SPADCALL (QREFELT $$ 1) |#1| (QREFELT $ 95))
           (|spadConstant| $ 96))
          ('T (|spadConstant| $ 97))))))) 

(DEFUN |GALFACT;factor;UPF;30| (|f| $)
  (SPADCALL (COND
              ((QREFELT $ 9)
               (SPADCALL |f| 'NIL
                   (|GALFACT;fullSet| (SPADCALL |f| (QREFELT $ 38)) $)
                   2 (QREFELT $ 153)))
              ('T (SPADCALL |f| 'NIL (QREFELT $ 151))))
            (QREFELT $ 125))) 

(DEFUN |GALFACT;errorsum?| (|d| |ld| $)
  (PROG (#0=#:G1815 #1=#:G2236 #2=#:G2233 #3=#:G2231 #4=#:G2232)
    (RETURN
      (SEQ (COND
             ((EQL |d|
                   (PROGN
                     (LETT #4# NIL . #5=(|GALFACT;errorsum?|))
                     (SEQ (LETT #0# NIL . #5#) (LETT #1# |ld| . #5#)
                          G190
                          (COND
                            ((OR (ATOM #1#)
                                 (PROGN
                                   (LETT #0# (CAR #1#) . #5#)
                                   NIL))
                             (GO G191)))
                          (SEQ (EXIT (PROGN
                                       (LETT #2# #0# . #5#)
                                       (COND
                                         (#4#
                                          (LETT #3# (+ #3# #2#) . #5#))
                                         ('T
                                          (PROGN
                                            (LETT #3# #2# . #5#)
                                            (LETT #4# 'T . #5#)))))))
                          (LETT #1# (CDR #1#) . #5#) (GO G190) G191
                          (EXIT NIL))
                     (COND (#4# #3#) ('T 0))))
              'NIL)
             ('T 'T)))))) 

(DEFUN |GALFACT;makeSet| (|ld| $)
  (PROG (|d| #0=#:G2240 |s|)
    (RETURN
      (SEQ (LETT |s| (SPADCALL (LIST 0) (QREFELT $ 45))
                 . #1=(|GALFACT;makeSet|))
           (SEQ (LETT |d| NIL . #1#) (LETT #0# |ld| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |d| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |s|
                                 (SPADCALL |s|
                                     (|GALFACT;shiftSet| |s| |d| $)
                                     (QREFELT $ 55)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |s|))))) 

(DEFUN |GALFACT;factor;UPLNniF;33| (|f| |ld| |r| $)
  (COND
    ((|GALFACT;errorsum?| (SPADCALL |f| (QREFELT $ 38)) |ld| $)
     (|error| "factor: Bad arguments"))
    ('T
     (SPADCALL
         (SPADCALL |f| 'NIL (|GALFACT;makeSet| |ld| $) |r|
             (QREFELT $ 153))
         (QREFELT $ 125))))) 

(DEFUN |GALFACT;factor;UPNniF;34| (|f| |r| $)
  (SPADCALL
      (SPADCALL |f| 'NIL
          (|GALFACT;fullSet| (SPADCALL |f| (QREFELT $ 38)) $) |r|
          (QREFELT $ 153))
      (QREFELT $ 125))) 

(DEFUN |GALFACT;factor;UPLF;35| (|f| |ld| $)
  (SPADCALL |f| |ld| 2 (QREFELT $ 155))) 

(DEFUN |GALFACT;factor;UP2NniF;36| (|f| |d| |r| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n|
                 (SPADCALL (SPADCALL |f| (QREFELT $ 38)) |d|
                     (QREFELT $ 103))
                 |GALFACT;factor;UP2NniF;36|)
           (EXIT (COND
                   ((QEQCAR |n| 1) (|error| "factor: Bad arguments"))
                   ('T
                    (SPADCALL |f|
                        (SPADCALL (QCDR |n|) |d| (QREFELT $ 158)) |r|
                        (QREFELT $ 155))))))))) 

(DEFUN |GALFACT;factorSquareFree;UPF;37| (|f| $)
  (SPADCALL
      (COND
        ((QREFELT $ 9)
         (SPADCALL |f| 'T
             (|GALFACT;fullSet| (SPADCALL |f| (QREFELT $ 38)) $) 2
             (QREFELT $ 153)))
        ('T (SPADCALL |f| 'T (QREFELT $ 151))))
      (QREFELT $ 125))) 

(DEFUN |GALFACT;factorSquareFree;UPLNniF;38| (|f| |ld| |r| $)
  (COND
    ((|GALFACT;errorsum?| (SPADCALL |f| (QREFELT $ 38)) |ld| $)
     (|error| "factorSquareFree: Bad arguments"))
    ('T
     (SPADCALL
         (SPADCALL |f| 'T (|GALFACT;makeSet| |ld| $) |r|
             (QREFELT $ 153))
         (QREFELT $ 125))))) 

(DEFUN |GALFACT;factorSquareFree;UPNniF;39| (|f| |r| $)
  (SPADCALL
      (SPADCALL |f| 'T
          (|GALFACT;fullSet| (SPADCALL |f| (QREFELT $ 38)) $) |r|
          (QREFELT $ 153))
      (QREFELT $ 125))) 

(DEFUN |GALFACT;factorSquareFree;UPLF;40| (|f| |ld| $)
  (SPADCALL |f| |ld| 2 (QREFELT $ 161))) 

(DEFUN |GALFACT;factorSquareFree;UP2NniF;41| (|f| |d| |r| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n|
                 (SPADCALL (SPADCALL |f| (QREFELT $ 38)) |d|
                     (QREFELT $ 103))
                 |GALFACT;factorSquareFree;UP2NniF;41|)
           (EXIT (COND
                   ((QEQCAR |n| 1)
                    (|error| "factorSquareFree: Bad arguments"))
                   ('T
                    (SPADCALL |f|
                        (SPADCALL (QCDR |n|) |d| (QREFELT $ 158)) |r|
                        (QREFELT $ 161))))))))) 

(DEFUN |GALFACT;factorOfDegree;PiUPLNniBU;42|
       (|d| |p| |ld| |r| |sqf| $)
  (PROG (|dp| |lf| |f| #0=#:G2279 #1=#:G2278 #2=#:G2272)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |dp| (SPADCALL |p| (QREFELT $ 38))
                            . #3=(|GALFACT;factorOfDegree;PiUPLNniBU;42|))
                      (EXIT (COND
                              ((|GALFACT;errorsum?| |dp| |ld| $)
                               (|error| "factorOfDegree: Bad arguments"))
                              ('T
                               (SEQ (COND
                                      ((EQL |d| 1)
                                       (COND
                                         ((SPADCALL |p|
                                           (QREFELT $ 108))
                                          (EXIT (CONS 1 "failed"))))))
                                    (LETT |lf|
                                     (QCDR
                                      (SPADCALL |p| |sqf|
                                       (|GALFACT;makeSet| |ld| $) |r|
                                       (QREFELT $ 153))) . #3#)
                                    (SEQ
                                     (EXIT
                                      (SEQ (LETT |f| NIL . #3#)
                                       (LETT #0# |lf| . #3#) G190
                                       (COND
                                         ((OR (ATOM #0#)
                                           (PROGN
                                             (LETT |f| (CAR #0#) . #3#)
                                             NIL))
                                          (GO G191)))
                                       (SEQ
                                        (EXIT
                                         (COND
                                           ((EQL
                                             (SPADCALL (QCAR |f|)
                                              (QREFELT $ 38))
                                             |d|)
                                            (PROGN
                                              (LETT #2#
                                               (PROGN
                                                 (LETT #1#
                                                  (CONS 0 (QCAR |f|)) . #3#)
                                                 (GO #1#)) . #3#)
                                              (GO #2#))))))
                                       (LETT #0# (CDR #0#) . #3#)
                                       (GO G190) G191 (EXIT NIL)))
                                     #2# (EXIT #2#))
                                    (EXIT (CONS 1 "failed"))))))))
           #1# (EXIT #1#))))) 

(DEFUN |GALFACT;factorOfDegree;PiUPLNniU;43| (|d| |p| |ld| |r| $)
  (SPADCALL |d| |p| |ld| |r| 'NIL (QREFELT $ 166))) 

(DEFUN |GALFACT;factorOfDegree;PiUPNniU;44| (|d| |p| |r| $)
  (SPADCALL |d| |p|
      (SPADCALL (SPADCALL |p| (QREFELT $ 38)) 1 (QREFELT $ 158)) |r|
      'NIL (QREFELT $ 166))) 

(DEFUN |GALFACT;factorOfDegree;PiUPLU;45| (|d| |p| |ld| $)
  (SPADCALL |d| |p| |ld| 2 'NIL (QREFELT $ 166))) 

(DEFUN |GALFACT;factorOfDegree;PiUPU;46| (|d| |p| $)
  (SPADCALL |d| |p|
      (SPADCALL (SPADCALL |p| (QREFELT $ 38)) 1 (QREFELT $ 158)) 2 'NIL
      (QREFELT $ 166))) 

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

(DEFUN |GaloisGroupFactorizer;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|GaloisGroupFactorizer|))
        (LETT |dv$| (LIST '|GaloisGroupFactorizer| DV$1) . #0#)
        (LETT $ (GETREFV 171) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|GaloisGroupFactorizer|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 5)
        (QSETREFV $ 8 8)
        (QSETREFV $ 9 'T)
        (QSETREFV $ 10 'T)
        (QSETREFV $ 11 'T)
        $)))) 

(MAKEPROP '|GaloisGroupFactorizer| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|mussertrials|
             '|stopmussertrials| '|usesinglefactorbound|
             '|tryfunctionaldecomposition| '|useeisensteincriterion|
             (|Boolean|) |GALFACT;useEisensteinCriterion?;B;1|
             |GALFACT;useEisensteinCriterion;2B;2|
             |GALFACT;tryFunctionalDecomposition?;B;3|
             |GALFACT;tryFunctionalDecomposition;2B;4|
             |GALFACT;useSingleFactorBound?;B;5|
             |GALFACT;useSingleFactorBound;2B;6| (|PositiveInteger|)
             |GALFACT;stopMusserTrials;Pi;7|
             |GALFACT;stopMusserTrials;2Pi;8|
             |GALFACT;musserTrials;Pi;9| |GALFACT;musserTrials;2Pi;10|
             (0 . |reductum|) (|Integer|) (5 . |content|)
             (10 . |unit?|) (15 . |leadingCoefficient|) (20 . |zero?|)
             (|Factored| $) (25 . |factor|)
             (|Record| (|:| |factor| 25) (|:| |exponent| 25))
             (|List| 32) (|Factored| 25) (30 . |factors|)
             |GALFACT;eisensteinIrreducible?;UPB;11|
             (|NonNegativeInteger|) (35 . |degree|)
             (|Record| (|:| |factor| 6) (|:| |degree| 25)) (|List| 39)
             |GALFACT;numberOfFactors;LNni;12| (|List| 37) (|Set| 37)
             (40 . |parts|) (45 . |set|) (50 . |One|) (54 . |Zero|)
             (58 . |empty|) (62 . |differentiate|)
             (|ModularDistinctDegreeFactorizer| 6) (67 . |gcd|)
             (|IntegerPrimesPackage| 25) (74 . |nextPrime|)
             (79 . |ddFact|) (85 . |union|) (91 . |intersect|) (97 . =)
             (|List| 6) (103 . |separateFactors|)
             (|Record| (|:| |prime| 25) (|:| |factors| 58))
             |GALFACT;modularFactor;UPR;18| (|Multiset| 37)
             (109 . |empty|) (113 . |insert!|) (119 . |insert!|)
             |GALFACT;degreePartition;LM;19| (|BrillhartTests| 6)
             (126 . |brillhartIrreducible?|)
             (|Record| (|:| |left| 6) (|:| |right| 6))
             (|Union| 69 '"failed")
             (|UnivariatePolynomialDecompositionPackage| 25 6)
             (131 . |monicDecomposeIfCan|) (136 . *)
             (|GaloisGroupFactorizationUtilities| 25 6 (|Float|))
             (142 . |beauzamyBound|) (|GeneralHenselPackage| 25 6)
             (147 . |completeHensel|) (155 . |elt|)
             (161 . |coefficient|) (167 . |bit?|) (173 . |elt|)
             (179 . |symmetricRemainder|) (185 . |member?|)
             (|Union| $ '"failed") (191 . |exquo|) (197 . |coerce|)
             (202 . *) (208 . |reduction|) (214 . |primitivePart|)
             (219 . |exquo|) (|Void|) (225 . |swap!|) (232 . |rest|)
             (238 . |setrest!|) (244 . <) (250 . |false|)
             (254 . |true|) (|Mapping| 12 37) (258 . |select|)
             (264 . |singleFactorBound|)
             (|Record| (|:| |plist| 58) (|:| |modulo| 25))
             (270 . |HenselLift|) (278 . |exquo|) (284 . |max|)
             (|GaloisGroupPolynomialUtilities| 25 6) (289 . |reverse|)
             (294 . -) (299 . |noLinearFactor?|) (304 . |One|)
             (308 . |remove|) (314 . |ground?|) (319 . |subtractIfCan|)
             (325 . |setelt|)
             (|Union| '"nil" '"sqfr" '"irred" '"prime")
             (|Record| (|:| |flg| 114) (|:| |fctr| 25) (|:| |xpnt| 25))
             (|List| 115) (332 . |factorList|) (337 . |unit|)
             (|Record| (|:| |flg| 114) (|:| |fctr| 6) (|:| |xpnt| 25))
             (|List| 119) (|Factored| 6) (342 . |makeFR|)
             (|Record| (|:| |irr| 6) (|:| |pow| 25))
             (|Record| (|:| |contp| 25) (|:| |factors| (|List| 123)))
             |GALFACT;makeFR;RF;24| (348 . **) (|Union| 25 '"failed")
             (|IntegerRoots| 25) (354 . |perfectSqrt|)
             (359 . |monomial|) (365 . +)
             (|SparseUnivariatePolynomial| 25) (371 . |monomial|)
             (377 . |elt|) (383 . |unmakeSUP|) (388 . |exquo|)
             (394 . |minimumDegree|)
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (399 . |monicDivide|) (405 . =) (|List| 132)
             (|CyclotomicPolynomialPackage|)
             (411 . |cyclotomicDecomposition|) (|Mapping| 6 132)
             (|ListFunctions2| 132 6) (416 . |map|)
             (422 . |squareFree|)
             (|Record| (|:| |factor| 6) (|:| |exponent| 25))
             (|List| 148) (427 . |factors|)
             |GALFACT;henselFact;UPBR;28| (432 . *)
             |GALFACT;btwFact;UPBSNniR;29| |GALFACT;factor;UPF;30|
             |GALFACT;factor;UPLNniF;33| |GALFACT;factor;UPNniF;34|
             |GALFACT;factor;UPLF;35| (438 . |new|)
             |GALFACT;factor;UP2NniF;36|
             |GALFACT;factorSquareFree;UPF;37|
             |GALFACT;factorSquareFree;UPLNniF;38|
             |GALFACT;factorSquareFree;UPNniF;39|
             |GALFACT;factorSquareFree;UPLF;40|
             |GALFACT;factorSquareFree;UP2NniF;41|
             (|Union| 6 '"failed")
             |GALFACT;factorOfDegree;PiUPLNniBU;42|
             |GALFACT;factorOfDegree;PiUPLNniU;43|
             |GALFACT;factorOfDegree;PiUPNniU;44|
             |GALFACT;factorOfDegree;PiUPLU;45|
             |GALFACT;factorOfDegree;PiUPU;46|)
          '#(|useSingleFactorBound?| 444 |useSingleFactorBound| 448
             |useEisensteinCriterion?| 453 |useEisensteinCriterion| 457
             |tryFunctionalDecomposition?| 462
             |tryFunctionalDecomposition| 466 |stopMusserTrials| 471
             |numberOfFactors| 480 |musserTrials| 485 |modularFactor|
             494 |makeFR| 499 |henselFact| 504 |factorSquareFree| 510
             |factorOfDegree| 541 |factor| 578 |eisensteinIrreducible?|
             609 |degreePartition| 614 |btwFact| 619)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 170
                                '(1 6 0 0 24 1 6 25 0 26 1 25 12 0 27 1
                                  6 25 0 28 1 6 12 0 29 1 25 30 0 31 1
                                  34 33 0 35 1 6 37 0 38 1 43 42 0 44 1
                                  43 0 42 45 0 6 0 46 0 6 0 47 0 43 0
                                  48 1 6 0 0 49 3 50 6 6 6 25 51 1 52
                                  25 25 53 2 50 40 6 25 54 2 43 0 0 0
                                  55 2 43 0 0 0 56 2 43 12 0 0 57 2 50
                                  58 40 25 59 0 62 0 63 2 62 0 37 0 64
                                  3 62 0 37 0 37 65 1 67 12 6 68 1 71
                                  70 6 72 2 25 0 19 0 73 1 74 25 6 75 4
                                  76 58 6 58 25 19 77 2 6 0 0 0 78 2 6
                                  25 0 37 79 2 25 12 0 0 80 2 58 6 0 25
                                  81 2 25 0 0 0 82 2 43 12 37 0 83 2 25
                                  84 0 0 85 1 6 0 25 86 2 6 0 0 0 87 2
                                  76 6 6 25 88 1 6 0 0 89 2 6 84 0 0 90
                                  3 58 91 0 25 25 92 2 58 0 0 37 93 2
                                  58 0 0 0 94 2 37 12 0 0 95 0 12 0 96
                                  0 12 0 97 2 43 0 98 0 99 2 74 25 6 37
                                  100 4 76 101 6 58 25 19 102 2 37 84 0
                                  0 103 1 43 37 0 104 1 105 6 6 106 1 6
                                  0 0 107 1 67 12 6 108 0 19 0 109 2 43
                                  0 37 0 110 1 6 12 0 111 2 37 84 0 0
                                  112 3 58 6 0 25 6 113 1 34 116 0 117
                                  1 34 25 0 118 2 121 0 6 120 122 2 25
                                  0 0 19 126 1 128 127 25 129 2 6 0 25
                                  37 130 2 6 0 0 0 131 2 132 0 25 37
                                  133 2 132 0 0 0 134 1 6 0 132 135 2 6
                                  84 0 25 136 1 6 37 0 137 2 6 138 0 0
                                  139 2 6 12 0 0 140 1 142 141 25 143 2
                                  145 58 144 141 146 1 6 30 0 147 1 121
                                  149 0 150 2 25 0 37 0 152 2 42 0 37
                                  37 158 0 0 12 17 1 0 12 12 18 0 0 12
                                  13 1 0 12 12 14 0 0 12 15 1 0 12 12
                                  16 1 0 19 19 21 0 0 19 20 1 0 37 40
                                  41 1 0 19 19 23 0 0 19 22 1 0 60 6 61
                                  1 0 121 124 125 2 0 124 6 12 151 2 0
                                  121 6 37 162 1 0 121 6 160 3 0 121 6
                                  42 37 161 2 0 121 6 42 163 3 0 121 6
                                  37 37 164 2 0 165 19 6 170 3 0 165 19
                                  6 42 169 3 0 165 19 6 37 168 5 0 165
                                  19 6 42 37 12 166 4 0 165 19 6 42 37
                                  167 1 0 121 6 154 2 0 121 6 42 157 2
                                  0 121 6 37 156 3 0 121 6 37 37 159 3
                                  0 121 6 42 37 155 1 0 12 6 36 1 0 62
                                  40 66 4 0 124 6 12 43 37 153)))))
          '|lookupComplete|)) 
