
(/VERSIONCHECK 2) 

(DEFUN |IRSN;aIdInverse| ($)
  (PROG (#1=#:G1852 #2=#:G1832 #3=#:G1822 |i| #4=#:G1862 |k| #5=#:G1819
         #6=#:G1815 |j| #7=#:G1861 |l| #8=#:G1860 |idperm| #9=#:G1858
         #10=#:G1859)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SETELT $ 17 (SPADCALL (QREFELT $ 7) (QREFELT $ 7) 0 (QREFELT $ 16)))
        (SEQ (LETT |k| 1 . #11=(|IRSN;aIdInverse|))
             (LETT #10# (QREFELT $ 7) . #11#) G190
             (COND ((QSGREATERP |k| #10#) #12=(GO G191)))
             (SEQ (EXIT (SPADCALL (QREFELT $ 17) |k| |k| 1 (QREFELT $ 18))))
             (LETT |k| (QSADD1 |k|) . #11#) #13=(GO G190) G191 (EXIT NIL))
        (COND
         ((< (QREFELT $ 10) 5)
          (PROGN (LETT #9# (QREFELT $ 17) . #11#) (GO #9#))))
        (LETT |idperm| NIL . #11#)
        (SEQ (LETT |k| (QREFELT $ 10) . #11#) G190 (COND ((< |k| 1) #12#))
             (SEQ (EXIT (LETT |idperm| (CONS |k| |idperm|) . #11#)))
             (LETT |k| (+ |k| -1) . #11#) #13# G191 (EXIT NIL))
        (SEQ (LETT |k| 1 . #11#) (LETT #8# (- (QREFELT $ 7) 1) . #11#) G190
             (COND ((QSGREATERP |k| #8#) #12#))
             (SEQ
              (EXIT
               (SEQ (LETT |l| (+ |k| 1) . #11#) (LETT #7# (QREFELT $ 7) . #11#)
                    G190 (COND ((> |l| #7#) #12#))
                    (SEQ
                     (EXIT
                      (SPADCALL (QREFELT $ 17) |k| |l|
                                (|IRSN;signum| |k| |l| |idperm| $)
                                (QREFELT $ 18))))
                    (LETT |l| (+ |l| 1) . #11#) #13# G191 (EXIT NIL))))
             (LETT |k| (QSADD1 |k|) . #11#) #13# G191 (EXIT NIL))
        (EXIT
         (SEQ (LETT |j| (QREFELT $ 7) . #11#) G190 (COND ((< |j| 2) #12#))
              (SEQ
               (SEQ (LETT |i| (- |j| 1) . #11#) G190 (COND ((< |i| 1) #12#))
                    (SEQ
                     (EXIT
                      (SPADCALL (QREFELT $ 17)
                                (PROG1 (LETT #6# |i| . #11#)
                                  (|check-subtype| (>= #6# 0)
                                                   '(|NonNegativeInteger|)
                                                   #6#))
                                |j|
                                (-
                                 (SPADCALL (QREFELT $ 17)
                                           (PROG1 (LETT #5# |i| . #11#)
                                             (|check-subtype| (>= #5# 0)
                                                              '(|NonNegativeInteger|)
                                                              #5#))
                                           |j| (QREFELT $ 19)))
                                (QREFELT $ 18))))
                    (LETT |i| (+ |i| -1) . #11#) #13# G191 (EXIT NIL))
               (EXIT
                (SEQ (LETT |k| (+ |j| 1) . #11#)
                     (LETT #4# (QREFELT $ 7) . #11#) G190
                     (COND ((> |k| #4#) #12#))
                     (SEQ
                      (EXIT
                       (SEQ (LETT |i| (- |j| 1) . #11#) G190
                            (COND ((< |i| 1) #12#))
                            (SEQ
                             (EXIT
                              (SPADCALL (QREFELT $ 17)
                                        (PROG1 (LETT #3# |i| . #11#)
                                          (|check-subtype| (>= #3# 0)
                                                           '(|NonNegativeInteger|)
                                                           #3#))
                                        |k|
                                        (+
                                         (SPADCALL (QREFELT $ 17)
                                                   (PROG1 (LETT #2# |i| . #11#)
                                                     (|check-subtype|
                                                      (>= #2# 0)
                                                      '(|NonNegativeInteger|)
                                                      #2#))
                                                   |k| (QREFELT $ 19))
                                         (*
                                          (SPADCALL (QREFELT $ 17)
                                                    (PROG1
                                                        (LETT #1# |i| . #11#)
                                                      (|check-subtype|
                                                       (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                                    |j| (QREFELT $ 19))
                                          (SPADCALL (QREFELT $ 17) |j| |k|
                                                    (QREFELT $ 19))))
                                        (QREFELT $ 18))))
                            (LETT |i| (+ |i| -1) . #11#) #13# G191
                            (EXIT NIL))))
                     (LETT |k| (+ |k| 1) . #11#) #13# G191 (EXIT NIL))))
              (LETT |j| (+ |j| -1) . #11#) #13# G191 (EXIT NIL)))))
      #9# (EXIT #9#))))) 

(DEFUN |IRSN;alreadyComputed?| (|lambda| $)
  (PROG (#1=#:G1875 #2=#:G1873 #3=#:G1872 #4=#:G1874 #5=#:G1878 #6=#:G1792
         #7=#:G1868 #8=#:G1867)
    (RETURN
     (SEQ
      (COND
       ((NULL (SPADCALL |lambda| (QREFELT $ 6) (QREFELT $ 22)))
        (SEQ (SETELT $ 6 |lambda|)
             (SETELT $ 9 (SPADCALL |lambda| (QREFELT $ 24)))
             (SETELT $ 11
                     (PROG1
                         (LETT #8# (|SPADfirst| (QREFELT $ 9))
                               . #9=(|IRSN;alreadyComputed?|))
                       (|check-subtype| (>= #8# 0) '(|NonNegativeInteger|)
                                        #8#)))
             (SETELT $ 12
                     (PROG1 (LETT #7# (|SPADfirst| |lambda|) . #9#)
                       (|check-subtype| (>= #7# 0) '(|NonNegativeInteger|)
                                        #7#)))
             (SETELT $ 10
                     (PROG1
                         (LETT #1#
                               (PROGN
                                (LETT #2# NIL . #9#)
                                (SEQ (LETT #6# NIL . #9#)
                                     (LETT #5# |lambda| . #9#) G190
                                     (COND
                                      ((OR (ATOM #5#)
                                           (PROGN
                                            (LETT #6# (CAR #5#) . #9#)
                                            NIL))
                                       (GO G191)))
                                     (SEQ
                                      (EXIT
                                       (PROGN
                                        (LETT #4# #6# . #9#)
                                        (COND
                                         (#2# (LETT #3# (+ #3# #4#) . #9#))
                                         ('T
                                          (PROGN
                                           (LETT #3# #4# . #9#)
                                           (LETT #2# 'T . #9#)))))))
                                     (LETT #5# (CDR #5#) . #9#) (GO G190) G191
                                     (EXIT NIL))
                                (COND (#2# #3#) ('T 0)))
                               . #9#)
                       (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                        #1#)))
             (SETELT $ 8 (SPADCALL |lambda| (QREFELT $ 27)))
             (SETELT $ 7 (LENGTH (QREFELT $ 8)))
             (EXIT (|IRSN;aIdInverse| $))))))))) 

(DEFUN |IRSN;listPermutation| (|pi| $)
  (PROG (|li| |k|)
    (RETURN
     (SEQ (LETT |li| NIL . #1=(|IRSN;listPermutation|))
          (SEQ (LETT |k| (QREFELT $ 10) . #1#) G190
               (COND ((< |k| 1) (GO G191)))
               (SEQ
                (EXIT
                 (LETT |li| (CONS (SPADCALL |pi| |k| (QREFELT $ 29)) |li|)
                       . #1#)))
               (LETT |k| (+ |k| -1) . #1#) (GO G190) G191 (EXIT NIL))
          (EXIT |li|))))) 

(DEFUN |IRSN;signum| (|numberOfRowTableau| |numberOfColumnTableau| |pi| $)
  (PROG (|k| |l| |end| |sign| |z| |swap| |endk| |s| |ctrl| |columntab|
         |rowtab|)
    (RETURN
     (SEQ
      (LETT |rowtab|
            (SPADCALL
             (SPADCALL (QREFELT $ 8) |numberOfRowTableau| (QREFELT $ 30))
             (QREFELT $ 31))
            . #1=(|IRSN;signum|))
      (LETT |columntab|
            (SPADCALL
             (SPADCALL (QREFELT $ 8) |numberOfColumnTableau| (QREFELT $ 30))
             (QREFELT $ 31))
            . #1#)
      (LETT |sign| 1 . #1#) (LETT |end| 'NIL . #1#) (LETT |k| 1 . #1#)
      (SEQ G190
           (COND
            ((NULL (COND ((OR (< (QREFELT $ 11) |k|) |end|) 'NIL) ('T 'T)))
             #2=(GO G191)))
           (SEQ (LETT |l| 1 . #1#)
                (SEQ G190
                     (COND
                      ((NULL
                        (COND
                         ((OR
                           (< (SPADCALL (QREFELT $ 6) |k| (QREFELT $ 32)) |l|)
                           |end|)
                          'NIL)
                         ('T 'T)))
                       #2#))
                     (SEQ (LETT |z| |l| . #1#) (LETT |endk| 'NIL . #1#)
                          (SEQ G190
                               (COND
                                ((NULL
                                  (COND
                                   ((OR
                                     (<
                                      (SPADCALL (QREFELT $ 6) |k|
                                                (QREFELT $ 32))
                                      |z|)
                                     |endk|)
                                    'NIL)
                                   ('T 'T)))
                                 #2#))
                               (SEQ (LETT |s| |k| . #1#) (LETT |ctrl| 'T . #1#)
                                    (SEQ G190 (COND ((NULL |ctrl|) #2#))
                                         (SEQ
                                          (EXIT
                                           (COND
                                            ((OR
                                              (<
                                               (SPADCALL (QREFELT $ 9) |l|
                                                         (QREFELT $ 32))
                                               |s|)
                                              (EQL
                                               (+ 1
                                                  (SPADCALL |rowtab| |k| |z|
                                                            (QREFELT $ 19)))
                                               (SPADCALL |pi|
                                                         (+ 1
                                                            (SPADCALL
                                                             |columntab| |s|
                                                             |l|
                                                             (QREFELT $ 19)))
                                                         (QREFELT $ 32))))
                                             (LETT |ctrl| 'NIL . #1#))
                                            ('T (LETT |s| (+ |s| 1) . #1#)))))
                                         NIL #3=(GO G190) G191 (EXIT NIL))
                                    (LETT |endk|
                                          (COND
                                           ((<
                                             (SPADCALL (QREFELT $ 9) |l|
                                                       (QREFELT $ 32))
                                             |s|)
                                            'NIL)
                                           ('T 'T))
                                          . #1#)
                                    (EXIT
                                     (COND
                                      (|endk|
                                       (SEQ
                                        (COND
                                         ((< |k| |s|)
                                          (SEQ (LETT |sign| (- |sign|) . #1#)
                                               (LETT |swap|
                                                     (SPADCALL |columntab| |s|
                                                               |l|
                                                               (QREFELT $ 19))
                                                     . #1#)
                                               (SPADCALL |columntab| |s| |l|
                                                         (SPADCALL |columntab|
                                                                   |k| |l|
                                                                   (QREFELT $
                                                                            19))
                                                         (QREFELT $ 18))
                                               (EXIT
                                                (SPADCALL |columntab| |k| |l|
                                                          |swap|
                                                          (QREFELT $ 18))))))
                                        (EXIT
                                         (COND
                                          ((< |l| |z|)
                                           (SEQ
                                            (LETT |swap|
                                                  (SPADCALL |rowtab| |k| |z|
                                                            (QREFELT $ 19))
                                                  . #1#)
                                            (SPADCALL |rowtab| |k| |z|
                                                      (SPADCALL |rowtab| |k|
                                                                |l|
                                                                (QREFELT $ 19))
                                                      (QREFELT $ 18))
                                            (EXIT
                                             (SPADCALL |rowtab| |k| |l| |swap|
                                                       (QREFELT $ 18)))))))))
                                      ('T (LETT |z| (+ |z| 1) . #1#)))))
                               NIL #3# G191 (EXIT NIL))
                          (COND
                           ((< (SPADCALL (QREFELT $ 6) |k| (QREFELT $ 32)) |z|)
                            (SEQ (LETT |sign| 0 . #1#)
                                 (EXIT (LETT |end| 'T . #1#)))))
                          (EXIT (LETT |l| (+ |l| 1) . #1#)))
                     NIL #3# G191 (EXIT NIL))
                (EXIT (LETT |k| (+ |k| 1) . #1#)))
           NIL #3# G191 (EXIT NIL))
      (EXIT |sign|))))) 

(DEFUN |IRSN;sumPartition| (|lambda| $)
  (PROG (#1=#:G1911 |prev| |ok| |sum| #2=#:G1914 |x|)
    (RETURN
     (SEQ (LETT |ok| 'T . #3=(|IRSN;sumPartition|))
          (LETT |prev| (|SPADfirst| |lambda|) . #3#) (LETT |sum| 0 . #3#)
          (SEQ (LETT |x| NIL . #3#) (LETT #2# |lambda| . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |x| (CAR #2#) . #3#) NIL))
                 (GO G191)))
               (SEQ (LETT |sum| (+ |sum| |x|) . #3#)
                    (LETT |ok|
                          (COND (|ok| (COND ((< |prev| |x|) 'NIL) ('T 'T)))
                                ('T 'NIL))
                          . #3#)
                    (EXIT (LETT |prev| |x| . #3#)))
               (LETT #2# (CDR #2#) . #3#) (GO G190) G191 (EXIT NIL))
          (COND ((NULL |ok|) (|error| "No proper partition ")))
          (EXIT
           (PROG1 (LETT #1# |sum| . #3#)
             (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))))))) 

(DEFUN |IRSN;testPermutation| (|pi| $)
  (PROG (#1=#:G1921 #2=#:G1925 |i| |test| #3=#:G1918 |ok| #4=#:G1924)
    (RETURN
     (SEQ (LETT |ok| 'T . #5=(|IRSN;testPermutation|)) (SETELT $ 10 0)
          (SEQ (LETT |i| NIL . #5#) (LETT #4# |pi| . #5#) G190
               (COND
                ((OR (ATOM #4#) (PROGN (LETT |i| (CAR #4#) . #5#) NIL))
                 #6=(GO G191)))
               (SEQ (COND ((< (QREFELT $ 10) |i|) (SETELT $ 10 |i|)))
                    (EXIT (COND ((< |i| 1) (LETT |ok| 'NIL . #5#)))))
               (LETT #4# (CDR #4#) . #5#) #7=(GO G190) G191 (EXIT NIL))
          (COND
           ((EQL (QREFELT $ 10) (LENGTH |pi|))
            (COND ((NULL |ok|) (|error| #8="No permutation of 1,2,..,n"))))
           ('T (|error| #8#)))
          (LETT |test|
                (MAKEARR1
                 (PROG1 (LETT #3# (QREFELT $ 10) . #5#)
                   (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|) #3#))
                 'NIL)
                . #5#)
          (SEQ (LETT |i| NIL . #5#) (LETT #2# |pi| . #5#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #5#) NIL)) #6#))
               (SEQ (EXIT (SPADCALL |test| |i| 'T (QREFELT $ 34))))
               (LETT #2# (CDR #2#) . #5#) #7# G191 (EXIT NIL))
          (COND
           ((SPADCALL 'NIL |test| (QREFELT $ 35)) (|error| "No permutation")))
          (EXIT
           (PROG1 (LETT #1# (QREFELT $ 10) . #5#)
             (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))))))) 

(DEFUN |IRSN;dimensionOfIrreducibleRepresentation;LNni;7| (|lambda| $)
  (PROG (#1=#:G1928 |dd| #2=#:G1932 |j| #3=#:G1931 |i| |lambdaprime| |nn|)
    (RETURN
     (SEQ
      (LETT |nn| (|IRSN;sumPartition| |lambda| $)
            . #4=(|IRSN;dimensionOfIrreducibleRepresentation;LNni;7|))
      (LETT |dd| 1 . #4#)
      (LETT |lambdaprime| (SPADCALL |lambda| (QREFELT $ 24)) . #4#)
      (SEQ (LETT |i| 1 . #4#)
           (LETT #3# (SPADCALL |lambdaprime| 1 (QREFELT $ 32)) . #4#) G190
           (COND ((QSGREATERP |i| #3#) #5=(GO G191)))
           (SEQ
            (EXIT
             (SEQ (LETT |j| 1 . #4#)
                  (LETT #2# (SPADCALL |lambda| |i| (QREFELT $ 32)) . #4#) G190
                  (COND ((QSGREATERP |j| #2#) #5#))
                  (SEQ
                   (EXIT
                    (LETT |dd|
                          (* |dd|
                             (+
                              (-
                               (-
                                (+ (SPADCALL |lambda| |i| (QREFELT $ 32))
                                   (SPADCALL |lambdaprime| |j| (QREFELT $ 32)))
                                |i|)
                               |j|)
                              1))
                          . #4#)))
                  (LETT |j| (QSADD1 |j|) . #4#) #6=(GO G190) G191 (EXIT NIL))))
           (LETT |i| (QSADD1 |i|) . #4#) #6# G191 (EXIT NIL))
      (EXIT
       (PROG1 (LETT #1# (QUOTIENT2 (SPADCALL |nn| (QREFELT $ 37)) |dd|) . #4#)
         (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))))))) 

(DEFUN |IRSN;irreducibleRepresentation;LPM;8| (|lambda| |pi| $)
  (PROG (#1=#:G1939 |l| #2=#:G1938 |k| |aPi| |piList| |nn|)
    (RETURN
     (SEQ
      (LETT |nn| (|IRSN;sumPartition| |lambda| $)
            . #3=(|IRSN;irreducibleRepresentation;LPM;8|))
      (|IRSN;alreadyComputed?| |lambda| $)
      (LETT |piList| (|IRSN;listPermutation| |pi| $) . #3#)
      (COND
       ((NULL (EQL |nn| (|IRSN;testPermutation| |piList| $)))
        (|error| "Partition and permutation are not consistent")))
      (LETT |aPi| (SPADCALL (QREFELT $ 7) (QREFELT $ 7) 0 (QREFELT $ 16))
            . #3#)
      (SEQ (LETT |k| 1 . #3#) (LETT #2# (QREFELT $ 7) . #3#) G190
           (COND ((QSGREATERP |k| #2#) #4=(GO G191)))
           (SEQ
            (EXIT
             (SEQ (LETT |l| 1 . #3#) (LETT #1# (QREFELT $ 7) . #3#) G190
                  (COND ((QSGREATERP |l| #1#) #4#))
                  (SEQ
                   (EXIT
                    (SPADCALL |aPi| |k| |l| (|IRSN;signum| |k| |l| |piList| $)
                              (QREFELT $ 18))))
                  (LETT |l| (QSADD1 |l|) . #3#) #5=(GO G190) G191 (EXIT NIL))))
           (LETT |k| (QSADD1 |k|) . #3#) #5# G191 (EXIT NIL))
      (EXIT (SPADCALL (QREFELT $ 17) |aPi| (QREFELT $ 39))))))) 

(DEFUN |IRSN;irreducibleRepresentation;LL;9| (|lambda| $)
  (PROG (|listperm| |li| |k|)
    (RETURN
     (SEQ (LETT |listperm| NIL . #1=(|IRSN;irreducibleRepresentation;LL;9|))
          (LETT |li| NIL . #1#) (|IRSN;sumPartition| |lambda| $)
          (|IRSN;alreadyComputed?| |lambda| $)
          (LETT |listperm|
                (COND
                 ((EQL (QREFELT $ 10) 1)
                  (CONS (|spadConstant| $ 41) |listperm|))
                 ((EQL (QREFELT $ 10) 2)
                  (CONS (SPADCALL (LIST 1 2) (QREFELT $ 42)) |listperm|))
                 ('T
                  (SEQ
                   (SEQ (LETT |k| (QREFELT $ 10) . #1#) G190
                        (COND ((< |k| 1) (GO G191)))
                        (SEQ (EXIT (LETT |li| (CONS |k| |li|) . #1#)))
                        (LETT |k| (+ |k| -1) . #1#) (GO G190) G191 (EXIT NIL))
                   (LETT |listperm|
                         (CONS (SPADCALL |li| (QREFELT $ 42)) |listperm|)
                         . #1#)
                   (EXIT
                    (CONS (SPADCALL (LIST 1 2) (QREFELT $ 42)) |listperm|)))))
                . #1#)
          (EXIT (SPADCALL |lambda| |listperm| (QREFELT $ 44))))))) 

(DEFUN |IRSN;irreducibleRepresentation;LLL;10| (|lambda| |listperm| $)
  (PROG (#1=#:G1948 |pi| #2=#:G1947)
    (RETURN
     (SEQ (|IRSN;sumPartition| |lambda| $) (|IRSN;alreadyComputed?| |lambda| $)
          (EXIT
           (PROGN
            (LETT #2# NIL . #3=(|IRSN;irreducibleRepresentation;LLL;10|))
            (SEQ (LETT |pi| NIL . #3#) (LETT #1# |listperm| . #3#) G190
                 (COND
                  ((OR (ATOM #1#) (PROGN (LETT |pi| (CAR #1#) . #3#) NIL))
                   (GO G191)))
                 (SEQ
                  (EXIT
                   (LETT #2# (CONS (SPADCALL |lambda| |pi| (QREFELT $ 40)) #2#)
                         . #3#)))
                 (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                 (EXIT (NREVERSE0 #2#))))))))) 

(DEFUN |IrrRepSymNatPackage| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G1950)
       (RETURN
        (COND
         ((LETT #2# (HGET |$ConstructorCache| '|IrrRepSymNatPackage|)
                . #3=(|IrrRepSymNatPackage|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|IrrRepSymNatPackage|
                         (LIST (CONS NIL (CONS 1 (|IrrRepSymNatPackage;|))))))
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|IrrRepSymNatPackage|))))))))))) 

(DEFUN |IrrRepSymNatPackage;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|IrrRepSymNatPackage|) . #1=(|IrrRepSymNatPackage|))
      (LETT $ (GETREFV 46) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|IrrRepSymNatPackage| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 NIL)
      (QSETREFV $ 7 0)
      (QSETREFV $ 8 NIL)
      (QSETREFV $ 9 NIL)
      (QSETREFV $ 10 0)
      (QSETREFV $ 11 0)
      (QSETREFV $ 12 0)
      (QSETREFV $ 17 (SPADCALL 1 1 0 (QREFELT $ 16)))
      $)))) 

(MAKEPROP '|IrrRepSymNatPackage| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL '|oldlambda| '|flambda| '|younglist|
              '|lprime| '|n| '|rows| '|columns| (|NonNegativeInteger|)
              (|Integer|) (|Matrix| 14) (0 . |new|) '|aId| (7 . |setelt|)
              (15 . |elt|) (|Boolean|) (|List| 14) (22 . =)
              (|PartitionsAndPermutations|) (28 . |conjugate|) (|List| 15)
              (|SymmetricGroupCombinatoricFunctions|)
              (33 . |listYoungTableaus|) (|Permutation| 14) (38 . |eval|)
              (44 . |elt|) (50 . |copy|) (55 . |elt|) (|Vector| 20)
              (61 . |setelt|) (68 . |member?|)
              (|IntegerCombinatoricFunctions| 14) (74 . |factorial|)
              |IRSN;dimensionOfIrreducibleRepresentation;LNni;7| (79 . *)
              |IRSN;irreducibleRepresentation;LPM;8| (85 . |One|)
              (89 . |cycle|) (|List| 28)
              |IRSN;irreducibleRepresentation;LLL;10|
              |IRSN;irreducibleRepresentation;LL;9|)
           '#(|irreducibleRepresentation| 94
              |dimensionOfIrreducibleRepresentation| 111)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 45
                                                 '(3 15 0 13 13 14 16 4 15 14 0
                                                   14 14 14 18 3 15 14 0 14 14
                                                   19 2 21 20 0 0 22 1 23 21 21
                                                   24 1 26 25 21 27 2 28 14 0
                                                   14 29 2 25 15 0 14 30 1 15 0
                                                   0 31 2 21 14 0 14 32 3 33 20
                                                   0 14 20 34 2 33 20 20 0 35 1
                                                   36 14 14 37 2 15 0 0 0 39 0
                                                   28 0 41 1 28 0 21 42 2 0 15
                                                   21 28 40 2 0 25 21 43 44 1 0
                                                   25 21 45 1 0 13 21 38)))))
           '|lookupComplete|)) 

(MAKEPROP '|IrrRepSymNatPackage| 'NILADIC T) 
