
(/VERSIONCHECK 2) 

(DEFUN |FFF;createLowComplexityNormalBasis;PiU;1| (|n| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (LETT |u| (SPADCALL |n| (QREFELT $ 10))
            |FFF;createLowComplexityNormalBasis;PiU;1|)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 0 (SPADCALL |n| (QREFELT $ 13))))
             ('T (CONS 1 (QCDR |u|))))))))) 

(DEFUN |FFF;createLowComplexityTable;PiU;2| (|n| $)
  (PROG (|l| |term| |j| |v| |i| |multtable| |m| |lvjh| |help| |lvj| |x| |vec|
         |vt| |jt| |t| |pkn| |p1| |multmat| #1=#:G691 |t1| |k| |a| #2=#:G722
         |p| |q|)
    (RETURN
     (SEQ
      (LETT |q| (SPADCALL (QREFELT $ 17))
            . #3=(|FFF;createLowComplexityTable;PiU;2|))
      (LETT |p| (SPADCALL (QREFELT $ 18)) . #3#) (LETT |k| 0 . #3#)
      (SEQ (LETT |i| 1 . #3#) (LETT #2# (- |n| 1) . #3#) G190
           (COND ((OR (QSGREATERP |i| #2#) (NULL (EQL |k| 0))) #4=(GO G191)))
           (SEQ
            (EXIT
             (COND
              ((SPADCALL (+ (* |i| |n|) 1) (QREFELT $ 23))
               (COND
                ((NULL (EQL |p| (+ (* |i| |n|) 1)))
                 (COND
                  ((SPADCALL
                    (SPADCALL |q|
                              (|compiledLookupCheck| '|coerce|
                                                     (LIST '$
                                                           (LIST '|Integer|))
                                                     (|PrimeField|
                                                      (+ (* |i| |n|)
                                                         (|One|)))))
                    (|compiledLookupCheck| '|primitive?|
                                           (LIST (LIST '|Boolean|) '$)
                                           (|PrimeField|
                                            (+ (* |i| |n|) (|One|)))))
                   (SEQ (LETT |a| 1 . #3#) (LETT |k| |i| . #3#)
                        (EXIT
                         (LETT |t1|
                               (SPADCALL
                                (SPADCALL |q|
                                          (|compiledLookupCheck| '|coerce|
                                                                 (LIST '$
                                                                       (LIST
                                                                        '|Integer|))
                                                                 (|PrimeField|
                                                                  (+
                                                                   (* |k| |n|)
                                                                   (|One|)))))
                                |n|
                                (|compiledLookupCheck| '^
                                                       (LIST '$ '$
                                                             (LIST '|Integer|))
                                                       (|PrimeField|
                                                        (+ (* |k| |n|)
                                                           (|One|)))))
                               . #3#))))
                  ('T
                   (SEQ
                    (EXIT
                     (COND
                      ((EQL
                        (GCD |n|
                             (LETT |a|
                                   (SPADCALL
                                    (SPADCALL |q|
                                              (|compiledLookupCheck| '|coerce|
                                                                     (LIST '$
                                                                           (LIST
                                                                            '|Integer|))
                                                                     (|PrimeField|
                                                                      (+
                                                                       (* |n|
                                                                          |i|)
                                                                       (|One|)))))
                                    (|compiledLookupCheck| '|discreteLog|
                                                           (LIST
                                                            (LIST
                                                             '|NonNegativeInteger|)
                                                            '$)
                                                           (|PrimeField|
                                                            (+ (* |n| |i|)
                                                               (|One|)))))
                                   . #3#))
                        1)
                       (PROGN
                        (LETT #1#
                              (SEQ (LETT |k| |i| . #3#)
                                   (EXIT
                                    (LETT |t1|
                                          (SPADCALL
                                           (SPADCALL
                                            (|compiledLookupCheck|
                                             '|primitiveElement| (LIST '$)
                                             (|PrimeField|
                                              (+ (* |k| |n|) (|One|)))))
                                           |n|
                                           (|compiledLookupCheck| '^
                                                                  (LIST '$ '$
                                                                        (LIST
                                                                         '|Integer|))
                                                                  (|PrimeField|
                                                                   (+
                                                                    (* |i| |n|)
                                                                    (|One|)))))
                                          . #3#)))
                              . #3#)
                        (GO #1#)))))
                    #1# (EXIT #1#))))))))))
           (LETT |i| (QSADD1 |i|) . #3#) #5=(GO G190) G191 (EXIT NIL))
      (EXIT
       (COND ((EQL |k| 0) (CONS 1 "failed"))
             (#6='T
              (SEQ
               (LETT |multmat|
                     (SPADCALL |n| |n|
                               (|compiledLookupCheck| '|zero|
                                                      (LIST '$
                                                            (LIST
                                                             '|NonNegativeInteger|)
                                                            (LIST
                                                             '|NonNegativeInteger|))
                                                      (|Matrix|
                                                       (|PrimeField| |p|))))
                     . #3#)
               (LETT |p1| (+ (* |k| |n|) 1) . #3#)
               (LETT |pkn|
                     (SPADCALL |q|
                               (|compiledLookupCheck| '|coerce|
                                                      (LIST '$
                                                            (LIST '|Integer|))
                                                      (|PrimeField| |p1|)))
                     . #3#)
               (LETT |t| |t1| . #3#)
               (COND
                ((ODDP |k|)
                 (SEQ (LETT |jt| (+ (QUOTIENT2 |n| 2) 1) . #3#)
                      (EXIT
                       (LETT |vt|
                             (+
                              (SPADCALL (QUOTIENT2 (- |k| |a|) 2) |k|
                                        (QREFELT $ 24))
                              1)
                             . #3#))))
                (#6#
                 (SEQ (LETT |jt| 1 . #3#)
                      (EXIT (LETT |vt| (+ (QUOTIENT2 |k| 2) 1) . #3#)))))
               (LETT |vec| (SPADCALL |p1| (QREFELT $ 26)) . #3#)
               (SEQ (LETT |x| 1 . #3#) G190 (COND ((QSGREATERP |x| |k|) #4#))
                    (SEQ
                     (EXIT
                      (SEQ (LETT |l| 1 . #3#) G190
                           (COND ((QSGREATERP |l| |n|) #4#))
                           (SEQ
                            (EXIT
                             (SPADCALL |vec|
                                       (+
                                        (SPADCALL
                                         (SPADCALL |t| (- |x| 1)
                                                   (|compiledLookupCheck| '^
                                                                          (LIST
                                                                           '$
                                                                           '$
                                                                           (LIST
                                                                            '|Integer|))
                                                                          (|PrimeField|
                                                                           |p1|)))
                                         (SPADCALL |pkn| (- |l| 1)
                                                   (|compiledLookupCheck| '^
                                                                          (LIST
                                                                           '$
                                                                           '$
                                                                           (LIST
                                                                            '|Integer|))
                                                                          (|PrimeField|
                                                                           |p1|)))
                                         (|compiledLookupCheck| '*
                                                                (LIST '$ '$ '$)
                                                                (|PrimeField|
                                                                 (+ (* |k| |n|)
                                                                    (|One|)))))
                                        1)
                                       (SPADCALL |l| |p1| (QREFELT $ 24))
                                       (QREFELT $ 27))))
                           (LETT |l| (QSADD1 |l|) . #3#) #5# G191 (EXIT NIL))))
                    (LETT |x| (QSADD1 |x|) . #3#) #5# G191 (EXIT NIL))
               (LETT |lvj| (SPADCALL |k| |n| (QREFELT $ 29)) . #3#)
               (SEQ (LETT |v| 1 . #3#) G190 (COND ((QSGREATERP |v| |k|) #4#))
                    (SEQ
                     (EXIT
                      (SEQ (LETT |j| 1 . #3#) G190
                           (COND ((QSGREATERP |j| |n|) #4#))
                           (SEQ
                            (EXIT
                             (COND
                              ((EQL |j| |jt|)
                               (COND
                                ((NULL (EQL |v| |vt|))
                                 (SEQ
                                  (LETT |help|
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |t| (- |v| 1)
                                                    (|compiledLookupCheck| '^
                                                                           (LIST
                                                                            '$
                                                                            '$
                                                                            (LIST
                                                                             '|Integer|))
                                                                           (|PrimeField|
                                                                            |p1|)))
                                          (SPADCALL |pkn| (- |j| 1)
                                                    (|compiledLookupCheck| '^
                                                                           (LIST
                                                                            '$
                                                                            '$
                                                                            (LIST
                                                                             '|Integer|))
                                                                           (|PrimeField|
                                                                            |p1|)))
                                          (|compiledLookupCheck| '*
                                                                 (LIST '$ '$
                                                                       '$)
                                                                 (|PrimeField|
                                                                  |p1|)))
                                         (SPADCALL
                                          (|compiledLookupCheck| '|One|
                                                                 (LIST '$)
                                                                 (|PrimeField|
                                                                  |p1|)))
                                         (|compiledLookupCheck| '+
                                                                (LIST '$ '$ '$)
                                                                (|PrimeField|
                                                                 |p1|)))
                                        . #3#)
                                  (EXIT
                                   (SPADCALL |lvj| |v| |j|
                                             (SPADCALL |vec| (+ |help| 1)
                                                       (QREFELT $ 30))
                                             (QREFELT $ 31)))))))
                              ('T
                               (SEQ
                                (LETT |help|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL |t| (- |v| 1)
                                                  (|compiledLookupCheck| '^
                                                                         (LIST
                                                                          '$ '$
                                                                          (LIST
                                                                           '|Integer|))
                                                                         (|PrimeField|
                                                                          |p1|)))
                                        (SPADCALL |pkn| (- |j| 1)
                                                  (|compiledLookupCheck| '^
                                                                         (LIST
                                                                          '$ '$
                                                                          (LIST
                                                                           '|Integer|))
                                                                         (|PrimeField|
                                                                          |p1|)))
                                        (|compiledLookupCheck| '*
                                                               (LIST '$ '$ '$)
                                                               (|PrimeField|
                                                                |p1|)))
                                       (SPADCALL
                                        (|compiledLookupCheck| '|One| (LIST '$)
                                                               (|PrimeField|
                                                                |p1|)))
                                       (|compiledLookupCheck| '+
                                                              (LIST '$ '$ '$)
                                                              (|PrimeField|
                                                               |p1|)))
                                      . #3#)
                                (EXIT
                                 (SPADCALL |lvj| |v| |j|
                                           (SPADCALL |vec| (+ |help| 1)
                                                     (QREFELT $ 30))
                                           (QREFELT $ 31))))))))
                           (LETT |j| (QSADD1 |j|) . #3#) #5# G191 (EXIT NIL))))
                    (LETT |v| (QSADD1 |v|) . #3#) #5# G191 (EXIT NIL))
               (SEQ (LETT |j| 1 . #3#) G190 (COND ((QSGREATERP |j| |n|) #4#))
                    (SEQ
                     (EXIT
                      (COND
                       ((NULL (EQL |j| |jt|))
                        (SEQ (LETT |v| 1 . #3#) G190
                             (COND ((QSGREATERP |v| |k|) #4#))
                             (SEQ
                              (LETT |lvjh|
                                    (SPADCALL |lvj| |v| |j| (QREFELT $ 32))
                                    . #3#)
                              (EXIT
                               (SPADCALL |multmat| |j| |lvjh|
                                         (SPADCALL
                                          (SPADCALL |multmat| |j| |lvjh|
                                                    (|compiledLookupCheck|
                                                     '|elt|
                                                     (LIST
                                                      (LIST '|PrimeField| |p|)
                                                      '$ (LIST '|Integer|)
                                                      (LIST '|Integer|))
                                                     (|Matrix|
                                                      (|PrimeField| |p|))))
                                          (SPADCALL
                                           (|compiledLookupCheck| '|One|
                                                                  (LIST '$)
                                                                  (|PrimeField|
                                                                   |p|)))
                                          (|compiledLookupCheck| '+
                                                                 (LIST '$ '$
                                                                       '$)
                                                                 (|PrimeField|
                                                                  |p|)))
                                         (|compiledLookupCheck| '|setelt|
                                                                (LIST
                                                                 (LIST
                                                                  '|PrimeField|
                                                                  |p|)
                                                                 '$
                                                                 (LIST
                                                                  '|Integer|)
                                                                 (LIST
                                                                  '|Integer|)
                                                                 (LIST
                                                                  '|PrimeField|
                                                                  |p|))
                                                                (|Matrix|
                                                                 (|PrimeField|
                                                                  |p|))))))
                             (LETT |v| (QSADD1 |v|) . #3#) #5# G191
                             (EXIT NIL))))))
                    (LETT |j| (QSADD1 |j|) . #3#) #5# G191 (EXIT NIL))
               (SEQ (LETT |i| 1 . #3#) G190 (COND ((QSGREATERP |i| |n|) #4#))
                    (SEQ
                     (EXIT
                      (SPADCALL |multmat| |jt| |i|
                                (SPADCALL (SPADCALL (- |k|) |p| (QREFELT $ 24))
                                          (|compiledLookupCheck| '|coerce|
                                                                 (LIST '$
                                                                       (LIST
                                                                        '|Integer|))
                                                                 (|PrimeField|
                                                                  |p|)))
                                (|compiledLookupCheck| '|setelt|
                                                       (LIST
                                                        (LIST '|PrimeField|
                                                              |p|)
                                                        '$ (LIST '|Integer|)
                                                        (LIST '|Integer|)
                                                        (LIST '|PrimeField|
                                                              |p|))
                                                       (|Matrix|
                                                        (|PrimeField| |p|))))))
                    (LETT |i| (QSADD1 |i|) . #3#) #5# G191 (EXIT NIL))
               (SEQ (LETT |v| 1 . #3#) G190 (COND ((QSGREATERP |v| |k|) #4#))
                    (SEQ
                     (EXIT
                      (COND
                       ((NULL (EQL |v| |vt|))
                        (SEQ
                         (LETT |lvjh| (SPADCALL |lvj| |v| |jt| (QREFELT $ 32))
                               . #3#)
                         (EXIT
                          (SPADCALL |multmat| |jt| |lvjh|
                                    (SPADCALL
                                     (SPADCALL |multmat| |jt| |lvjh|
                                               (|compiledLookupCheck| '|elt|
                                                                      (LIST
                                                                       (LIST
                                                                        '|PrimeField|
                                                                        |p|)
                                                                       '$
                                                                       (LIST
                                                                        '|Integer|)
                                                                       (LIST
                                                                        '|Integer|))
                                                                      (|Matrix|
                                                                       (|PrimeField|
                                                                        |p|))))
                                     (SPADCALL
                                      (|compiledLookupCheck| '|One| (LIST '$)
                                                             (|PrimeField|
                                                              |p|)))
                                     (|compiledLookupCheck| '+ (LIST '$ '$ '$)
                                                            (|PrimeField|
                                                             |p|)))
                                    (|compiledLookupCheck| '|setelt|
                                                           (LIST
                                                            (LIST '|PrimeField|
                                                                  |p|)
                                                            '$
                                                            (LIST '|Integer|)
                                                            (LIST '|Integer|)
                                                            (LIST '|PrimeField|
                                                                  |p|))
                                                           (|Matrix|
                                                            (|PrimeField|
                                                             |p|))))))))))
                    (LETT |v| (QSADD1 |v|) . #3#) #5# G191 (EXIT NIL))
               (LETT |m|
                     (SPADCALL |multmat|
                               (|compiledLookupCheck| '|nrows|
                                                      (LIST
                                                       (LIST
                                                        '|NonNegativeInteger|)
                                                       '$)
                                                      (|Matrix|
                                                       (|PrimeField| |p|))))
                     . #3#)
               (LETT |multtable| (SPADCALL |m| NIL (QREFELT $ 35)) . #3#)
               (SEQ (LETT |i| 1 . #3#) G190 (COND ((QSGREATERP |i| |m|) #4#))
                    (SEQ (LETT |l| NIL . #3#)
                         (LETT |v|
                               (SPADCALL |multmat| |i|
                                         (|compiledLookupCheck| '|row|
                                                                (LIST
                                                                 (LIST
                                                                  '|Vector|
                                                                  (LIST
                                                                   '|PrimeField|
                                                                   |p|))
                                                                 '$
                                                                 (LIST
                                                                  '|Integer|))
                                                                (|Matrix|
                                                                 (|PrimeField|
                                                                  |p|))))
                               . #3#)
                         (SEQ (LETT |j| 1 . #3#) G190
                              (COND ((QSGREATERP |j| |m|) #4#))
                              (SEQ
                               (EXIT
                                (COND
                                 ((NULL
                                   (SPADCALL
                                    (SPADCALL |v| |j|
                                              (|compiledLookupCheck| '|elt|
                                                                     (LIST
                                                                      (LIST
                                                                       '|PrimeField|
                                                                       |p|)
                                                                      '$
                                                                      (LIST
                                                                       '|Integer|))
                                                                     (|Vector|
                                                                      (|PrimeField|
                                                                       |p|))))
                                    (SPADCALL
                                     (|compiledLookupCheck| '|Zero| (LIST '$)
                                                            (|PrimeField|
                                                             |p|)))
                                    (|compiledLookupCheck| '=
                                                           (LIST
                                                            (LIST '|Boolean|)
                                                            '$ '$)
                                                           (|PrimeField|
                                                            |p|))))
                                  (SEQ
                                   (LETT |term|
                                         (CONS
                                          (SPADCALL
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |v| |j|
                                                       (|compiledLookupCheck|
                                                        '|elt|
                                                        (LIST
                                                         (LIST '|PrimeField|
                                                               |p|)
                                                         '$ (LIST '|Integer|))
                                                        (|Vector|
                                                         (|PrimeField| |p|))))
                                             (|compiledLookupCheck| '-
                                                                    (LIST '$
                                                                          '$)
                                                                    (|PrimeField|
                                                                     |p|)))
                                            (|compiledLookupCheck| '|convert|
                                                                   (LIST
                                                                    (LIST
                                                                     '|Integer|)
                                                                    '$)
                                                                   (|PrimeField|
                                                                    |p|)))
                                           (QREFELT $ 36))
                                          (- |j| 2))
                                         . #3#)
                                   (EXIT
                                    (LETT |l| (CONS |term| |l|) . #3#)))))))
                              (LETT |j| (QSADD1 |j|) . #3#) #5# G191
                              (EXIT NIL))
                         (EXIT
                          (SPADCALL |multtable| |i|
                                    (SPADCALL |l| (QREFELT $ 37))
                                    (QREFELT $ 38))))
                    (LETT |i| (QSADD1 |i|) . #3#) #5# G191 (EXIT NIL))
               (EXIT (CONS 0 |multtable|)))))))))) 

(DEFUN |FFF;sizeMultiplication;VNni;3| (|m| $)
  (PROG (|s| #1=#:G729 |i|)
    (RETURN
     (SEQ (LETT |s| 0 . #2=(|FFF;sizeMultiplication;VNni;3|))
          (SEQ (LETT |i| 1 . #2#) (LETT #1# (QVSIZE |m|) . #2#) G190
               (COND ((QSGREATERP |i| #1#) (GO G191)))
               (SEQ
                (EXIT
                 (LETT |s| (+ |s| (LENGTH (SPADCALL |m| |i| (QREFELT $ 39))))
                       . #2#)))
               (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT |s|))))) 

(DEFUN |FFF;createMultiplicationTable;SupV;4| (|f| $)
  (PROG (|l| |term| #1=#:G755 |j| |v| |i| |multtable| |mat| #2=#:G740 |mat1|
         |h| |g| |qexp| |w| |qpow| |e| |m1| |m| |sizeGF|)
    (RETURN
     (SEQ
      (LETT |sizeGF| (SPADCALL (QREFELT $ 17))
            . #3=(|FFF;createMultiplicationTable;SupV;4|))
      (LETT |m| (SPADCALL |f| (QREFELT $ 41)) . #3#)
      (EXIT
       (COND
        ((EQL |m| 1)
         (VECTOR
          (LIST
           (CONS (SPADCALL (SPADCALL |f| 0 (QREFELT $ 44)) (QREFELT $ 45))
                 -1))))
        (#4='T
         (SEQ (LETT |m1| (- |m| 1) . #3#) (SPADCALL |f| (QREFELT $ 47))
              (LETT |e|
                    (SPADCALL
                     (SPADCALL
                      (SPADCALL (|spadConstant| $ 19) 1 (QREFELT $ 48))
                      (QREFELT $ 49))
                     |sizeGF| (QREFELT $ 50))
                    . #3#)
              (LETT |w| (|spadConstant| $ 51) . #3#)
              (LETT |qpow| (SPADCALL |m| (|spadConstant| $ 52) (QREFELT $ 54))
                    . #3#)
              (SETELT |qpow| 0 (|spadConstant| $ 51))
              (SEQ (LETT |i| 1 . #3#) G190
                   (COND ((QSGREATERP |i| |m1|) #5=(GO G191)))
                   (SEQ
                    (EXIT
                     (SETELT |qpow| |i|
                             (LETT |w| (SPADCALL |w| |e| (QREFELT $ 55))
                                   . #3#))))
                   (LETT |i| (QSADD1 |i|) . #3#) #6=(GO G190) G191 (EXIT NIL))
              (LETT |qexp| (SPADCALL |m| (|spadConstant| $ 52) (QREFELT $ 54))
                    . #3#)
              (SETELT |qexp| 0
                      (SPADCALL
                       (SPADCALL (|spadConstant| $ 19) 1 (QREFELT $ 48))
                       (QREFELT $ 49)))
              (LETT |mat| (SPADCALL |m| |m| (QREFELT $ 57)) . #3#)
              (SPADCALL |mat| 2 1 (|spadConstant| $ 19) (QREFELT $ 58))
              (LETT |h| (ELT |qpow| 1) . #3#) (SETELT |qexp| 1 |h|)
              (SPADCALL |mat| 2 (SPADCALL |h| (QREFELT $ 60)) (QREFELT $ 61))
              (SEQ (LETT |i| 2 . #3#) G190 (COND ((QSGREATERP |i| |m1|) #5#))
                   (SEQ (LETT |g| (|spadConstant| $ 52) . #3#)
                        (SEQ G190
                             (COND
                              ((NULL
                                (COND
                                 ((SPADCALL |h| (|spadConstant| $ 52)
                                            (QREFELT $ 62))
                                  'NIL)
                                 ('T 'T)))
                               #5#))
                             (SEQ
                              (LETT |g|
                                    (SPADCALL |g|
                                              (SPADCALL
                                               (SPADCALL |h| (QREFELT $ 63))
                                               (ELT |qpow|
                                                    (SPADCALL |h|
                                                              (QREFELT $ 64)))
                                               (QREFELT $ 65))
                                              (QREFELT $ 66))
                                    . #3#)
                              (EXIT
                               (LETT |h| (SPADCALL |h| (QREFELT $ 67)) . #3#)))
                             NIL #6# G191 (EXIT NIL))
                        (SETELT |qexp| |i| |g|)
                        (EXIT
                         (SPADCALL |mat| (+ |i| 1)
                                   (SPADCALL (LETT |h| |g| . #3#)
                                             (QREFELT $ 60))
                                   (QREFELT $ 61))))
                   (LETT |i| (QSADD1 |i|) . #3#) #6# G191 (EXIT NIL))
              (LETT |mat1| (SPADCALL |mat| (QREFELT $ 69)) . #3#)
              (EXIT
               (COND
                ((SPADCALL |mat1| (CONS 1 "failed") (QREFELT $ 71))
                 (|error|
                  "createMultiplicationTable: polynomial must be normal"))
                (#4#
                 (SEQ
                  (LETT |mat|
                        (PROG2
                            (LETT #2# |mat1| . #3#)
                            (QCDR #2#)
                          (|check-union| (QEQCAR #2# 0)
                                         (|Matrix| (QREFELT $ 6)) #2#))
                        . #3#)
                  (LETT |multtable| (SPADCALL |m| NIL (QREFELT $ 35)) . #3#)
                  (SEQ (LETT |i| 1 . #3#) G190
                       (COND ((QSGREATERP |i| |m|) #5#))
                       (SEQ (LETT |l| NIL . #3#)
                            (LETT |v|
                                  (SPADCALL |mat|
                                            (SPADCALL
                                             (SPADCALL (ELT |qexp| (- |i| 1))
                                                       (ELT |qexp| 0)
                                                       (QREFELT $ 55))
                                             (QREFELT $ 60))
                                            (QREFELT $ 72))
                                  . #3#)
                            (SEQ (LETT |j| 1 . #3#)
                                 (LETT #1# (SPADCALL |m| (QREFELT $ 74)) . #3#)
                                 G190 (COND ((QSGREATERP |j| #1#) #5#))
                                 (SEQ
                                  (EXIT
                                   (COND
                                    ((NULL
                                      (SPADCALL
                                       (SPADCALL |v| |j| (QREFELT $ 75))
                                       (|spadConstant| $ 20) (QREFELT $ 76)))
                                     (SEQ
                                      (LETT |term|
                                            (CONS
                                             (SPADCALL |v| |j| (QREFELT $ 75))
                                             (QSDIFFERENCE |j| 2))
                                            . #3#)
                                      (EXIT
                                       (LETT |l| (CONS |term| |l|) . #3#)))))))
                                 (LETT |j| (QSADD1 |j|) . #3#) #6# G191
                                 (EXIT NIL))
                            (EXIT
                             (SPADCALL |multtable| |i|
                                       (SPADCALL |l| (QREFELT $ 37))
                                       (QREFELT $ 38))))
                       (LETT |i| (QSADD1 |i|) . #3#) #6# G191 (EXIT NIL))
                  (EXIT |multtable|))))))))))))) 

(DEFUN |FFF;createZechTable;SupPa;5| (|f| $)
  (PROG (|a| #1=#:G769 |i| #2=#:G768 #3=#:G767 |primElement| |helparr|
         |zechlog| |qm1| |m| #4=#:G756 |sizeGF|)
    (RETURN
     (SEQ
      (LETT |sizeGF| (SPADCALL (QREFELT $ 17))
            . #5=(|FFF;createZechTable;SupPa;5|))
      (LETT |m|
            (PROG1 (LETT #4# (SPADCALL |f| (QREFELT $ 41)) . #5#)
              (|check-subtype| (> #4# 0) '(|PositiveInteger|) #4#))
            . #5#)
      (LETT |qm1| (- (SPADCALL |sizeGF| |m| (QREFELT $ 78)) 1) . #5#)
      (LETT |zechlog|
            (SPADCALL
             (QUOTIENT2 (+ (SPADCALL |sizeGF| |m| (QREFELT $ 78)) 1) 2) -1
             (QREFELT $ 80))
            . #5#)
      (LETT |helparr| (SPADCALL (EXPT |sizeGF| |m|) 0 (QREFELT $ 80)) . #5#)
      (LETT |primElement|
            (SPADCALL (SPADCALL (|spadConstant| $ 19) 1 (QREFELT $ 48))
                      (|compiledLookupCheck| '|reduce|
                                             (LIST '$
                                                   (LIST
                                                    '|SparseUnivariatePolynomial|
                                                    (|devaluate| (ELT $ 6))))
                                             (|SimpleAlgebraicExtension|
                                              (ELT $ 6)
                                              (|SparseUnivariatePolynomial|
                                               (ELT $ 6))
                                              |f|)))
            . #5#)
      (LETT |a| |primElement| . #5#)
      (SEQ (LETT |i| 1 . #5#) (LETT #3# (QSDIFFERENCE |qm1| 1) . #5#) G190
           (COND ((QSGREATERP |i| #3#) #6=(GO G191)))
           (SEQ
            (SETELT |helparr|
                    (SPADCALL
                     (SPADCALL |a|
                               (SPADCALL
                                (|compiledLookupCheck| '|One| (LIST '$)
                                                       (|SimpleAlgebraicExtension|
                                                        (ELT $ 6)
                                                        (|SparseUnivariatePolynomial|
                                                         (ELT $ 6))
                                                        |f|)))
                               (|compiledLookupCheck| '- (LIST '$ '$ '$)
                                                      (|SimpleAlgebraicExtension|
                                                       (ELT $ 6)
                                                       (|SparseUnivariatePolynomial|
                                                        (ELT $ 6))
                                                       |f|)))
                     (|compiledLookupCheck| '|lookup|
                                            (LIST (LIST '|PositiveInteger|) '$)
                                            (|SimpleAlgebraicExtension|
                                             (ELT $ 6)
                                             (|SparseUnivariatePolynomial|
                                              (ELT $ 6))
                                             |f|)))
                    (SPADCALL |i| (QREFELT $ 74)))
            (EXIT
             (LETT |a|
                   (SPADCALL |a| |primElement|
                             (|compiledLookupCheck| '* (LIST '$ '$ '$)
                                                    (|SimpleAlgebraicExtension|
                                                     (ELT $ 6)
                                                     (|SparseUnivariatePolynomial|
                                                      (ELT $ 6))
                                                     |f|)))
                   . #5#)))
           (LETT |i| (QSADD1 |i|) . #5#) #7=(GO G190) G191 (EXIT NIL))
      (EXIT
       (COND
        ((EQL (SPADCALL (QREFELT $ 18)) 2)
         (SEQ (LETT |a| |primElement| . #5#)
              (SEQ (LETT |i| 1 . #5#) (LETT #2# (QSQUOTIENT |qm1| 2) . #5#)
                   G190 (COND ((QSGREATERP |i| #2#) #6#))
                   (SEQ
                    (SETELT |zechlog| |i|
                            (ELT |helparr|
                                 (SPADCALL |a|
                                           (|compiledLookupCheck| '|lookup|
                                                                  (LIST
                                                                   (LIST
                                                                    '|PositiveInteger|)
                                                                   '$)
                                                                  (|SimpleAlgebraicExtension|
                                                                   (ELT $ 6)
                                                                   (|SparseUnivariatePolynomial|
                                                                    (ELT $ 6))
                                                                   |f|)))))
                    (EXIT
                     (LETT |a|
                           (SPADCALL |a| |primElement|
                                     (|compiledLookupCheck| '* (LIST '$ '$ '$)
                                                            (|SimpleAlgebraicExtension|
                                                             (ELT $ 6)
                                                             (|SparseUnivariatePolynomial|
                                                              (ELT $ 6))
                                                             |f|)))
                           . #5#)))
                   (LETT |i| (QSADD1 |i|) . #5#) #7# G191 (EXIT NIL))
              (EXIT |zechlog|)))
        ('T
         (SEQ
          (LETT |a|
                (SPADCALL
                 (|compiledLookupCheck| '|One| (LIST '$)
                                        (|SimpleAlgebraicExtension| (ELT $ 6)
                                                                    (|SparseUnivariatePolynomial|
                                                                     (ELT $ 6))
                                                                    |f|)))
                . #5#)
          (SEQ (LETT |i| 0 . #5#)
               (LETT #1# (QSQUOTIENT (QSDIFFERENCE |qm1| 2) 2) . #5#) G190
               (COND ((QSGREATERP |i| #1#) #6#))
               (SEQ
                (SETELT |zechlog| |i|
                        (ELT |helparr|
                             (SPADCALL |a|
                                       (|compiledLookupCheck| '|lookup|
                                                              (LIST
                                                               (LIST
                                                                '|PositiveInteger|)
                                                               '$)
                                                              (|SimpleAlgebraicExtension|
                                                               (ELT $ 6)
                                                               (|SparseUnivariatePolynomial|
                                                                (ELT $ 6))
                                                               |f|)))))
                (EXIT
                 (LETT |a|
                       (SPADCALL |a| |primElement|
                                 (|compiledLookupCheck| '* (LIST '$ '$ '$)
                                                        (|SimpleAlgebraicExtension|
                                                         (ELT $ 6)
                                                         (|SparseUnivariatePolynomial|
                                                          (ELT $ 6))
                                                         |f|)))
                       . #5#)))
               (LETT |i| (QSADD1 |i|) . #5#) #7# G191 (EXIT NIL))
          (EXIT |zechlog|))))))))) 

(DEFUN |FFF;createMultiplicationMatrix;VM;6| (|m| $)
  (PROG (#1=#:G776 |t| |i| |mat| |n|)
    (RETURN
     (SEQ (LETT |n| (QVSIZE |m|) . #2=(|FFF;createMultiplicationMatrix;VM;6|))
          (LETT |mat| (SPADCALL |n| |n| (QREFELT $ 57)) . #2#)
          (SEQ (LETT |i| 1 . #2#) G190
               (COND ((QSGREATERP |i| |n|) #3=(GO G191)))
               (SEQ
                (EXIT
                 (SEQ (LETT |t| NIL . #2#)
                      (LETT #1# (SPADCALL |m| |i| (QREFELT $ 39)) . #2#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |t| (CAR #1#) . #2#) NIL))
                        #3#))
                      (SEQ
                       (EXIT
                        (SPADCALL |mat| |i| (QSPLUS (QCDR |t|) 2) (QCAR |t|)
                                  (QREFELT $ 58))))
                      (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191
                      (EXIT NIL))))
               (LETT |i| (QSADD1 |i|) . #2#) #4# G191 (EXIT NIL))
          (EXIT |mat|))))) 

(DEFUN |FiniteFieldFunctions| (#1=#:G777)
  (PROG ()
    (RETURN
     (PROG (#2=#:G778)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|FiniteFieldFunctions|)
                                           '|domainEqualList|)
                . #3=(|FiniteFieldFunctions|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT
              (PROG1 (|FiniteFieldFunctions;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|FiniteFieldFunctions|))))))))))) 

(DEFUN |FiniteFieldFunctions;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|FiniteFieldFunctions|))
      (LETT |dv$| (LIST '|FiniteFieldFunctions| DV$1) . #1#)
      (LETT $ (GETREFV 86) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|FiniteFieldFunctions| (LIST DV$1)
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      $)))) 

(MAKEPROP '|FiniteFieldFunctions| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|)
              (|Record| (|:| |value| 6) (|:| |index| 73))
              (|Union| 34 '"failed") (|PositiveInteger|)
              |FFF;createLowComplexityTable;PiU;2|
              (|SparseUnivariatePolynomial| 6)
              (|FiniteFieldPolynomialPackage| 6) (0 . |createNormalPoly|)
              (|Union| 11 34) |FFF;createLowComplexityNormalBasis;PiU;1|
              (|NonNegativeInteger|) (5 . |size|) (9 . |characteristic|)
              (13 . |One|) (17 . |Zero|) (|Boolean|) (|Integer|)
              (21 . |prime?|) (26 . |positiveRemainder|) (|Vector| 22)
              (32 . |zero|) (37 . |setelt|) (|Matrix| 22) (44 . |zero|)
              (50 . |elt|) (56 . |setelt|) (64 . |elt|) (|List| 7)
              (|Vector| 33) (71 . |new|) (77 . |coerce|) (82 . |copy|)
              (87 . |qsetelt!|) (94 . |elt|) |FFF;sizeMultiplication;VNni;3|
              (100 . |degree|) (105 . |One|) (109 . |Zero|)
              (113 . |coefficient|) (119 . -) (|ModMonic| 6 11)
              (124 . |setPoly|) (129 . |monomial|) (135 . |reduce|) (140 . ^)
              (146 . |One|) (150 . |Zero|) (|PrimitiveArray| 46) (154 . |new|)
              (160 . *) (|Matrix| 6) (166 . |zero|) (172 . |qsetelt!|)
              (|Vector| 6) (180 . |Vectorise|) (185 . |setColumn!|) (192 . =)
              (198 . |leadingCoefficient|) (203 . |degree|) (208 . *) (214 . +)
              (220 . |reductum|) (|Union| $ '#1="failed") (225 . |inverse|)
              (|Union| 56 '#1#) (230 . =) (236 . *) (|SingleInteger|)
              (242 . |coerce|) (247 . |elt|) (253 . =)
              |FFF;createMultiplicationTable;SupV;4| (259 . ^)
              (|PrimitiveArray| 73) (265 . |new|) (271 . |characteristic|)
              (|Fraction| 11) (275 . |characteristic|)
              |FFF;createZechTable;SupPa;5|
              |FFF;createMultiplicationMatrix;VM;6|)
           '#(|sizeMultiplication| 279 |createZechTable| 284
              |createMultiplicationTable| 289 |createMultiplicationMatrix| 294
              |createLowComplexityTable| 299 |createLowComplexityNormalBasis|
              304)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 85
                                                 '(1 12 11 9 13 0 6 16 17 0 6
                                                   16 18 0 6 0 19 0 6 0 20 1 22
                                                   21 0 23 2 22 0 0 0 24 1 25 0
                                                   16 26 3 25 22 0 22 22 27 2
                                                   28 0 16 16 29 2 25 22 0 22
                                                   30 4 28 22 0 22 22 22 31 3
                                                   28 22 0 22 22 32 2 34 0 16
                                                   33 35 1 6 0 22 36 1 33 0 0
                                                   37 3 34 33 0 22 33 38 2 34
                                                   33 0 22 39 1 11 16 0 41 0 11
                                                   0 42 0 11 0 43 2 11 6 0 16
                                                   44 1 6 0 0 45 1 46 11 11 47
                                                   2 11 0 6 16 48 1 46 0 11 49
                                                   2 46 0 0 16 50 0 46 0 51 0
                                                   46 0 52 2 53 0 16 46 54 2 46
                                                   0 0 0 55 2 56 0 16 16 57 4
                                                   56 6 0 22 22 6 58 1 46 59 0
                                                   60 3 56 0 0 22 59 61 2 46 21
                                                   0 0 62 1 46 6 0 63 1 46 16 0
                                                   64 2 46 0 6 0 65 2 46 0 0 0
                                                   66 1 46 0 0 67 1 56 68 0 69
                                                   2 70 21 0 0 71 2 56 59 0 59
                                                   72 1 73 0 22 74 2 59 6 0 22
                                                   75 2 6 21 0 0 76 2 16 0 0 9
                                                   78 2 79 0 16 73 80 0 11 16
                                                   81 0 82 16 83 1 0 16 34 40 1
                                                   0 79 11 84 1 0 34 11 77 1 0
                                                   56 34 85 1 0 8 9 10 1 0 14 9
                                                   15)))))
           '|lookupComplete|)) 
