
(/VERSIONCHECK 2) 

(DEFUN |FFPOLY;revListToSUP| (|l| $)
  (PROG (|t| #0=#:G1874 |newl|)
    (RETURN
      (SEQ (LETT |newl| NIL . #1=(|FFPOLY;revListToSUP|))
           (SEQ (LETT |t| NIL . #1#) (LETT #0# |l| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |t| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |newl|
                                 (CONS (CONS (CAR |t|) (CDR |t|))
                                       |newl|) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |newl|))))) 

(DEFUN |FFPOLY;listToSUP| (|l| $)
  (PROG (#0=#:G1879 |t| #1=#:G1880 |newl|)
    (RETURN
      (SEQ (LETT |newl|
                 (PROGN
                   (LETT #0# NIL . #2=(|FFPOLY;listToSUP|))
                   (SEQ (LETT |t| NIL . #2#) (LETT #1# |l| . #2#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS (CONS (CAR |t|) (CDR |t|))
                                     #0#) . #2#)))
                        (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #2#)
           (EXIT |newl|))))) 

(DEFUN |FFPOLY;reducedQPowers;SupPa;3| (|f| $)
  (PROG (|m| |m1| |e| |qpow| |w| |qexp| |i| |g| |h|)
    (RETURN
      (SEQ (LETT |m| (SPADCALL |f| (QREFELT $ 12))
                 . #0=(|FFPOLY;reducedQPowers;SupPa;3|))
           (LETT |m1| (- |m| 1) . #0#) (SPADCALL |f| (QREFELT $ 15))
           (LETT |e|
                 (SPADCALL
                     (SPADCALL
                         (SPADCALL (|spadConstant| $ 13) 1
                             (QREFELT $ 16))
                         (QREFELT $ 17))
                     (QREFELT $ 10) (QREFELT $ 18)) . #0#)
           (LETT |w| (|spadConstant| $ 14) . #0#)
           (LETT |qpow|
                 (SPADCALL |m| (|spadConstant| $ 21) (QREFELT $ 23)) . #0#)
           (SETELT |qpow| 0 (|spadConstant| $ 24))
           (SEQ (LETT |i| 1 . #0#) G190
                (COND ((QSGREATERP |i| |m1|) #1=(GO G191)))
                (SEQ (EXIT (SETELT |qpow| |i|
                                   (SPADCALL
                                    (LETT |w|
                                     (SPADCALL |w| |e| (QREFELT $ 25)) . #0#)
                                    (QREFELT $ 26)))))
                (LETT |i| (QSADD1 |i|) . #0#) #2=(GO G190) G191
                (EXIT NIL))
           (LETT |qexp|
                 (SPADCALL |m| (|spadConstant| $ 21) (QREFELT $ 23)) . #0#)
           (EXIT (COND
                   ((EQL |m| 1)
                    (SEQ (SETELT |qexp| 0
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |f| 0 (QREFELT $ 27))
                                      (QREFELT $ 28))
                                     (QREFELT $ 29)))
                         (EXIT |qexp|)))
                   ('T
                    (SEQ (SETELT |qexp| 0
                                 (SPADCALL (|spadConstant| $ 13) 1
                                     (QREFELT $ 16)))
                         (LETT |h| (ELT |qpow| 1) . #0#)
                         (SETELT |qexp| 1 |h|)
                         (SEQ (LETT |i| 2 . #0#) G190
                              (COND ((QSGREATERP |i| |m1|) #1#))
                              (SEQ (LETT |g|
                                    (|spadConstant| $ 21) . #0#)
                                   (SEQ G190
                                    (COND
                                      ((NULL
                                        (COND
                                          ((SPADCALL |h|
                                            (|spadConstant| $ 21)
                                            (QREFELT $ 31))
                                           'NIL)
                                          ('T 'T)))
                                       #1#))
                                    (SEQ
                                     (LETT |g|
                                      (SPADCALL |g|
                                       (SPADCALL
                                        (SPADCALL |h| (QREFELT $ 32))
                                        (ELT |qpow|
                                         (SPADCALL |h| (QREFELT $ 12)))
                                        (QREFELT $ 33))
                                       (QREFELT $ 34)) . #0#)
                                     (EXIT
                                      (LETT |h|
                                       (SPADCALL |h| (QREFELT $ 35)) . #0#)))
                                    NIL #2# G191 (EXIT NIL))
                                   (EXIT
                                    (SETELT |qexp| |i|
                                     (LETT |h| |g| . #0#))))
                              (LETT |i| (QSADD1 |i|) . #0#) #2# G191
                              (EXIT NIL))
                         (EXIT |qexp|))))))))) 

(DEFUN |FFPOLY;leastAffineMultiple;2Sup;4| (|f| $)
  (PROG (|qexp| |n| #0=#:G1902 #1=#:G1903 |b| |col1| #2=#:G1904
                |newCoeffVector| |i| |dim| |coeffVector| |ns| |k|
                #3=#:G1899 #4=#:G1897 #5=#:G1895 #6=#:G1896)
    (RETURN
      (SEQ (LETT |qexp| (SPADCALL |f| (QREFELT $ 36))
                 . #7=(|FFPOLY;leastAffineMultiple;2Sup;4|))
           (LETT |n| (SPADCALL |f| (QREFELT $ 12)) . #7#)
           (LETT |b|
                 (SPADCALL
                     (SPADCALL
                         (PROGN
                           (LETT #0# NIL . #7#)
                           (SEQ (LETT |i| 0 . #7#)
                                (LETT #1# (- |n| 1) . #7#) G190
                                (COND
                                  ((QSGREATERP |i| #1#) #8=(GO G191)))
                                (SEQ (EXIT
                                      (LETT #0#
                                       (CONS
                                        (SPADCALL
                                         (SPADCALL (ELT |qexp| |i|) |n|
                                          (QREFELT $ 38))
                                         (QREFELT $ 40))
                                        #0#) . #7#)))
                                (LETT |i| (QSADD1 |i|) . #7#)
                                #9=(GO G190) G191
                                (EXIT (NREVERSE0 #0#))))
                         (QREFELT $ 43))
                     (QREFELT $ 44)) . #7#)
           (LETT |col1|
                 (SPADCALL |n| 1 (|spadConstant| $ 19) (QREFELT $ 45)) . #7#)
           (SPADCALL |col1| 1 1 (|spadConstant| $ 13) (QREFELT $ 53))
           (LETT |ns|
                 (SPADCALL (SPADCALL |col1| |b| (QREFELT $ 54))
                     (QREFELT $ 56)) . #7#)
           (LETT |dim| (+ |n| 2) . #7#)
           (SEQ (LETT #2# NIL . #7#) G190 (COND (#2# #8#))
                (SEQ (LETT |newCoeffVector|
                           (SPADCALL |ns| 1 (QREFELT $ 57)) . #7#)
                     (LETT |i| (+ |n| 1) . #7#)
                     (SEQ G190
                          (COND
                            ((NULL (SPADCALL
                                    (SPADCALL |newCoeffVector| |i|
                                     (QREFELT $ 58))
                                    (|spadConstant| $ 19)
                                    (QREFELT $ 59)))
                             #8#))
                          (SEQ (EXIT (LETT |i| (- |i| 1) . #7#))) NIL
                          #9# G191 (EXIT NIL))
                     (COND
                       ((< |i| |dim|)
                        (SEQ (LETT |dim| |i| . #7#)
                             (EXIT (LETT |coeffVector|
                                    |newCoeffVector| . #7#)))))
                     (EXIT (LETT |ns| (CDR |ns|) . #7#)))
                (LETT #2# (NULL |ns|) . #7#) #9# G191 (EXIT NIL))
           (EXIT (SPADCALL
                     (SPADCALL
                         (SPADCALL |coeffVector| 1 (QREFELT $ 58))
                         (QREFELT $ 29))
                     (PROGN
                       (LETT #6# NIL . #7#)
                       (SEQ (LETT |k| 2 . #7#) G190
                            (COND ((QSGREATERP |k| |dim|) #8#))
                            (SEQ (EXIT (PROGN
                                         (LETT #4#
                                          (SPADCALL
                                           (SPADCALL |coeffVector| |k|
                                            (QREFELT $ 58))
                                           (EXPT (QREFELT $ 10)
                                            (PROG1
                                             (LETT #3# (- |k| 2) . #7#)
                                              (|check-subtype|
                                               (>= #3# 0)
                                               '(|NonNegativeInteger|)
                                               #3#)))
                                           (QREFELT $ 16)) . #7#)
                                         (COND
                                           (#6#
                                            (LETT #5#
                                             (SPADCALL #5# #4#
                                              (QREFELT $ 34)) . #7#))
                                           ('T
                                            (PROGN
                                              (LETT #5# #4# . #7#)
                                              (LETT #6# 'T . #7#)))))))
                            (LETT |k| (QSADD1 |k|) . #7#) #9# G191
                            (EXIT NIL))
                       (COND (#6# #5#) ('T (|spadConstant| $ 21))))
                     (QREFELT $ 34))))))) 

(DEFUN |FFPOLY;numberOfIrreduciblePoly;2Pi;5| (|n| $)
  (PROG (|divisorsOfn| |d| #0=#:G1910 |qd| |sum| |lastd| #1=#:G1907)
    (RETURN
      (SEQ (COND
             ((EQL |n| 1) (QREFELT $ 10))
             ('T
              (SEQ (LETT |lastd| 1
                         . #2=(|FFPOLY;numberOfIrreduciblePoly;2Pi;5|))
                   (LETT |qd| (QREFELT $ 10) . #2#)
                   (LETT |sum|
                         (* (SPADCALL |n| (QREFELT $ 64)) |qd|) . #2#)
                   (LETT |divisorsOfn|
                         (CDR (SPADCALL |n| (QREFELT $ 66))) . #2#)
                   (SEQ (LETT |d| NIL . #2#)
                        (LETT #0# |divisorsOfn| . #2#) G190
                        (COND
                          ((OR (ATOM #0#)
                               (PROGN (LETT |d| (CAR #0#) . #2#) NIL))
                           (GO G191)))
                        (SEQ (LETT |qd|
                                   (* |qd|
                                    (SPADCALL (QREFELT $ 10)
                                     (- |d| |lastd|) (QREFELT $ 68))) . #2#)
                             (LETT |sum|
                                   (+ |sum|
                                    (*
                                     (SPADCALL (QUOTIENT2 |n| |d|)
                                      (QREFELT $ 64))
                                     |qd|)) . #2#)
                             (EXIT (LETT |lastd| |d| . #2#)))
                        (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                        (EXIT NIL))
                   (EXIT (PROG1 (LETT #1# (QUOTIENT2 |sum| |n|) . #2#)
                           (|check-subtype| (> #1# 0)
                               '(|PositiveInteger|) #1#)))))))))) 

(DEFUN |FFPOLY;numberOfPrimitivePoly;2Pi;6| (|n| $)
  (PROG (#0=#:G1911)
    (RETURN
      (PROG1 (LETT #0#
                   (QUOTIENT2
                       (SPADCALL (- (SPADCALL (QREFELT $ 10) |n|
                                     (QREFELT $ 68))
                                    1)
                                 (QREFELT $ 70))
                       |n|)
                   |FFPOLY;numberOfPrimitivePoly;2Pi;6|)
        (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))) 

(DEFUN |FFPOLY;numberOfNormalPoly;2Pi;7| (|n| $)
  (PROG (#0=#:G1914 #1=#:G1915 #2=#:G1916 |p| |q| #3=#:G1917 |m|
                    #4=#:G2134 #5=#:G2135 |divisorsOfm| |d| #6=#:G2144
                    |e| |qe| |prod|)
    (RETURN
      (SEQ (COND
             ((EQL |n| 1)
              (PROG1 (LETT #1#
                           (PROG1 (LETT #0# (- (QREFELT $ 10) 1)
                                        . #7=(|FFPOLY;numberOfNormalPoly;2Pi;7|))
                             (|check-subtype| (>= #0# 0)
                                 '(|NonNegativeInteger|) #0#)) . #7#)
                (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#)))
             (#8='T
              (SEQ (LETT |m| |n| . #7#)
                   (LETT |p|
                         (PROG1 (LETT #2#
                                      (SPADCALL (QREFELT $ 72)) . #7#)
                           (|check-subtype| (> #2# 0)
                               '(|PositiveInteger|) #2#)) . #7#)
                   (LETT |q| (QREFELT $ 10) . #7#)
                   (SEQ G190
                        (COND
                          ((NULL (EQL (REMAINDER2 |m| |p|) 0))
                           #9=(GO G191)))
                        (SEQ (EXIT (LETT |m|
                                    (PROG1
                                     (LETT #3#
                                      (QUOTIENT2 |m| |p|) . #7#)
                                      (|check-subtype| (> #3# 0)
                                       '(|PositiveInteger|) #3#)) . #7#)))
                        NIL #10=(GO G190) G191 (EXIT NIL))
                   (EXIT (COND
                           ((EQL |m| 1)
                            (PROG1 (LETT #5#
                                    (QUOTIENT2
                                     (*
                                      (EXPT |q|
                                       (PROG1
                                        (LETT #4# (- |n| 1) . #7#)
                                         (|check-subtype| (>= #4# 0)
                                          '(|NonNegativeInteger|) #4#)))
                                      (- |q| 1))
                                     |n|) . #7#)
                              (|check-subtype| (> #5# 0)
                                  '(|PositiveInteger|) #5#)))
                           (#8#
                            (SEQ (LETT |prod| (- |q| 1) . #7#)
                                 (LETT |divisorsOfm|
                                       (CDR
                                        (SPADCALL |m| (QREFELT $ 66))) . #7#)
                                 (SEQ (LETT |d| NIL . #7#)
                                      (LETT #6# |divisorsOfm| . #7#)
                                      G190
                                      (COND
                                        ((OR (ATOM #6#)
                                          (PROGN
                                            (LETT |d| (CAR #6#) . #7#)
                                            NIL))
                                         #9#))
                                      (SEQ (LETT |e| 1 . #7#)
                                       (LETT |qe| |q| . #7#)
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (COND
                                              ((EQL
                                                (REMAINDER2 |qe| |d|)
                                                1)
                                               'NIL)
                                              ('T 'T)))
                                           #9#))
                                        (SEQ (LETT |e| (+ |e| 1) . #7#)
                                         (EXIT
                                          (LETT |qe|
                                           (* |qe| |q|) . #7#)))
                                        NIL #10# G191 (EXIT NIL))
                                       (EXIT
                                        (LETT |prod|
                                         (* |prod|
                                          (EXPT (- |qe| 1)
                                           (QUOTIENT2
                                            (SPADCALL |d|
                                             (QREFELT $ 70))
                                            |e|))) . #7#)))
                                      (LETT #6# (CDR #6#) . #7#) #10#
                                      G191 (EXIT NIL))
                                 (EXIT (QUOTIENT2
                                        (*
                                         (SPADCALL |q| (- |n| |m|)
                                          (QREFELT $ 68))
                                         |prod|)
                                        |n|))))))))))))) 

(DEFUN |FFPOLY;primitive?;SupB;8| (|f| $)
  (PROG (|n| |q| #0=#:G2147 #1=#:G2148 |qn1| |x| |lrec| |rec|
             #2=#:G2162 #3=#:G2153 |lfact| |d| #4=#:G2163 |expt|
             #5=#:G2161 #6=#:G2157)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                            . #7=(|FFPOLY;primitive?;SupB;8|))
                      (EXIT (COND
                              ((OR (OR (EQL |n| 0)
                                    (NULL
                                     (SPADCALL
                                      (SPADCALL |f| (QREFELT $ 32))
                                      (|spadConstant| $ 13)
                                      (QREFELT $ 59))))
                                   (SPADCALL
                                    (SPADCALL |f| 0 (QREFELT $ 27))
                                    (|spadConstant| $ 19)
                                    (QREFELT $ 59)))
                               'NIL)
                              ('T
                               (SEQ (LETT |q| (QREFELT $ 10) . #7#)
                                    (LETT |qn1|
                                     (PROG1
                                      (LETT #1#
                                       (PROG1
                                        (LETT #0#
                                         (- (EXPT |q| |n|) 1) . #7#)
                                         (|check-subtype| (>= #0# 0)
                                          '(|NonNegativeInteger|) #0#)) . #7#)
                                       (|check-subtype| (> #1# 0)
                                        '(|PositiveInteger|) #1#)) . #7#)
                                    (SPADCALL |f| (QREFELT $ 15))
                                    (LETT |x|
                                     (SPADCALL
                                      (SPADCALL (|spadConstant| $ 13) 1
                                       (QREFELT $ 16))
                                      (QREFELT $ 17)) . #7#)
                                    (COND
                                      ((NULL
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |x| |qn1|
                                           (QREFELT $ 74))
                                          (QREFELT $ 26))
                                         (|spadConstant| $ 24)
                                         (QREFELT $ 31)))
                                       (EXIT 'NIL)))
                                    (LETT |lrec|
                                     (SPADCALL
                                      (SPADCALL |qn1| (QREFELT $ 76))
                                      (QREFELT $ 80)) . #7#)
                                    (LETT |lfact| NIL . #7#)
                                    (SEQ (LETT |rec| NIL . #7#)
                                     (LETT #2# |lrec| . #7#) G190
                                     (COND
                                       ((OR (ATOM #2#)
                                         (PROGN
                                           (LETT |rec| (CAR #2#) . #7#)
                                           NIL))
                                        #8=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT |lfact|
                                        (CONS
                                         (PROG1
                                          (LETT #3# (QCAR |rec|) . #7#)
                                           (|check-subtype| (> #3# 0)
                                            '(|PositiveInteger|) #3#))
                                         |lfact|) . #7#)))
                                     (LETT #2# (CDR #2#) . #7#)
                                     #9=(GO G190) G191 (EXIT NIL))
                                    (SEQ
                                     (EXIT
                                      (SEQ (LETT |d| NIL . #7#)
                                       (LETT #4# |lfact| . #7#) G190
                                       (COND
                                         ((OR (ATOM #4#)
                                           (PROGN
                                             (LETT |d| (CAR #4#) . #7#)
                                             NIL))
                                          #8#))
                                       (SEQ
                                        (LETT |expt|
                                         (QUOTIENT2 |qn1| |d|) . #7#)
                                        (EXIT
                                         (COND
                                           ((NULL (< |expt| |n|))
                                            (COND
                                              ((SPADCALL
                                                (SPADCALL
                                                 (SPADCALL |x| |expt|
                                                  (QREFELT $ 18))
                                                 (QREFELT $ 26))
                                                (|spadConstant| $ 24)
                                                (QREFELT $ 31))
                                               (PROGN
                                                 (LETT #6#
                                                  (PROGN
                                                    (LETT #5#
                                                     'NIL . #7#)
                                                    (GO #5#)) . #7#)
                                                 (GO #6#))))))))
                                       (LETT #4# (CDR #4#) . #7#) #9#
                                       G191 (EXIT NIL)))
                                     #6# (EXIT #6#))
                                    (EXIT 'T)))))))
           #5# (EXIT #5#))))) 

(DEFUN |FFPOLY;normal?;SupB;9| (|f| $)
  (PROG (|n| |g| #0=#:G2173 |i| #1=#:G2167 #2=#:G2174 |l|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                 . #3=(|FFPOLY;normal?;SupB;9|))
           (EXIT (COND
                   ((OR (OR (EQL |n| 0)
                            (NULL (SPADCALL
                                      (SPADCALL |f| (QREFELT $ 32))
                                      (|spadConstant| $ 13)
                                      (QREFELT $ 59))))
                        (SPADCALL (SPADCALL |f| 0 (QREFELT $ 27))
                            (|spadConstant| $ 19) (QREFELT $ 59)))
                    'NIL)
                   ((EQL |n| 1) 'T)
                   ('T
                    (COND
                      ((NULL (SPADCALL |f| (QREFELT $ 83))) 'NIL)
                      ('T
                       (SEQ (LETT |g|
                                  (SPADCALL |f| (QREFELT $ 36)) . #3#)
                            (LETT |l|
                                  (PROGN
                                    (LETT #0# NIL . #3#)
                                    (SEQ (LETT |i| 0 . #3#)
                                     (LETT #2#
                                      (PROG1 (LETT #1# (- |n| 1) . #3#)
                                        (|check-subtype| (>= #1# 0)
                                         '(|NonNegativeInteger|) #1#)) . #3#)
                                     G190
                                     (COND
                                       ((QSGREATERP |i| #2#) (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT #0#
                                        (CONS
                                         (SPADCALL
                                          (SPADCALL (ELT |g| |i|) |n|
                                           (QREFELT $ 38))
                                          (QREFELT $ 40))
                                         #0#) . #3#)))
                                     (LETT |i| (QSADD1 |i|) . #3#)
                                     (GO G190) G191
                                     (EXIT (NREVERSE0 #0#)))) . #3#)
                            (EXIT (COND
                                    ((EQL
                                      (SPADCALL
                                       (SPADCALL |l| (QREFELT $ 43))
                                       (QREFELT $ 84))
                                      |n|)
                                     'T)
                                    ('T 'NIL))))))))))))) 

(DEFUN |FFPOLY;nextSubset| (|s| |bound| $)
  (PROG (|m| |restOfs| |secondOfs| |firstOfsPlus1| |noGap| |firstOfs|
             |i| #0=#:G2188 |j|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |m| (SPADCALL |s| (QREFELT $ 87))
                            . #1=(|FFPOLY;nextSubset|))
                      (EXIT (COND
                              ((EQL |m| 0) (CONS 0 (LIST 1)))
                              (#2='T
                               (SEQ (LETT |noGap| 'T . #1#)
                                    (LETT |i| 0 . #1#)
                                    (SEQ G190
                                     (COND
                                       ((NULL
                                         (COND
                                           (|noGap|
                                            (COND
                                              ((NULL
                                                (LETT |restOfs|
                                                 (CDR |s|) . #1#))
                                               'NIL)
                                              ('T 'T)))
                                           ('T 'NIL)))
                                        #3=(GO G191)))
                                     (SEQ
                                      (LETT |secondOfs|
                                       (|SPADfirst| |restOfs|) . #1#)
                                      (LETT |firstOfsPlus1|
                                       (+ (|SPADfirst| |s|) 1) . #1#)
                                      (EXIT
                                       (COND
                                         ((EQL |secondOfs|
                                           |firstOfsPlus1|)
                                          (SEQ
                                           (LETT |s| |restOfs| . #1#)
                                           (EXIT
                                            (LETT |i| (+ |i| 1) . #1#))))
                                         ('T
                                          (SEQ
                                           (SPADCALL |s|
                                            |firstOfsPlus1|
                                            (QREFELT $ 88))
                                           (EXIT
                                            (LETT |noGap| 'NIL . #1#)))))))
                                     NIL #4=(GO G190) G191 (EXIT NIL))
                                    (COND
                                      (|noGap|
                                       (SEQ
                                        (LETT |firstOfs|
                                         (|SPADfirst| |s|) . #1#)
                                        (EXIT
                                         (COND
                                           ((< |firstOfs| |bound|)
                                            (SPADCALL |s|
                                             (+ |firstOfs| 1)
                                             (QREFELT $ 88)))
                                           ((< |m| |bound|)
                                            (SEQ
                                             (SPADCALL |s| (+ |m| 1)
                                              (QREFELT $ 88))
                                             (EXIT
                                              (LETT |i| |m| . #1#))))
                                           (#2#
                                            (PROGN
                                              (LETT #0#
                                               (CONS 1 "failed") . #1#)
                                              (GO #0#))))))))
                                    (SEQ (LETT |j| |i| . #1#) G190
                                     (COND ((< |j| 1) #3#))
                                     (SEQ
                                      (EXIT
                                       (LETT |s| (CONS |j| |s|) . #1#)))
                                     (LETT |j| (+ |j| -1) . #1#) #4#
                                     G191 (EXIT NIL))
                                    (EXIT (CONS 0 |s|))))))))
           #0# (EXIT #0#))))) 

(DEFUN |FFPOLY;nextIrreduciblePoly;SupU;11| (|f| $)
  (PROG (|n| |lcf| |fRepr| #0=#:G2227 |fcopy| #1=#:G2198 #2=#:G2199
             |n1| |term| |j| #3=#:G2202 |pol| |restfcopy| |entry|
             #4=#:G2228 #5=#:G2226 #6=#:G2212 |s| |weight|
             |taillookuplist| #7=#:G2214 |headlookuplist| |tailpol|
             |s1| |headpol|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                            . #8=(|FFPOLY;nextIrreduciblePoly;SupU;11|))
                      (EXIT (COND
                              ((EQL |n| 0)
                               (|error| "polynomial must have positive degree"))
                              ('T
                               (SEQ (SEQ
                                     (LETT |lcf|
                                      (SPADCALL |f| (QREFELT $ 32)) . #8#)
                                     (EXIT
                                      (COND
                                        ((NULL
                                          (SPADCALL |lcf|
                                           (|spadConstant| $ 13)
                                           (QREFELT $ 59)))
                                         (LETT |f|
                                          (SPADCALL
                                           (SPADCALL |lcf|
                                            (QREFELT $ 89))
                                           |f| (QREFELT $ 33)) . #8#)))))
                                    (LETT |fRepr| |f| . #8#)
                                    (LETT |fcopy| NIL . #8#)
                                    (SEQ (LETT |term| NIL . #8#)
                                     (LETT #0# |fRepr| . #8#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |term|
                                            (CAR #0#) . #8#)
                                           NIL))
                                        #9=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT |fcopy|
                                        (CONS
                                         (CONS (CAR |term|)
                                          (CDR |term|))
                                         |fcopy|) . #8#)))
                                     (LETT #0# (CDR #0#) . #8#)
                                     #10=(GO G190) G191 (EXIT NIL))
                                    (COND
                                      ((NULL (EQL (QCAR |term|) 0))
                                       (LETT |fcopy|
                                        (CONS
                                         (CONS 0 (|spadConstant| $ 19))
                                         |fcopy|) . #8#)))
                                    (LETT |tailpol| NIL . #8#)
                                    (LETT |headpol| |fcopy| . #8#)
                                    (LETT |fcopy|
                                     (REVERSE |fcopy|) . #8#)
                                    (LETT |weight|
                                     (PROG1
                                      (LETT #1#
                                       (- (LENGTH |fcopy|) 1) . #8#)
                                       (|check-subtype| (>= #1# 0)
                                        '(|NonNegativeInteger|) #1#)) . #8#)
                                    (LETT |taillookuplist| NIL . #8#)
                                    (LETT |headlookuplist|
                                     (SPADCALL |weight| 0
                                      (QREFELT $ 90)) . #8#)
                                    (LETT |s| NIL . #8#)
                                    (LETT |n1|
                                     (PROG1 (LETT #2# (- |n| 1) . #8#)
                                       (|check-subtype| (>= #2# 0)
                                        '(|NonNegativeInteger|) #2#)) . #8#)
                                    (EXIT
                                     (SEQ G190 NIL
                                      (SEQ
                                       (SEQ G190
                                        (COND
                                          ((NULL
                                            (COND
                                              ((NULL |headlookuplist|)
                                               'NIL)
                                              ('T 'T)))
                                           #9#))
                                        (SEQ
                                         (LETT |term|
                                          (|SPADfirst| |headpol|) . #8#)
                                         (LETT |j|
                                          (|SPADfirst|
                                           |headlookuplist|) . #8#)
                                         (COND
                                           ((EQL |j| 0)
                                            (LETT |j|
                                             (SPADCALL (QCDR |term|)
                                              (QREFELT $ 91)) . #8#)))
                                         (LETT |j| (+ |j| 1) . #8#)
                                         (EXIT
                                          (COND
                                            ((EQL
                                              (REMAINDER2 |j|
                                               (QREFELT $ 10))
                                              0)
                                             (SEQ
                                              (LETT |tailpol|
                                               (CONS |term| |tailpol|) . #8#)
                                              (LETT |headpol|
                                               (CDR |headpol|) . #8#)
                                              (LETT |taillookuplist|
                                               (CONS |j|
                                                |taillookuplist|) . #8#)
                                              (EXIT
                                               (LETT |headlookuplist|
                                                (CDR |headlookuplist|) . #8#))))
                                            ('T
                                             (SEQ
                                              (PROGN
                                                (RPLACD
                                                 (|SPADfirst|
                                                  |headpol|)
                                                 (SPADCALL
                                                  (PROG1
                                                   (LETT #3# |j| . #8#)
                                                    (|check-subtype|
                                                     (> #3# 0)
                                                     '(|PositiveInteger|)
                                                     #3#))
                                                  (QREFELT $ 92)))
                                                (QCDR
                                                 (|SPADfirst|
                                                  |headpol|)))
                                              (SPADCALL
                                               |headlookuplist| |j|
                                               (QREFELT $ 88))
                                              (EXIT
                                               (COND
                                                 ((NULL
                                                   |taillookuplist|)
                                                  (SEQ
                                                   (LETT |pol|
                                                    (|FFPOLY;revListToSUP|
                                                     |headpol| $) . #8#)
                                                   (EXIT
                                                    (COND
                                                      ((SPADCALL |pol|
                                                        (QREFELT $ 83))
                                                       (PROGN
                                                         (LETT #5#
                                                          (CONS 0
                                                           |pol|) . #8#)
                                                         (GO #5#)))))))
                                                 ('T
                                                  (SEQ
                                                   (LETT |headpol|
                                                    (CONS
                                                     (|SPADfirst|
                                                      |tailpol|)
                                                     |headpol|) . #8#)
                                                   (LETT |tailpol|
                                                    (CDR |tailpol|) . #8#)
                                                   (LETT
                                                    |headlookuplist|
                                                    (CONS
                                                     (|SPADfirst|
                                                      |taillookuplist|)
                                                     |headlookuplist|) . #8#)
                                                   (EXIT
                                                    (LETT
                                                     |taillookuplist|
                                                     (CDR
                                                      |taillookuplist|) . #8#)))))))))))
                                        NIL #10# G191 (EXIT NIL))
                                       (COND
                                         ((NULL |s|)
                                          (SEQ
                                           (LETT |restfcopy|
                                            (CDR |fcopy|) . #8#)
                                           (EXIT
                                            (SEQ
                                             (LETT |entry| NIL . #8#)
                                             (LETT #4#
                                              |restfcopy| . #8#)
                                             G190
                                             (COND
                                               ((OR (ATOM #4#)
                                                 (PROGN
                                                   (LETT |entry|
                                                    (CAR #4#) . #8#)
                                                   NIL))
                                                #9#))
                                             (SEQ
                                              (EXIT
                                               (LETT |s|
                                                (CONS (QCAR |entry|)
                                                 |s|) . #8#)))
                                             (LETT #4# (CDR #4#) . #8#)
                                             #10# G191 (EXIT NIL))))))
                                       (EXIT
                                        (COND
                                          ((EQL |weight| |n|)
                                           (PROGN
                                             (LETT #5#
                                              (CONS 1 "failed") . #8#)
                                             (GO #5#)))
                                          ('T
                                           (SEQ
                                            (LETT |s1|
                                             (PROG2
                                              (LETT #6#
                                               (|FFPOLY;nextSubset|
                                                (CDR |s|) |n1| $) . #8#)
                                              (QCDR #6#)
                                               (|check-union|
                                                (QEQCAR #6# 0)
                                                (|List|
                                                 (|NonNegativeInteger|))
                                                #6#)) . #8#)
                                            (LETT |s|
                                             (CONS 0 |s1|) . #8#)
                                            (LETT |weight|
                                             (SPADCALL |s|
                                              (QREFELT $ 87)) . #8#)
                                            (LETT |taillookuplist|
                                             NIL . #8#)
                                            (LETT |headlookuplist|
                                             (CONS (QREFELT $ 10)
                                              (SPADCALL
                                               (PROG1
                                                (LETT #7#
                                                 (- |weight| 1) . #8#)
                                                 (|check-subtype|
                                                  (>= #7# 0)
                                                  '(|NonNegativeInteger|)
                                                  #7#))
                                               1 (QREFELT $ 90))) . #8#)
                                            (LETT |tailpol| NIL . #8#)
                                            (LETT |headpol| NIL . #8#)
                                            (LETT |s1|
                                             (CONS |n| (REVERSE |s1|)) . #8#)
                                            (SEQ G190
                                             (COND
                                               ((NULL
                                                 (COND
                                                   ((NULL |s1|) 'NIL)
                                                   ('T 'T)))
                                                #9#))
                                             (SEQ
                                              (LETT |headpol|
                                               (CONS
                                                (CONS
                                                 (|SPADfirst| |s1|)
                                                 (|spadConstant| $ 13))
                                                |headpol|) . #8#)
                                              (EXIT
                                               (LETT |s1|
                                                (CDR |s1|) . #8#)))
                                             NIL #10# G191 (EXIT NIL))
                                            (EXIT
                                             (LETT |headpol|
                                              (CONS
                                               (CONS 0
                                                (|spadConstant| $ 19))
                                               |headpol|) . #8#)))))))
                                      NIL #10# G191 (EXIT NIL)))))))))
           #5# (EXIT #5#))))) 

(DEFUN |FFPOLY;nextPrimitivePoly;SupU;12| (|f| $)
  (PROG (|n| |lcf| |fRepr| #0=#:G2281 |fcopy| |xn| |c0| #1=#:G2237 |q1|
             #2=#:G2238 #3=#:G2239 #4=#:G2244 #5=#:G2245 |n1|
             |noGenerator| #6=#:G2246 |constterm| |term| |j| #7=#:G2255
             |pol| #8=#:G2280 |notReady| |restfcopy| |entry| #9=#:G2282
             #10=#:G2265 |s| |weight| |taillookuplist| #11=#:G2267
             |headlookuplist| |tailpol| |s1| |headpol| |l| #12=#:G2273
             |c|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                            . #13=(|FFPOLY;nextPrimitivePoly;SupU;12|))
                      (EXIT (COND
                              ((EQL |n| 0)
                               (|error| "polynomial must have positive degree"))
                              (#14='T
                               (SEQ (SEQ
                                     (LETT |lcf|
                                      (SPADCALL |f| (QREFELT $ 32)) . #13#)
                                     (EXIT
                                      (COND
                                        ((NULL
                                          (SPADCALL |lcf|
                                           (|spadConstant| $ 13)
                                           (QREFELT $ 59)))
                                         (LETT |f|
                                          (SPADCALL
                                           (SPADCALL |lcf|
                                            (QREFELT $ 89))
                                           |f| (QREFELT $ 33)) . #13#)))))
                                    (LETT |fRepr| |f| . #13#)
                                    (LETT |fcopy| NIL . #13#)
                                    (SEQ (LETT |term| NIL . #13#)
                                     (LETT #0# |fRepr| . #13#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |term|
                                            (CAR #0#) . #13#)
                                           NIL))
                                        #15=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT |fcopy|
                                        (CONS
                                         (CONS (CAR |term|)
                                          (CDR |term|))
                                         |fcopy|) . #13#)))
                                     (LETT #0# (CDR #0#) . #13#)
                                     #16=(GO G190) G191 (EXIT NIL))
                                    (COND
                                      ((NULL (EQL (QCAR |term|) 0))
                                       (SEQ
                                        (LETT |term|
                                         (CONS 0 (|spadConstant| $ 19)) . #13#)
                                        (EXIT
                                         (LETT |fcopy|
                                          (CONS |term| |fcopy|) . #13#)))))
                                    (LETT |fcopy|
                                     (REVERSE |fcopy|) . #13#)
                                    (LETT |xn|
                                     (|SPADfirst| |fcopy|) . #13#)
                                    (LETT |c0| (QCDR |term|) . #13#)
                                    (LETT |l|
                                     (REMAINDER2
                                      (SPADCALL |c0| (QREFELT $ 91))
                                      (QREFELT $ 10)) . #13#)
                                    (EXIT
                                     (COND
                                       ((EQL |n| 1)
                                        (SEQ
                                         (LETT |q1|
                                          (PROG1
                                           (LETT #1#
                                            (- (QREFELT $ 10) 1) . #13#)
                                            (|check-subtype| (>= #1# 0)
                                             '(|NonNegativeInteger|)
                                             #1#)) . #13#)
                                         (SEQ G190
                                          (COND
                                            ((NULL (< |l| |q1|)) #15#))
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (LETT |l|
                                              (+ |l| 1) . #13#)
                                             (LETT |c|
                                              (SPADCALL
                                               (PROG1
                                                (LETT #2# |l| . #13#)
                                                 (|check-subtype|
                                                  (> #2# 0)
                                                  '(|PositiveInteger|)
                                                  #2#))
                                               (QREFELT $ 92)) . #13#)
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (SPADCALL |c|
                                                   (QREFELT $ 28))
                                                  (QREFELT $ 95))
                                                 (PROGN
                                                   (LETT #3#
                                                    (PROGN
                                                      (LETT #8#
                                                       (CONS 0
                                                        (LIST |xn|
                                                         (CONS 0 |c|))) . #13#)
                                                      (GO #8#)) . #13#)
                                                   (GO #3#)))))))
                                           #3# (EXIT #3#))
                                          NIL #16# G191 (EXIT NIL))
                                         (EXIT (CONS 1 "failed"))))
                                       (#14#
                                        (SEQ
                                         (LETT |weight|
                                          (PROG1
                                           (LETT #4#
                                            (- (LENGTH |fcopy|) 1) . #13#)
                                            (|check-subtype| (>= #4# 0)
                                             '(|NonNegativeInteger|)
                                             #4#)) . #13#)
                                         (LETT |s| NIL . #13#)
                                         (LETT |n1|
                                          (PROG1
                                           (LETT #5# (- |n| 1) . #13#)
                                            (|check-subtype| (>= #5# 0)
                                             '(|NonNegativeInteger|)
                                             #5#)) . #13#)
                                         (LETT |c| |c0| . #13#)
                                         (SEQ G190
                                          (COND
                                            ((NULL
                                              (< |l| (QREFELT $ 10)))
                                             #15#))
                                          (SEQ
                                           (LETT |noGenerator|
                                            'T . #13#)
                                           (SEQ G190
                                            (COND
                                              ((NULL
                                                (COND
                                                  (|noGenerator|
                                                   (< |l|
                                                    (QREFELT $ 10)))
                                                  ('T 'NIL)))
                                               #15#))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (SPADCALL
                                                   (EXPT -1 |n|) |c|
                                                   (QREFELT $ 96))
                                                  (QREFELT $ 95))
                                                 (LETT |noGenerator|
                                                  'NIL . #13#))
                                                ('T
                                                 (SEQ
                                                  (LETT |l|
                                                   (+ |l| 1) . #13#)
                                                  (EXIT
                                                   (LETT |c|
                                                    (SPADCALL
                                                     (PROG1
                                                      (LETT #6#
                                                       |l| . #13#)
                                                       (|check-subtype|
                                                        (> #6# 0)
                                                        '(|PositiveInteger|)
                                                        #6#))
                                                     (QREFELT $ 92)) . #13#)))))))
                                            NIL #16# G191 (EXIT NIL))
                                           (EXIT
                                            (COND
                                              (|noGenerator|
                                               (PROGN
                                                 (LETT #8#
                                                  (CONS 1 "failed") . #13#)
                                                 (GO #8#)))
                                              ('T
                                               (SEQ
                                                (LETT |constterm|
                                                 (CONS 0 |c|) . #13#)
                                                (COND
                                                  ((SPADCALL |c| |c0|
                                                    (QREFELT $ 59))
                                                   (COND
                                                     ((< 1 |weight|)
                                                      (SEQ
                                                       (LETT |headpol|
                                                        (CDR
                                                         (REVERSE
                                                          |fcopy|)) . #13#)
                                                       (EXIT
                                                        (LETT
                                                         |headlookuplist|
                                                         (SPADCALL
                                                          |weight| 0
                                                          (QREFELT $
                                                           90)) . #13#))))
                                                     ('T
                                                      (SEQ
                                                       (LETT |headpol|
                                                        (LIST
                                                         (CONS 1
                                                          (|spadConstant|
                                                           $ 19))
                                                         |xn|) . #13#)
                                                       (LETT
                                                        |headlookuplist|
                                                        (LIST
                                                         (QREFELT $ 10)) . #13#)
                                                       (LETT |s|
                                                        (LIST 0 1) . #13#)
                                                       (EXIT
                                                        (LETT |weight|
                                                         2 . #13#))))))
                                                  ('T
                                                   (SEQ
                                                    (LETT |headpol|
                                                     (LIST
                                                      (CONS 1
                                                       (|spadConstant|
                                                        $ 19))
                                                      |xn|) . #13#)
                                                    (LETT
                                                     |headlookuplist|
                                                     (LIST
                                                      (QREFELT $ 10)) . #13#)
                                                    (LETT |s|
                                                     (LIST 0 1) . #13#)
                                                    (EXIT
                                                     (LETT |weight|
                                                      2 . #13#)))))
                                                (LETT |tailpol|
                                                 NIL . #13#)
                                                (LETT |taillookuplist|
                                                 NIL . #13#)
                                                (LETT |notReady|
                                                 'T . #13#)
                                                (SEQ G190
                                                 (COND
                                                   ((NULL |notReady|)
                                                    #15#))
                                                 (SEQ
                                                  (SEQ G190
                                                   (COND
                                                     ((NULL
                                                       (COND
                                                         ((NULL
                                                           |headlookuplist|)
                                                          'NIL)
                                                         ('T 'T)))
                                                      #15#))
                                                   (SEQ
                                                    (LETT |term|
                                                     (|SPADfirst|
                                                      |headpol|) . #13#)
                                                    (LETT |j|
                                                     (|SPADfirst|
                                                      |headlookuplist|) . #13#)
                                                    (COND
                                                      ((EQL |j| 0)
                                                       (LETT |j|
                                                        (SPADCALL
                                                         (QCDR |term|)
                                                         (QREFELT $ 91)) . #13#)))
                                                    (LETT |j|
                                                     (+ |j| 1) . #13#)
                                                    (EXIT
                                                     (COND
                                                       ((EQL
                                                         (REMAINDER2
                                                          |j|
                                                          (QREFELT $
                                                           10))
                                                         0)
                                                        (SEQ
                                                         (LETT
                                                          |tailpol|
                                                          (CONS |term|
                                                           |tailpol|) . #13#)
                                                         (LETT
                                                          |headpol|
                                                          (CDR
                                                           |headpol|) . #13#)
                                                         (LETT
                                                          |taillookuplist|
                                                          (CONS |j|
                                                           |taillookuplist|) . #13#)
                                                         (EXIT
                                                          (LETT
                                                           |headlookuplist|
                                                           (CDR
                                                            |headlookuplist|) . #13#))))
                                                       ('T
                                                        (SEQ
                                                         (PROGN
                                                           (RPLACD
                                                            (|SPADfirst|
                                                             |headpol|)
                                                            (SPADCALL
                                                             (PROG1
                                                              (LETT #7#
                                                               |j| . #13#)
                                                               (|check-subtype|
                                                                (> #7#
                                                                 0)
                                                                '(|PositiveInteger|)
                                                                #7#))
                                                             (QREFELT $
                                                              92)))
                                                           (QCDR
                                                            (|SPADfirst|
                                                             |headpol|)))
                                                         (SPADCALL
                                                          |headlookuplist|
                                                          |j|
                                                          (QREFELT $
                                                           88))
                                                         (EXIT
                                                          (COND
                                                            ((NULL
                                                              |taillookuplist|)
                                                             (SEQ
                                                              (LETT
                                                               |pol|
                                                               (|FFPOLY;revListToSUP|
                                                                (CONS
                                                                 |constterm|
                                                                 |headpol|)
                                                                $) . #13#)
                                                              (EXIT
                                                               (COND
                                                                 ((SPADCALL
                                                                   |pol|
                                                                   (QREFELT
                                                                    $
                                                                    81))
                                                                  (PROGN
                                                                    (LETT
                                                                     #8#
                                                                     (CONS
                                                                      0
                                                                      |pol|) . #13#)
                                                                    (GO
                                                                     #8#)))))))
                                                            ('T
                                                             (SEQ
                                                              (LETT
                                                               |headpol|
                                                               (CONS
                                                                (|SPADfirst|
                                                                 |tailpol|)
                                                                |headpol|) . #13#)
                                                              (LETT
                                                               |tailpol|
                                                               (CDR
                                                                |tailpol|) . #13#)
                                                              (LETT
                                                               |headlookuplist|
                                                               (CONS
                                                                (|SPADfirst|
                                                                 |taillookuplist|)
                                                                |headlookuplist|) . #13#)
                                                              (EXIT
                                                               (LETT
                                                                |taillookuplist|
                                                                (CDR
                                                                 |taillookuplist|) . #13#)))))))))))
                                                   NIL #16# G191
                                                   (EXIT NIL))
                                                  (EXIT
                                                   (COND
                                                     ((EQL |weight|
                                                       |n|)
                                                      (LETT |notReady|
                                                       'NIL . #13#))
                                                     ('T
                                                      (SEQ
                                                       (COND
                                                         ((NULL |s|)
                                                          (SEQ
                                                           (LETT
                                                            |restfcopy|
                                                            (CDR
                                                             |fcopy|) . #13#)
                                                           (EXIT
                                                            (SEQ
                                                             (LETT
                                                              |entry|
                                                              NIL . #13#)
                                                             (LETT #9#
                                                              |restfcopy| . #13#)
                                                             G190
                                                             (COND
                                                               ((OR
                                                                 (ATOM
                                                                  #9#)
                                                                 (PROGN
                                                                   (LETT
                                                                    |entry|
                                                                    (CAR
                                                                     #9#) . #13#)
                                                                   NIL))
                                                                #15#))
                                                             (SEQ
                                                              (EXIT
                                                               (LETT
                                                                |s|
                                                                (CONS
                                                                 (QCAR
                                                                  |entry|)
                                                                 |s|) . #13#)))
                                                             (LETT #9#
                                                              (CDR #9#) . #13#)
                                                             #16# G191
                                                             (EXIT NIL))))))
                                                       (LETT |s1|
                                                        (PROG2
                                                         (LETT #10#
                                                          (|FFPOLY;nextSubset|
                                                           (CDR |s|)
                                                           |n1| $) . #13#)
                                                         (QCDR #10#)
                                                          (|check-union|
                                                           (QEQCAR #10#
                                                            0)
                                                           (|List|
                                                            (|NonNegativeInteger|))
                                                           #10#)) . #13#)
                                                       (LETT |s|
                                                        (CONS 0 |s1|) . #13#)
                                                       (LETT |weight|
                                                        (SPADCALL |s|
                                                         (QREFELT $ 87)) . #13#)
                                                       (LETT
                                                        |taillookuplist|
                                                        NIL . #13#)
                                                       (LETT
                                                        |headlookuplist|
                                                        (CONS
                                                         (QREFELT $ 10)
                                                         (SPADCALL
                                                          (PROG1
                                                           (LETT #11#
                                                            (- |weight|
                                                             2) . #13#)
                                                            (|check-subtype|
                                                             (>= #11#
                                                              0)
                                                             '(|NonNegativeInteger|)
                                                             #11#))
                                                          1
                                                          (QREFELT $
                                                           90))) . #13#)
                                                       (LETT |tailpol|
                                                        NIL . #13#)
                                                       (LETT |headpol|
                                                        (LIST
                                                         (CONS
                                                          (|SPADfirst|
                                                           |s1|)
                                                          (|spadConstant|
                                                           $ 19))) . #13#)
                                                       (SEQ G190
                                                        (COND
                                                          ((NULL
                                                            (COND
                                                              ((NULL
                                                                (LETT
                                                                 |s1|
                                                                 (CDR
                                                                  |s1|) . #13#))
                                                               'NIL)
                                                              ('T 'T)))
                                                           #15#))
                                                        (SEQ
                                                         (EXIT
                                                          (LETT
                                                           |headpol|
                                                           (CONS
                                                            (CONS
                                                             (|SPADfirst|
                                                              |s1|)
                                                             (|spadConstant|
                                                              $ 13))
                                                            |headpol|) . #13#)))
                                                        NIL #16# G191
                                                        (EXIT NIL))
                                                       (EXIT
                                                        (LETT |headpol|
                                                         (REVERSE
                                                          (CONS
                                                           (CONS |n|
                                                            (|spadConstant|
                                                             $ 13))
                                                           |headpol|)) . #13#)))))))
                                                 NIL #16# G191
                                                 (EXIT NIL))
                                                (LETT |l|
                                                 (+ |l| 1) . #13#)
                                                (EXIT
                                                 (LETT |c|
                                                  (SPADCALL
                                                   (PROG1
                                                    (LETT #12#
                                                     |l| . #13#)
                                                     (|check-subtype|
                                                      (> #12# 0)
                                                      '(|PositiveInteger|)
                                                      #12#))
                                                   (QREFELT $ 92)) . #13#)))))))
                                          NIL #16# G191 (EXIT NIL))
                                         (EXIT (CONS 1 "failed"))))))))))))
           #8# (EXIT #8#))))) 

(DEFUN |FFPOLY;nextNormalPoly;SupU;13| (|f| $)
  (PROG (|n| |lcf| |fRepr| #0=#:G2330 |fcopy| |xn| |a0| #1=#:G2294
             #2=#:G2296 |n1| #3=#:G2297 |n2| |headpol| |term| |j|
             #4=#:G2304 |pol| #5=#:G2329 |notReady| |restfcopy| |entry|
             #6=#:G2331 #7=#:G2314 |s| |weight| |taillookuplist|
             #8=#:G2316 |middlelookuplist| |tailpol| |s1| |middlepol|
             |l| #9=#:G2323 |a|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                            . #10=(|FFPOLY;nextNormalPoly;SupU;13|))
                      (EXIT (COND
                              ((EQL |n| 0)
                               (|error| "polynomial must have positive degree"))
                              (#11='T
                               (SEQ (SEQ
                                     (LETT |lcf|
                                      (SPADCALL |f| (QREFELT $ 32)) . #10#)
                                     (EXIT
                                      (COND
                                        ((NULL
                                          (SPADCALL |lcf|
                                           (|spadConstant| $ 13)
                                           (QREFELT $ 59)))
                                         (LETT |f|
                                          (SPADCALL
                                           (SPADCALL |lcf|
                                            (QREFELT $ 89))
                                           |f| (QREFELT $ 33)) . #10#)))))
                                    (LETT |fRepr| |f| . #10#)
                                    (LETT |fcopy| NIL . #10#)
                                    (SEQ (LETT |term| NIL . #10#)
                                     (LETT #0# |fRepr| . #10#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |term|
                                            (CAR #0#) . #10#)
                                           NIL))
                                        #12=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT |fcopy|
                                        (CONS
                                         (CONS (CAR |term|)
                                          (CDR |term|))
                                         |fcopy|) . #10#)))
                                     (LETT #0# (CDR #0#) . #10#)
                                     #13=(GO G190) G191 (EXIT NIL))
                                    (COND
                                      ((NULL (EQL (QCAR |term|) 0))
                                       (SEQ
                                        (LETT |term|
                                         (CONS 0 (|spadConstant| $ 19)) . #10#)
                                        (EXIT
                                         (LETT |fcopy|
                                          (CONS |term| |fcopy|) . #10#)))))
                                    (LETT |fcopy|
                                     (REVERSE |fcopy|) . #10#)
                                    (LETT |xn|
                                     (|SPADfirst| |fcopy|) . #10#)
                                    (LETT |middlepol|
                                     (CDR |fcopy|) . #10#)
                                    (LETT |a0|
                                     (QCDR (|SPADfirst| |middlepol|)) . #10#)
                                    (LETT |l|
                                     (REMAINDER2
                                      (SPADCALL |a0| (QREFELT $ 91))
                                      (QREFELT $ 10)) . #10#)
                                    (EXIT
                                     (COND
                                       ((EQL |n| 1)
                                        (COND
                                          ((EQL |l|
                                            (- (QREFELT $ 10) 1))
                                           (CONS 1 "failed"))
                                          ('T
                                           (CONS 0
                                            (LIST |xn|
                                             (CONS 0
                                              (SPADCALL
                                               (PROG1
                                                (LETT #1#
                                                 (+ |l| 1) . #10#)
                                                 (|check-subtype|
                                                  (> #1# 0)
                                                  '(|PositiveInteger|)
                                                  #1#))
                                               (QREFELT $ 92))))))))
                                       (#11#
                                        (SEQ
                                         (LETT |n1|
                                          (PROG1
                                           (LETT #2# (- |n| 1) . #10#)
                                            (|check-subtype| (>= #2# 0)
                                             '(|NonNegativeInteger|)
                                             #2#)) . #10#)
                                         (LETT |n2|
                                          (PROG1
                                           (LETT #3# (- |n1| 1) . #10#)
                                            (|check-subtype| (>= #3# 0)
                                             '(|NonNegativeInteger|)
                                             #3#)) . #10#)
                                         (LETT |a| |a0| . #10#)
                                         (COND
                                           ((EQL |l| 0)
                                            (SEQ (LETT |l| 1 . #10#)
                                             (EXIT
                                              (LETT |a|
                                               (|spadConstant| $ 13) . #10#)))))
                                         (SEQ G190
                                          (COND
                                            ((NULL
                                              (< |l| (QREFELT $ 10)))
                                             #12#))
                                          (SEQ
                                           (COND
                                             ((SPADCALL |a| |a0|
                                               (QREFELT $ 59))
                                              (SEQ
                                               (LETT |middlepol|
                                                (REVERSE
                                                 (CDR |middlepol|)) . #10#)
                                               (LETT |weight|
                                                (LENGTH |middlepol|) . #10#)
                                               (LETT |middlelookuplist|
                                                (SPADCALL |weight| 0
                                                 (QREFELT $ 90)) . #10#)
                                               (EXIT
                                                (LETT |s| NIL . #10#))))
                                             ('T
                                              (SEQ
                                               (LETT |middlepol|
                                                (LIST
                                                 (CONS 0
                                                  (|spadConstant| $ 19))) . #10#)
                                               (LETT |middlelookuplist|
                                                (LIST (QREFELT $ 10)) . #10#)
                                               (LETT |s|
                                                (LIST 0) . #10#)
                                               (EXIT
                                                (LETT |weight|
                                                 1 . #10#)))))
                                           (LETT |headpol|
                                            (LIST |xn| (CONS |n1| |a|)) . #10#)
                                           (LETT |tailpol| NIL . #10#)
                                           (LETT |taillookuplist|
                                            NIL . #10#)
                                           (LETT |notReady| 'T . #10#)
                                           (SEQ G190
                                            (COND
                                              ((NULL |notReady|) #12#))
                                            (SEQ
                                             (SEQ G190
                                              (COND
                                                ((NULL
                                                  (COND
                                                    ((NULL
                                                      |middlelookuplist|)
                                                     'NIL)
                                                    ('T 'T)))
                                                 #12#))
                                              (SEQ
                                               (LETT |term|
                                                (|SPADfirst|
                                                 |middlepol|) . #10#)
                                               (LETT |j|
                                                (|SPADfirst|
                                                 |middlelookuplist|) . #10#)
                                               (COND
                                                 ((EQL |j| 0)
                                                  (LETT |j|
                                                   (SPADCALL
                                                    (QCDR |term|)
                                                    (QREFELT $ 91)) . #10#)))
                                               (LETT |j|
                                                (+ |j| 1) . #10#)
                                               (EXIT
                                                (COND
                                                  ((EQL
                                                    (REMAINDER2 |j|
                                                     (QREFELT $ 10))
                                                    0)
                                                   (SEQ
                                                    (LETT |tailpol|
                                                     (CONS |term|
                                                      |tailpol|) . #10#)
                                                    (LETT |middlepol|
                                                     (CDR |middlepol|) . #10#)
                                                    (LETT
                                                     |taillookuplist|
                                                     (CONS |j|
                                                      |taillookuplist|) . #10#)
                                                    (EXIT
                                                     (LETT
                                                      |middlelookuplist|
                                                      (CDR
                                                       |middlelookuplist|) . #10#))))
                                                  ('T
                                                   (SEQ
                                                    (PROGN
                                                      (RPLACD
                                                       (|SPADfirst|
                                                        |middlepol|)
                                                       (SPADCALL
                                                        (PROG1
                                                         (LETT #4#
                                                          |j| . #10#)
                                                          (|check-subtype|
                                                           (> #4# 0)
                                                           '(|PositiveInteger|)
                                                           #4#))
                                                        (QREFELT $ 92)))
                                                      (QCDR
                                                       (|SPADfirst|
                                                        |middlepol|)))
                                                    (SPADCALL
                                                     |middlelookuplist|
                                                     |j|
                                                     (QREFELT $ 88))
                                                    (EXIT
                                                     (COND
                                                       ((NULL
                                                         |taillookuplist|)
                                                        (SEQ
                                                         (LETT |pol|
                                                          (|FFPOLY;listToSUP|
                                                           (APPEND
                                                            |headpol|
                                                            (REVERSE
                                                             |middlepol|))
                                                           $) . #10#)
                                                         (EXIT
                                                          (COND
                                                            ((SPADCALL
                                                              |pol|
                                                              (QREFELT
                                                               $ 85))
                                                             (PROGN
                                                               (LETT
                                                                #5#
                                                                (CONS 0
                                                                 |pol|) . #10#)
                                                               (GO #5#)))))))
                                                       ('T
                                                        (SEQ
                                                         (LETT
                                                          |middlepol|
                                                          (CONS
                                                           (|SPADfirst|
                                                            |tailpol|)
                                                           |middlepol|) . #10#)
                                                         (LETT
                                                          |tailpol|
                                                          (CDR
                                                           |tailpol|) . #10#)
                                                         (LETT
                                                          |middlelookuplist|
                                                          (CONS
                                                           (|SPADfirst|
                                                            |taillookuplist|)
                                                           |middlelookuplist|) . #10#)
                                                         (EXIT
                                                          (LETT
                                                           |taillookuplist|
                                                           (CDR
                                                            |taillookuplist|) . #10#)))))))))))
                                              NIL #13# G191 (EXIT NIL))
                                             (EXIT
                                              (COND
                                                ((EQL |weight| |n1|)
                                                 (LETT |notReady|
                                                  'NIL . #10#))
                                                ('T
                                                 (SEQ
                                                  (COND
                                                    ((NULL |s|)
                                                     (SEQ
                                                      (LETT |restfcopy|
                                                       (CDR
                                                        (CDR |fcopy|)) . #10#)
                                                      (EXIT
                                                       (SEQ
                                                        (LETT |entry|
                                                         NIL . #10#)
                                                        (LETT #6#
                                                         |restfcopy| . #10#)
                                                        G190
                                                        (COND
                                                          ((OR
                                                            (ATOM #6#)
                                                            (PROGN
                                                              (LETT
                                                               |entry|
                                                               (CAR
                                                                #6#) . #10#)
                                                              NIL))
                                                           #12#))
                                                        (SEQ
                                                         (EXIT
                                                          (LETT |s|
                                                           (CONS
                                                            (QCAR
                                                             |entry|)
                                                            |s|) . #10#)))
                                                        (LETT #6#
                                                         (CDR #6#) . #10#)
                                                        #13# G191
                                                        (EXIT NIL))))))
                                                  (LETT |s1|
                                                   (PROG2
                                                    (LETT #7#
                                                     (|FFPOLY;nextSubset|
                                                      (CDR |s|) |n2| $) . #10#)
                                                    (QCDR #7#)
                                                     (|check-union|
                                                      (QEQCAR #7# 0)
                                                      (|List|
                                                       (|NonNegativeInteger|))
                                                      #7#)) . #10#)
                                                  (LETT |s|
                                                   (CONS 0 |s1|) . #10#)
                                                  (LETT |weight|
                                                   (SPADCALL |s|
                                                    (QREFELT $ 87)) . #10#)
                                                  (LETT
                                                   |taillookuplist|
                                                   NIL . #10#)
                                                  (LETT
                                                   |middlelookuplist|
                                                   (CONS (QREFELT $ 10)
                                                    (SPADCALL
                                                     (PROG1
                                                      (LETT #8#
                                                       (- |weight| 1) . #10#)
                                                       (|check-subtype|
                                                        (>= #8# 0)
                                                        '(|NonNegativeInteger|)
                                                        #8#))
                                                     1 (QREFELT $ 90))) . #10#)
                                                  (LETT |tailpol|
                                                   NIL . #10#)
                                                  (LETT |middlepol|
                                                   NIL . #10#)
                                                  (LETT |s1|
                                                   (REVERSE |s1|) . #10#)
                                                  (SEQ G190
                                                   (COND
                                                     ((NULL
                                                       (COND
                                                         ((NULL |s1|)
                                                          'NIL)
                                                         ('T 'T)))
                                                      #12#))
                                                   (SEQ
                                                    (LETT |middlepol|
                                                     (CONS
                                                      (CONS
                                                       (|SPADfirst|
                                                        |s1|)
                                                       (|spadConstant|
                                                        $ 13))
                                                      |middlepol|) . #10#)
                                                    (EXIT
                                                     (LETT |s1|
                                                      (CDR |s1|) . #10#)))
                                                   NIL #13# G191
                                                   (EXIT NIL))
                                                  (EXIT
                                                   (LETT |middlepol|
                                                    (CONS
                                                     (CONS 0
                                                      (|spadConstant| $
                                                       19))
                                                     |middlepol|) . #10#)))))))
                                            NIL #13# G191 (EXIT NIL))
                                           (LETT |l| (+ |l| 1) . #10#)
                                           (EXIT
                                            (LETT |a|
                                             (SPADCALL
                                              (PROG1
                                               (LETT #9# |l| . #10#)
                                                (|check-subtype|
                                                 (> #9# 0)
                                                 '(|PositiveInteger|)
                                                 #9#))
                                              (QREFELT $ 92)) . #10#)))
                                          NIL #13# G191 (EXIT NIL))
                                         (EXIT (CONS 1 "failed"))))))))))))
           #5# (EXIT #5#))))) 

(DEFUN |FFPOLY;nextNormalPrimitivePoly;SupU;14| (|f| $)
  (PROG (|n| |lcf| |fRepr| #0=#:G2393 |fcopy| |xn| |c0| #1=#:G2340 |q1|
             #2=#:G2341 #3=#:G2342 #4=#:G2345 |n1| #5=#:G2346 |n2| |a0|
             |noGenerator| #6=#:G2348 |constterm| |headpol| #7=#:G2353
             |term| |j| #8=#:G2363 |pol| #9=#:G2392 #10=#:G2364
             |notReady| |restfcopy| |entry| #11=#:G2394 #12=#:G2374 |s|
             |weight| |taillookuplist| #13=#:G2376 |middlelookuplist|
             |tailpol| |s1| |middlepol| #14=#:G2382 |lc| #15=#:G2385
             |c| |la| |a|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 12))
                            . #16=(|FFPOLY;nextNormalPrimitivePoly;SupU;14|))
                      (EXIT (COND
                              ((EQL |n| 0)
                               (|error| "polynomial must have positive degree"))
                              (#17='T
                               (SEQ (SEQ
                                     (LETT |lcf|
                                      (SPADCALL |f| (QREFELT $ 32)) . #16#)
                                     (EXIT
                                      (COND
                                        ((NULL
                                          (SPADCALL |lcf|
                                           (|spadConstant| $ 13)
                                           (QREFELT $ 59)))
                                         (LETT |f|
                                          (SPADCALL
                                           (SPADCALL |lcf|
                                            (QREFELT $ 89))
                                           |f| (QREFELT $ 33)) . #16#)))))
                                    (LETT |fRepr| |f| . #16#)
                                    (LETT |fcopy| NIL . #16#)
                                    (SEQ (LETT |term| NIL . #16#)
                                     (LETT #0# |fRepr| . #16#) G190
                                     (COND
                                       ((OR (ATOM #0#)
                                         (PROGN
                                           (LETT |term|
                                            (CAR #0#) . #16#)
                                           NIL))
                                        #18=(GO G191)))
                                     (SEQ
                                      (EXIT
                                       (LETT |fcopy|
                                        (CONS
                                         (CONS (CAR |term|)
                                          (CDR |term|))
                                         |fcopy|) . #16#)))
                                     (LETT #0# (CDR #0#) . #16#)
                                     #19=(GO G190) G191 (EXIT NIL))
                                    (COND
                                      ((NULL (EQL (QCAR |term|) 0))
                                       (SEQ
                                        (LETT |term|
                                         (CONS 0 (|spadConstant| $ 19)) . #16#)
                                        (EXIT
                                         (LETT |fcopy|
                                          (CONS |term| |fcopy|) . #16#)))))
                                    (LETT |fcopy|
                                     (REVERSE |fcopy|) . #16#)
                                    (LETT |xn|
                                     (|SPADfirst| |fcopy|) . #16#)
                                    (LETT |c0| (QCDR |term|) . #16#)
                                    (LETT |lc|
                                     (REMAINDER2
                                      (SPADCALL |c0| (QREFELT $ 91))
                                      (QREFELT $ 10)) . #16#)
                                    (EXIT
                                     (COND
                                       ((EQL |n| 1)
                                        (SEQ
                                         (LETT |q1|
                                          (PROG1
                                           (LETT #1#
                                            (- (QREFELT $ 10) 1) . #16#)
                                            (|check-subtype| (>= #1# 0)
                                             '(|NonNegativeInteger|)
                                             #1#)) . #16#)
                                         (SEQ G190
                                          (COND
                                            ((NULL (< |lc| |q1|)) #18#))
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (LETT |lc|
                                              (+ |lc| 1) . #16#)
                                             (LETT |c|
                                              (SPADCALL
                                               (PROG1
                                                (LETT #2# |lc| . #16#)
                                                 (|check-subtype|
                                                  (> #2# 0)
                                                  '(|PositiveInteger|)
                                                  #2#))
                                               (QREFELT $ 92)) . #16#)
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (SPADCALL |c|
                                                   (QREFELT $ 28))
                                                  (QREFELT $ 95))
                                                 (PROGN
                                                   (LETT #3#
                                                    (PROGN
                                                      (LETT #9#
                                                       (CONS 0
                                                        (LIST |xn|
                                                         (CONS 0 |c|))) . #16#)
                                                      (GO #9#)) . #16#)
                                                   (GO #3#)))))))
                                           #3# (EXIT #3#))
                                          NIL #19# G191 (EXIT NIL))
                                         (EXIT (CONS 1 "failed"))))
                                       (#17#
                                        (SEQ
                                         (LETT |n1|
                                          (PROG1
                                           (LETT #4# (- |n| 1) . #16#)
                                            (|check-subtype| (>= #4# 0)
                                             '(|NonNegativeInteger|)
                                             #4#)) . #16#)
                                         (LETT |n2|
                                          (PROG1
                                           (LETT #5# (- |n1| 1) . #16#)
                                            (|check-subtype| (>= #5# 0)
                                             '(|NonNegativeInteger|)
                                             #5#)) . #16#)
                                         (LETT |middlepol|
                                          (CDR |fcopy|) . #16#)
                                         (LETT |a0|
                                          (QCDR
                                           (|SPADfirst| |middlepol|)) . #16#)
                                         (LETT |la|
                                          (REMAINDER2
                                           (SPADCALL |a0|
                                            (QREFELT $ 91))
                                           (QREFELT $ 10)) . #16#)
                                         (LETT |c| |c0| . #16#)
                                         (LETT |a| |a0| . #16#)
                                         (COND
                                           ((EQL |la| 0)
                                            (SEQ (LETT |la| 1 . #16#)
                                             (EXIT
                                              (LETT |a|
                                               (|spadConstant| $ 13) . #16#)))))
                                         (SEQ G190
                                          (COND
                                            ((NULL
                                              (< |lc| (QREFELT $ 10)))
                                             #18#))
                                          (SEQ
                                           (LETT |noGenerator|
                                            'T . #16#)
                                           (SEQ G190
                                            (COND
                                              ((NULL
                                                (COND
                                                  (|noGenerator|
                                                   (< |lc|
                                                    (QREFELT $ 10)))
                                                  ('T 'NIL)))
                                               #18#))
                                            (SEQ
                                             (EXIT
                                              (COND
                                                ((SPADCALL
                                                  (SPADCALL
                                                   (EXPT -1 |n|) |c|
                                                   (QREFELT $ 96))
                                                  (QREFELT $ 95))
                                                 (LETT |noGenerator|
                                                  'NIL . #16#))
                                                ('T
                                                 (SEQ
                                                  (LETT |lc|
                                                   (+ |lc| 1) . #16#)
                                                  (EXIT
                                                   (LETT |c|
                                                    (SPADCALL
                                                     (PROG1
                                                      (LETT #6#
                                                       |lc| . #16#)
                                                       (|check-subtype|
                                                        (> #6# 0)
                                                        '(|PositiveInteger|)
                                                        #6#))
                                                     (QREFELT $ 92)) . #16#)))))))
                                            NIL #19# G191 (EXIT NIL))
                                           (EXIT
                                            (COND
                                              (|noGenerator|
                                               (PROGN
                                                 (LETT #9#
                                                  (CONS 1 "failed") . #16#)
                                                 (GO #9#)))
                                              ('T
                                               (SEQ
                                                (LETT |constterm|
                                                 (CONS 0 |c|) . #16#)
                                                (SEQ G190
                                                 (COND
                                                   ((NULL
                                                     (< |la|
                                                      (QREFELT $ 10)))
                                                    #18#))
                                                 (SEQ
                                                  (LETT |headpol|
                                                   (LIST |xn|
                                                    (CONS |n1| |a|)) . #16#)
                                                  (COND
                                                    ((SPADCALL |c| |c0|
                                                      (QREFELT $ 59))
                                                     (COND
                                                       ((SPADCALL |a|
                                                         |a0|
                                                         (QREFELT $ 59))
                                                        (SEQ
                                                         (LETT
                                                          |middlepol|
                                                          (CDR
                                                           (REVERSE
                                                            (CDR
                                                             |middlepol|))) . #16#)
                                                         (LETT |weight|
                                                          (+
                                                           (LENGTH
                                                            |middlepol|)
                                                           1) . #16#)
                                                         (LETT
                                                          |middlelookuplist|
                                                          (SPADCALL
                                                           (PROG1
                                                            (LETT #7#
                                                             (-
                                                              |weight|
                                                              1) . #16#)
                                                             (|check-subtype|
                                                              (>= #7#
                                                               0)
                                                              '(|NonNegativeInteger|)
                                                              #7#))
                                                           0
                                                           (QREFELT $
                                                            90)) . #16#)
                                                         (EXIT
                                                          (LETT |s|
                                                           NIL . #16#))))
                                                       ('T
                                                        (SEQ
                                                         (LETT |pol|
                                                          (|FFPOLY;listToSUP|
                                                           (APPEND
                                                            |headpol|
                                                            (LIST
                                                             |constterm|))
                                                           $) . #16#)
                                                         (COND
                                                           ((SPADCALL
                                                             |pol|
                                                             (QREFELT $
                                                              85))
                                                            (COND
                                                              ((SPADCALL
                                                                |pol|
                                                                (QREFELT
                                                                 $ 81))
                                                               (EXIT
                                                                (PROGN
                                                                  (LETT
                                                                   #9#
                                                                   (CONS
                                                                    0
                                                                    |pol|) . #16#)
                                                                  (GO
                                                                   #9#)))))))
                                                         (LETT
                                                          |middlepol|
                                                          (LIST
                                                           (CONS 1
                                                            (|spadConstant|
                                                             $ 19))) . #16#)
                                                         (LETT
                                                          |middlelookuplist|
                                                          (LIST
                                                           (QREFELT $
                                                            10)) . #16#)
                                                         (LETT |s|
                                                          (LIST 0 1) . #16#)
                                                         (EXIT
                                                          (LETT
                                                           |weight|
                                                           2 . #16#))))))
                                                    ('T
                                                     (SEQ
                                                      (LETT |pol|
                                                       (|FFPOLY;listToSUP|
                                                        (APPEND
                                                         |headpol|
                                                         (LIST
                                                          |constterm|))
                                                        $) . #16#)
                                                      (COND
                                                        ((SPADCALL
                                                          |pol|
                                                          (QREFELT $
                                                           85))
                                                         (COND
                                                           ((SPADCALL
                                                             |pol|
                                                             (QREFELT $
                                                              81))
                                                            (EXIT
                                                             (PROGN
                                                               (LETT
                                                                #9#
                                                                (CONS 0
                                                                 |pol|) . #16#)
                                                               (GO #9#)))))))
                                                      (LETT |middlepol|
                                                       (LIST
                                                        (CONS 1
                                                         (|spadConstant|
                                                          $ 19))) . #16#)
                                                      (LETT
                                                       |middlelookuplist|
                                                       (LIST
                                                        (QREFELT $ 10)) . #16#)
                                                      (LETT |s|
                                                       (LIST 0 1) . #16#)
                                                      (EXIT
                                                       (LETT |weight|
                                                        2 . #16#)))))
                                                  (LETT |tailpol|
                                                   NIL . #16#)
                                                  (LETT
                                                   |taillookuplist|
                                                   NIL . #16#)
                                                  (LETT |notReady|
                                                   'T . #16#)
                                                  (SEQ G190
                                                   (COND
                                                     ((NULL |notReady|)
                                                      #18#))
                                                   (SEQ
                                                    (SEQ G190
                                                     (COND
                                                       ((NULL
                                                         (COND
                                                           ((NULL
                                                             |middlelookuplist|)
                                                            'NIL)
                                                           ('T 'T)))
                                                        #18#))
                                                     (SEQ
                                                      (LETT |term|
                                                       (|SPADfirst|
                                                        |middlepol|) . #16#)
                                                      (LETT |j|
                                                       (|SPADfirst|
                                                        |middlelookuplist|) . #16#)
                                                      (COND
                                                        ((EQL |j| 0)
                                                         (LETT |j|
                                                          (SPADCALL
                                                           (QCDR
                                                            |term|)
                                                           (QREFELT $
                                                            91)) . #16#)))
                                                      (LETT |j|
                                                       (+ |j| 1) . #16#)
                                                      (EXIT
                                                       (COND
                                                         ((EQL
                                                           (REMAINDER2
                                                            |j|
                                                            (QREFELT $
                                                             10))
                                                           0)
                                                          (SEQ
                                                           (LETT
                                                            |tailpol|
                                                            (CONS
                                                             |term|
                                                             |tailpol|) . #16#)
                                                           (LETT
                                                            |middlepol|
                                                            (CDR
                                                             |middlepol|) . #16#)
                                                           (LETT
                                                            |taillookuplist|
                                                            (CONS |j|
                                                             |taillookuplist|) . #16#)
                                                           (EXIT
                                                            (LETT
                                                             |middlelookuplist|
                                                             (CDR
                                                              |middlelookuplist|) . #16#))))
                                                         ('T
                                                          (SEQ
                                                           (PROGN
                                                             (RPLACD
                                                              (|SPADfirst|
                                                               |middlepol|)
                                                              (SPADCALL
                                                               (PROG1
                                                                (LETT
                                                                 #8#
                                                                 |j| . #16#)
                                                                 (|check-subtype|
                                                                  (>
                                                                   #8#
                                                                   0)
                                                                  '(|PositiveInteger|)
                                                                  #8#))
                                                               (QREFELT
                                                                $ 92)))
                                                             (QCDR
                                                              (|SPADfirst|
                                                               |middlepol|)))
                                                           (SPADCALL
                                                            |middlelookuplist|
                                                            |j|
                                                            (QREFELT $
                                                             88))
                                                           (EXIT
                                                            (COND
                                                              ((NULL
                                                                |taillookuplist|)
                                                               (SEQ
                                                                (LETT
                                                                 |pol|
                                                                 (|FFPOLY;listToSUP|
                                                                  (APPEND
                                                                   |headpol|
                                                                   (REVERSE
                                                                    (CONS
                                                                     |constterm|
                                                                     |middlepol|)))
                                                                  $) . #16#)
                                                                (EXIT
                                                                 (COND
                                                                   ((SPADCALL
                                                                     |pol|
                                                                     (QREFELT
                                                                      $
                                                                      85))
                                                                    (SEQ
                                                                     (EXIT
                                                                      (COND
                                                                        ((SPADCALL
                                                                          |pol|
                                                                          (QREFELT
                                                                           $
                                                                           81))
                                                                         (PROGN
                                                                           (LETT
                                                                            #10#
                                                                            (PROGN
                                                                              (LETT
                                                                               #9#
                                                                               (CONS
                                                                                0
                                                                                |pol|) . #16#)
                                                                              (GO
                                                                               #9#)) . #16#)
                                                                           (GO
                                                                            #10#)))))
                                                                     #10#
                                                                     (EXIT
                                                                      #10#)))))))
                                                              ('T
                                                               (SEQ
                                                                (LETT
                                                                 |middlepol|
                                                                 (CONS
                                                                  (|SPADfirst|
                                                                   |tailpol|)
                                                                  |middlepol|) . #16#)
                                                                (LETT
                                                                 |tailpol|
                                                                 (CDR
                                                                  |tailpol|) . #16#)
                                                                (LETT
                                                                 |middlelookuplist|
                                                                 (CONS
                                                                  (|SPADfirst|
                                                                   |taillookuplist|)
                                                                  |middlelookuplist|) . #16#)
                                                                (EXIT
                                                                 (LETT
                                                                  |taillookuplist|
                                                                  (CDR
                                                                   |taillookuplist|) . #16#)))))))))))
                                                     NIL #19# G191
                                                     (EXIT NIL))
                                                    (EXIT
                                                     (COND
                                                       ((EQL |weight|
                                                         |n1|)
                                                        (LETT
                                                         |notReady|
                                                         'NIL . #16#))
                                                       ('T
                                                        (SEQ
                                                         (COND
                                                           ((NULL |s|)
                                                            (SEQ
                                                             (LETT
                                                              |restfcopy|
                                                              (CDR
                                                               (CDR
                                                                |fcopy|)) . #16#)
                                                             (EXIT
                                                              (SEQ
                                                               (LETT
                                                                |entry|
                                                                NIL . #16#)
                                                               (LETT
                                                                #11#
                                                                |restfcopy| . #16#)
                                                               G190
                                                               (COND
                                                                 ((OR
                                                                   (ATOM
                                                                    #11#)
                                                                   (PROGN
                                                                     (LETT
                                                                      |entry|
                                                                      (CAR
                                                                       #11#) . #16#)
                                                                     NIL))
                                                                  #18#))
                                                               (SEQ
                                                                (EXIT
                                                                 (LETT
                                                                  |s|
                                                                  (CONS
                                                                   (QCAR
                                                                    |entry|)
                                                                   |s|) . #16#)))
                                                               (LETT
                                                                #11#
                                                                (CDR
                                                                 #11#) . #16#)
                                                               #19#
                                                               G191
                                                               (EXIT
                                                                NIL))))))
                                                         (LETT |s1|
                                                          (PROG2
                                                           (LETT #12#
                                                            (|FFPOLY;nextSubset|
                                                             (CDR |s|)
                                                             |n2| $) . #16#)
                                                           (QCDR #12#)
                                                            (|check-union|
                                                             (QEQCAR
                                                              #12# 0)
                                                             (|List|
                                                              (|NonNegativeInteger|))
                                                             #12#)) . #16#)
                                                         (LETT |s|
                                                          (CONS 0 |s1|) . #16#)
                                                         (LETT |weight|
                                                          (SPADCALL |s|
                                                           (QREFELT $
                                                            87)) . #16#)
                                                         (LETT
                                                          |taillookuplist|
                                                          NIL . #16#)
                                                         (LETT
                                                          |middlelookuplist|
                                                          (CONS
                                                           (QREFELT $
                                                            10)
                                                           (SPADCALL
                                                            (PROG1
                                                             (LETT #13#
                                                              (-
                                                               |weight|
                                                               2) . #16#)
                                                              (|check-subtype|
                                                               (>= #13#
                                                                0)
                                                               '(|NonNegativeInteger|)
                                                               #13#))
                                                            1
                                                            (QREFELT $
                                                             90))) . #16#)
                                                         (LETT
                                                          |tailpol|
                                                          NIL . #16#)
                                                         (LETT
                                                          |middlepol|
                                                          (LIST
                                                           (CONS
                                                            (|SPADfirst|
                                                             |s1|)
                                                            (|spadConstant|
                                                             $ 19))) . #16#)
                                                         (SEQ G190
                                                          (COND
                                                            ((NULL
                                                              (COND
                                                                ((NULL
                                                                  (LETT
                                                                   |s1|
                                                                   (CDR
                                                                    |s1|) . #16#))
                                                                 'NIL)
                                                                ('T 'T)))
                                                             #18#))
                                                          (SEQ
                                                           (EXIT
                                                            (LETT
                                                             |middlepol|
                                                             (CONS
                                                              (CONS
                                                               (|SPADfirst|
                                                                |s1|)
                                                               (|spadConstant|
                                                                $ 13))
                                                              |middlepol|) . #16#)))
                                                          NIL #19# G191
                                                          (EXIT NIL))
                                                         (EXIT
                                                          (LETT
                                                           |middlepol|
                                                           (REVERSE
                                                            |middlepol|) . #16#)))))))
                                                   NIL #19# G191
                                                   (EXIT NIL))
                                                  (LETT |la|
                                                   (+ |la| 1) . #16#)
                                                  (EXIT
                                                   (LETT |a|
                                                    (SPADCALL
                                                     (PROG1
                                                      (LETT #14#
                                                       |la| . #16#)
                                                       (|check-subtype|
                                                        (> #14# 0)
                                                        '(|PositiveInteger|)
                                                        #14#))
                                                     (QREFELT $ 92)) . #16#)))
                                                 NIL #19# G191
                                                 (EXIT NIL))
                                                (LETT |lc|
                                                 (+ |lc| 1) . #16#)
                                                (LETT |c|
                                                 (SPADCALL
                                                  (PROG1
                                                   (LETT #15#
                                                    |lc| . #16#)
                                                    (|check-subtype|
                                                     (> #15# 0)
                                                     '(|PositiveInteger|)
                                                     #15#))
                                                  (QREFELT $ 92)) . #16#)
                                                (LETT |la| 1 . #16#)
                                                (EXIT
                                                 (LETT |a|
                                                  (|spadConstant| $ 13) . #16#)))))))
                                          NIL #19# G191 (EXIT NIL))
                                         (EXIT (CONS 1 "failed"))))))))))))
           #9# (EXIT #9#))))) 

(DEFUN |FFPOLY;nextPrimitiveNormalPoly;SupU;15| (|f| $)
  (SPADCALL |f| (QREFELT $ 99))) 

(DEFUN |FFPOLY;createIrreduciblePoly;PiSup;16| (|n| $)
  (PROG (|x| |xn| #0=#:G2400)
    (RETURN
      (SEQ (LETT |x| (SPADCALL (|spadConstant| $ 13) 1 (QREFELT $ 16))
                 . #1=(|FFPOLY;createIrreduciblePoly;PiSup;16|))
           (EXIT (COND
                   ((EQL |n| 1) |x|)
                   (#2='T
                    (SEQ (LETT |xn|
                               (SPADCALL (|spadConstant| $ 13) |n|
                                   (QREFELT $ 16)) . #1#)
                         (EXIT (COND
                                 ((< |n| (QREFELT $ 10))
                                  (COND
                                    ((ODDP |n|)
                                     (PROG2
                                      (LETT #0#
                                       (SPADCALL
                                        (SPADCALL |xn|
                                         (|spadConstant| $ 24)
                                         (QREFELT $ 34))
                                        (QREFELT $ 94)) . #1#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (|SparseUnivariatePolynomial|
                                         (QREFELT $ 6))
                                        #0#)))
                                    ('T
                                     (PROG2
                                      (LETT #0#
                                       (SPADCALL |xn| (QREFELT $ 94)) . #1#)
                                      (QCDR #0#)
                                       (|check-union| (QEQCAR #0# 0)
                                        (|SparseUnivariatePolynomial|
                                         (QREFELT $ 6))
                                        #0#)))))
                                 (#2#
                                  (PROG2 (LETT #0#
                                          (SPADCALL
                                           (SPADCALL |xn| |x|
                                            (QREFELT $ 34))
                                           (QREFELT $ 94)) . #1#)
                                         (QCDR #0#)
                                    (|check-union| (QEQCAR #0# 0)
                                     (|SparseUnivariatePolynomial|
                                      (QREFELT $ 6))
                                     #0#))))))))))))) 

(DEFUN |FFPOLY;createPrimitivePoly;PiSup;17| (|n| $)
  (PROG (|xn| |c0| |constterm| #0=#:G2407 |n1| |polRepr| |pol|
              #1=#:G2422 |notReady| #2=#:G2412 |s1| |s| |weight|
              #3=#:G2418)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |xn|
                            (SPADCALL (|spadConstant| $ 13) |n|
                                (QREFELT $ 16))
                            . #4=(|FFPOLY;createPrimitivePoly;PiSup;17|))
                      (EXIT (COND
                              ((EQL |n| 1)
                               (SPADCALL |xn|
                                         (SPADCALL
                                          (SPADCALL
                                           (SPADCALL (QREFELT $ 102))
                                           (QREFELT $ 28))
                                          0 (QREFELT $ 16))
                                         (QREFELT $ 34)))
                              ('T
                               (SEQ (LETT |c0|
                                     (SPADCALL (EXPT -1 |n|)
                                      (SPADCALL (QREFELT $ 102))
                                      (QREFELT $ 96)) . #4#)
                                    (LETT |constterm|
                                     (CONS 0 |c0|) . #4#)
                                    (LETT |s| (LIST 0 1) . #4#)
                                    (LETT |weight| 2 . #4#)
                                    (LETT |s1| (LIST 1) . #4#)
                                    (LETT |n1|
                                     (PROG1 (LETT #0# (- |n| 1) . #4#)
                                       (|check-subtype| (>= #0# 0)
                                        '(|NonNegativeInteger|) #0#)) . #4#)
                                    (LETT |notReady| 'T . #4#)
                                    (SEQ G190
                                     (COND
                                       ((NULL |notReady|) #5=(GO G191)))
                                     (SEQ
                                      (LETT |polRepr|
                                       (LIST |constterm|) . #4#)
                                      (SEQ G190
                                       (COND
                                         ((NULL
                                           (COND
                                             ((NULL |s1|) 'NIL)
                                             ('T 'T)))
                                          #5#))
                                       (SEQ
                                        (LETT |polRepr|
                                         (CONS
                                          (CONS (|SPADfirst| |s1|)
                                           (|spadConstant| $ 13))
                                          |polRepr|) . #4#)
                                        (EXIT
                                         (LETT |s1| (CDR |s1|) . #4#)))
                                       NIL #6=(GO G190) G191
                                       (EXIT NIL))
                                      (LETT |polRepr|
                                       (CONS
                                        (CONS |n|
                                         (|spadConstant| $ 13))
                                        |polRepr|) . #4#)
                                      (EXIT
                                       (COND
                                         ((SPADCALL
                                           (LETT |pol|
                                            (|FFPOLY;listToSUP|
                                             |polRepr| $) . #4#)
                                           (QREFELT $ 81))
                                          (PROGN
                                            (LETT #1# |pol| . #4#)
                                            (GO #1#)))
                                         ((EQL |weight| |n|)
                                          (LETT |notReady| 'NIL . #4#))
                                         ('T
                                          (SEQ
                                           (LETT |s1|
                                            (PROG2
                                             (LETT #2#
                                              (|FFPOLY;nextSubset|
                                               (CDR |s|) |n1| $) . #4#)
                                             (QCDR #2#)
                                              (|check-union|
                                               (QEQCAR #2# 0)
                                               (|List|
                                                (|NonNegativeInteger|))
                                               #2#)) . #4#)
                                           (LETT |s|
                                            (CONS 0 |s1|) . #4#)
                                           (EXIT
                                            (LETT |weight|
                                             (SPADCALL |s|
                                              (QREFELT $ 87)) . #4#)))))))
                                     NIL #6# G191 (EXIT NIL))
                                    (EXIT
                                     (PROG2
                                      (LETT #3#
                                       (SPADCALL
                                        (SPADCALL |xn|
                                         (SPADCALL |c0| 0
                                          (QREFELT $ 16))
                                         (QREFELT $ 34))
                                        (QREFELT $ 97)) . #4#)
                                      (QCDR #3#)
                                       (|check-union| (QEQCAR #3# 0)
                                        (|SparseUnivariatePolynomial|
                                         (QREFELT $ 6))
                                        #3#)))))))))
           #1# (EXIT #1#))))) 

(DEFUN |FFPOLY;createNormalPoly;PiSup;18| (|n| $)
  (PROG (#0=#:G2424 #1=#:G2426)
    (RETURN
      (COND
        ((EQL |n| 1)
         (SPADCALL (SPADCALL (|spadConstant| $ 13) 1 (QREFELT $ 16))
             (SPADCALL (SPADCALL (|spadConstant| $ 13) (QREFELT $ 28))
                 0 (QREFELT $ 16))
             (QREFELT $ 34)))
        ('T
         (PROG2 (LETT #1#
                      (SPADCALL
                          (SPADCALL
                              (SPADCALL (|spadConstant| $ 13) |n|
                                  (QREFELT $ 16))
                              (SPADCALL
                                  (SPADCALL (|spadConstant| $ 13)
                                      (QREFELT $ 28))
                                  (PROG1 (LETT #0# (- |n| 1)
                                          . #2=(|FFPOLY;createNormalPoly;PiSup;18|))
                                    (|check-subtype| (>= #0# 0)
                                     '(|NonNegativeInteger|) #0#))
                                  (QREFELT $ 16))
                              (QREFELT $ 34))
                          (QREFELT $ 98)) . #2#)
                (QCDR #1#)
           (|check-union| (QEQCAR #1# 0)
               (|SparseUnivariatePolynomial| (QREFELT $ 6)) #1#))))))) 

(DEFUN |FFPOLY;createNormalPrimitivePoly;PiSup;19| (|n| $)
  (PROG (|xn| #0=#:G2429 |n1| |c0| |constterm| |res| |pol| #1=#:G2433)
    (RETURN
      (SEQ (LETT |xn|
                 (SPADCALL (|spadConstant| $ 13) |n| (QREFELT $ 16))
                 . #2=(|FFPOLY;createNormalPrimitivePoly;PiSup;19|))
           (EXIT (COND
                   ((EQL |n| 1)
                    (SPADCALL |xn|
                        (SPADCALL
                            (SPADCALL (SPADCALL (QREFELT $ 102))
                                (QREFELT $ 28))
                            0 (QREFELT $ 16))
                        (QREFELT $ 34)))
                   (#3='T
                    (SEQ (LETT |n1|
                               (PROG1 (LETT #0# (- |n| 1) . #2#)
                                 (|check-subtype| (>= #0# 0)
                                     '(|NonNegativeInteger|) #0#)) . #2#)
                         (LETT |c0|
                               (SPADCALL (EXPT -1 |n|)
                                   (SPADCALL (QREFELT $ 102))
                                   (QREFELT $ 96)) . #2#)
                         (LETT |constterm|
                               (SPADCALL |c0| 0 (QREFELT $ 16)) . #2#)
                         (LETT |pol|
                               (SPADCALL
                                   (SPADCALL |xn|
                                    (SPADCALL
                                     (SPADCALL (|spadConstant| $ 13)
                                      (QREFELT $ 28))
                                     |n1| (QREFELT $ 16))
                                    (QREFELT $ 34))
                                   |constterm| (QREFELT $ 34)) . #2#)
                         (COND
                           ((SPADCALL |pol| (QREFELT $ 85))
                            (COND
                              ((SPADCALL |pol| (QREFELT $ 81))
                               (EXIT |pol|)))))
                         (LETT |res|
                               (SPADCALL |pol| (QREFELT $ 99)) . #2#)
                         (EXIT (COND
                                 ((QEQCAR |res| 0) (QCDR |res|))
                                 (#3#
                                  (SEQ (LETT |pol|
                                        (SPADCALL
                                         (SPADCALL |xn|
                                          (SPADCALL
                                           (|spadConstant| $ 13) |n1|
                                           (QREFELT $ 16))
                                          (QREFELT $ 34))
                                         |constterm| (QREFELT $ 34)) . #2#)
                                       (COND
                                         ((SPADCALL |pol|
                                           (QREFELT $ 85))
                                          (COND
                                            ((SPADCALL |pol|
                                              (QREFELT $ 81))
                                             (EXIT |pol|)))))
                                       (EXIT
                                        (PROG2
                                         (LETT #1#
                                          (SPADCALL |pol|
                                           (QREFELT $ 99)) . #2#)
                                         (QCDR #1#)
                                          (|check-union| (QEQCAR #1# 0)
                                           (|SparseUnivariatePolynomial|
                                            (QREFELT $ 6))
                                           #1#))))))))))))))) 

(DEFUN |FFPOLY;createPrimitiveNormalPoly;PiSup;20| (|n| $)
  (SPADCALL |n| (QREFELT $ 105))) 

(DEFUN |FFPOLY;random;PiSup;21| (|n| $)
  (PROG (#0=#:G2443 |n1| |i| |c| |polRepr|)
    (RETURN
      (SEQ (LETT |polRepr| NIL . #1=(|FFPOLY;random;PiSup;21|))
           (LETT |n1|
                 (PROG1 (LETT #0# (- |n| 1) . #1#)
                   (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                       #0#)) . #1#)
           (SEQ (LETT |i| 0 . #1#) G190
                (COND ((QSGREATERP |i| |n1|) (GO G191)))
                (SEQ (LETT |c| (SPADCALL (QREFELT $ 107)) . #1#)
                     (EXIT (COND
                             ((NULL (SPADCALL |c| (|spadConstant| $ 19)
                                     (QREFELT $ 59)))
                              (LETT |polRepr|
                                    (CONS (CONS |i| |c|) |polRepr|) . #1#)))))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (EXIT (CONS (CONS |n| (|spadConstant| $ 13)) |polRepr|)))))) 

(DEFUN |FFPOLY;random;2PiSup;22| (|m| |n| $)
  (PROG (|#G63| |#G64| #0=#:G2448 |d| #1=#:G2449)
    (RETURN
      (SEQ (COND
             ((< |n| |m|)
              (PROGN
                (LETT |#G63| |n| . #2=(|FFPOLY;random;2PiSup;22|))
                (LETT |#G64| |m| . #2#)
                (LETT |m| |#G63| . #2#)
                (LETT |n| |#G64| . #2#))))
           (LETT |d|
                 (PROG1 (LETT #0# (- |n| |m|) . #2#)
                   (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                       #0#)) . #2#)
           (COND
             ((< 1 |d|)
              (LETT |n|
                    (PROG1 (LETT #1# (+ (RANDOM |d|) |m|) . #2#)
                      (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                          #1#)) . #2#)))
           (EXIT (SPADCALL |n| (QREFELT $ 108))))))) 

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

(DEFUN |FiniteFieldPolynomialPackage;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$| #0=#:G1869)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #1=(|FiniteFieldPolynomialPackage|))
        (LETT |dv$| (LIST '|FiniteFieldPolynomialPackage| DV$1) . #1#)
        (LETT $ (GETREFV 110) . #1#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
        (|haddProp| |$ConstructorCache| '|FiniteFieldPolynomialPackage|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7
            (|ModMonic| |#1| (|SparseUnivariatePolynomial| |#1|)))
        (QSETREFV $ 10
            (PROG1 (LETT #0# (SPADCALL (QREFELT $ 9)) . #1#)
              (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#)))
        $)))) 

(MAKEPROP '|FiniteFieldPolynomialPackage| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) 'MM
             (|NonNegativeInteger|) (0 . |size|) '|sizeGF|
             (|SparseUnivariatePolynomial| 6) (4 . |degree|)
             (9 . |One|) (13 . |One|) (17 . |setPoly|)
             (22 . |monomial|) (28 . |reduce|) (33 . **) (39 . |Zero|)
             (43 . |Zero|) (47 . |Zero|) (|PrimitiveArray| 11)
             (51 . |new|) (57 . |One|) (61 . *) (67 . |lift|)
             (72 . |coefficient|) (78 . -) (83 . |coerce|) (|Boolean|)
             (88 . =) (94 . |leadingCoefficient|) (99 . *) (105 . +)
             (111 . |reductum|) |FFPOLY;reducedQPowers;SupPa;3|
             (|Vector| 6) (116 . |vectorise|) (|List| 6)
             (122 . |entries|) (|List| 39) (|Matrix| 6)
             (127 . |matrix|) (132 . |transpose|) (137 . |new|)
             (|ModMonic| 6 11) (144 . |One|) (|Fraction| 7)
             (148 . |One|) (|Fraction| 11) (152 . |One|) (|Integer|)
             (156 . |setelt|) (164 . |horizConcat|) (|List| 37)
             (170 . |nullSpace|) (175 . |elt|) (181 . |elt|) (187 . =)
             (|Fraction| 46) (193 . |One|)
             |FFPOLY;leastAffineMultiple;2Sup;4|
             (|IntegerNumberTheoryFunctions|) (197 . |moebiusMu|)
             (|List| 52) (202 . |divisors|) (|PositiveInteger|)
             (207 . **) |FFPOLY;numberOfIrreduciblePoly;2Pi;5|
             (213 . |eulerPhi|) |FFPOLY;numberOfPrimitivePoly;2Pi;6|
             (218 . |characteristic|) |FFPOLY;numberOfNormalPoly;2Pi;7|
             (222 . **) (|Factored| $) (228 . |factor|)
             (|Record| (|:| |factor| 52) (|:| |exponent| 52))
             (|List| 77) (|Factored| 52) (233 . |factors|)
             |FFPOLY;primitive?;SupB;8|
             (|DistinctDegreeFactorize| 6 11) (238 . |irreducible?|)
             (243 . |rank|) |FFPOLY;normal?;SupB;9| (|List| 8)
             (248 . |#|) (253 . |setfirst!|) (259 . |inv|)
             (264 . |new|) (270 . |lookup|) (275 . |index|)
             (|Union| 11 '"failed")
             |FFPOLY;nextIrreduciblePoly;SupU;11| (280 . |primitive?|)
             (285 . *) |FFPOLY;nextPrimitivePoly;SupU;12|
             |FFPOLY;nextNormalPoly;SupU;13|
             |FFPOLY;nextNormalPrimitivePoly;SupU;14|
             |FFPOLY;nextPrimitiveNormalPoly;SupU;15|
             |FFPOLY;createIrreduciblePoly;PiSup;16|
             (291 . |primitiveElement|)
             |FFPOLY;createPrimitivePoly;PiSup;17|
             |FFPOLY;createNormalPoly;PiSup;18|
             |FFPOLY;createNormalPrimitivePoly;PiSup;19|
             |FFPOLY;createPrimitiveNormalPoly;PiSup;20|
             (295 . |random|) |FFPOLY;random;PiSup;21|
             |FFPOLY;random;2PiSup;22|)
          '#(|reducedQPowers| 299 |random| 304 |primitive?| 315
             |numberOfPrimitivePoly| 320 |numberOfNormalPoly| 325
             |numberOfIrreduciblePoly| 330 |normal?| 335
             |nextPrimitivePoly| 340 |nextPrimitiveNormalPoly| 345
             |nextNormalPrimitivePoly| 350 |nextNormalPoly| 355
             |nextIrreduciblePoly| 360 |leastAffineMultiple| 365
             |createPrimitivePoly| 370 |createPrimitiveNormalPoly| 375
             |createNormalPrimitivePoly| 380 |createNormalPoly| 385
             |createIrreduciblePoly| 390)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 109
                                '(0 6 8 9 1 11 8 0 12 0 6 0 13 0 7 0 14
                                  1 7 11 11 15 2 11 0 6 8 16 1 7 0 11
                                  17 2 7 0 0 8 18 0 6 0 19 0 7 0 20 0
                                  11 0 21 2 22 0 8 11 23 0 11 0 24 2 7
                                  0 0 0 25 1 7 11 0 26 2 11 6 0 8 27 1
                                  6 0 0 28 1 11 0 6 29 2 11 30 0 0 31 1
                                  11 6 0 32 2 11 0 6 0 33 2 11 0 0 0 34
                                  1 11 0 0 35 2 11 37 0 8 38 1 37 39 0
                                  40 1 42 0 41 43 1 42 0 0 44 3 42 0 8
                                  8 6 45 0 46 0 47 0 48 0 49 0 50 0 51
                                  4 42 6 0 52 52 6 53 2 42 0 0 0 54 1
                                  42 55 0 56 2 55 37 0 52 57 2 37 6 0
                                  52 58 2 6 30 0 0 59 0 60 0 61 1 63 52
                                  52 64 1 63 65 52 66 2 67 0 0 67 68 1
                                  63 52 52 70 0 6 8 72 2 7 0 0 67 74 1
                                  52 75 0 76 1 79 78 0 80 1 82 30 11 83
                                  1 42 8 0 84 1 86 8 0 87 2 86 8 0 8 88
                                  1 6 0 0 89 2 86 0 8 8 90 1 6 67 0 91
                                  1 6 0 67 92 1 6 30 0 95 2 6 0 52 0 96
                                  0 6 0 102 0 6 0 107 1 0 22 11 36 1 0
                                  11 67 108 2 0 11 67 67 109 1 0 30 11
                                  81 1 0 67 67 71 1 0 67 67 73 1 0 67
                                  67 69 1 0 30 11 85 1 0 93 11 97 1 0
                                  93 11 100 1 0 93 11 99 1 0 93 11 98 1
                                  0 93 11 94 1 0 11 11 62 1 0 11 67 103
                                  1 0 11 67 106 1 0 11 67 105 1 0 11 67
                                  104 1 0 11 67 101)))))
          '|lookupComplete|)) 
