
(/VERSIONCHECK 2) 

(DEFUN |IRSN;aIdInverse| ($)
  (PROG (#0=#:G1875 #1=#:G1874 |idperm| #2=#:G1876 |l| #3=#:G1877 |j|
            #4=#:G1831 #5=#:G1835 |k| #6=#:G1878 |i| #7=#:G1838
            #8=#:G1848 #9=#:G1868)
    (RETURN
      (SEQ (EXIT (SEQ (SETELT $ 17
                              (SPADCALL (QREFELT $ 7) (QREFELT $ 7) 0
                                  (QREFELT $ 16)))
                      (SEQ (LETT |k| 1 . #10=(|IRSN;aIdInverse|))
                           (LETT #0# (QREFELT $ 7) . #10#) G190
                           (COND ((QSGREATERP |k| #0#) #11=(GO G191)))
                           (SEQ (EXIT (SPADCALL (QREFELT $ 17) |k| |k|
                                       1 (QREFELT $ 18))))
                           (LETT |k| (QSADD1 |k|) . #10#) #12=(GO G190)
                           G191 (EXIT NIL))
                      (COND
                        ((< (QREFELT $ 10) 5)
                         (PROGN
                           (LETT #1# (QREFELT $ 17) . #10#)
                           (GO #1#))))
                      (LETT |idperm| NIL . #10#)
                      (SEQ (LETT |k| (QREFELT $ 10) . #10#) G190
                           (COND ((< |k| 1) #11#))
                           (SEQ (EXIT (LETT |idperm|
                                       (CONS |k| |idperm|) . #10#)))
                           (LETT |k| (+ |k| -1) . #10#) #12# G191
                           (EXIT NIL))
                      (SEQ (LETT |k| 1 . #10#)
                           (LETT #2# (- (QREFELT $ 7) 1) . #10#) G190
                           (COND ((QSGREATERP |k| #2#) #11#))
                           (SEQ (EXIT (SEQ (LETT |l| (+ |k| 1) . #10#)
                                       (LETT #3# (QREFELT $ 7) . #10#)
                                       G190 (COND ((> |l| #3#) #11#))
                                       (SEQ
                                        (EXIT
                                         (SPADCALL (QREFELT $ 17) |k|
                                          |l|
                                          (|IRSN;signum| |k| |l|
                                           |idperm| $)
                                          (QREFELT $ 18))))
                                       (LETT |l| (+ |l| 1) . #10#) #12#
                                       G191 (EXIT NIL))))
                           (LETT |k| (QSADD1 |k|) . #10#) #12# G191
                           (EXIT NIL))
                      (EXIT (SEQ (LETT |j| (QREFELT $ 7) . #10#) G190
                                 (COND ((< |j| 2) #11#))
                                 (SEQ (SEQ (LETT |i| (- |j| 1) . #10#)
                                       G190 (COND ((< |i| 1) #11#))
                                       (SEQ
                                        (EXIT
                                         (SPADCALL (QREFELT $ 17)
                                          (PROG1 (LETT #4# |i| . #10#)
                                            (|check-subtype| (>= #4# 0)
                                             '(|NonNegativeInteger|)
                                             #4#))
                                          |j|
                                          (-
                                           (SPADCALL (QREFELT $ 17)
                                            (PROG1
                                             (LETT #5# |i| . #10#)
                                              (|check-subtype|
                                               (>= #5# 0)
                                               '(|NonNegativeInteger|)
                                               #5#))
                                            |j| (QREFELT $ 19)))
                                          (QREFELT $ 18))))
                                       (LETT |i| (+ |i| -1) . #10#)
                                       #12# G191 (EXIT NIL))
                                      (EXIT
                                       (SEQ (LETT |k| (+ |j| 1) . #10#)
                                        (LETT #6# (QREFELT $ 7) . #10#)
                                        G190 (COND ((> |k| #6#) #11#))
                                        (SEQ
                                         (EXIT
                                          (SEQ
                                           (LETT |i| (- |j| 1) . #10#)
                                           G190 (COND ((< |i| 1) #11#))
                                           (SEQ
                                            (EXIT
                                             (SPADCALL (QREFELT $ 17)
                                              (PROG1
                                               (LETT #7# |i| . #10#)
                                                (|check-subtype|
                                                 (>= #7# 0)
                                                 '(|NonNegativeInteger|)
                                                 #7#))
                                              |k|
                                              (+
                                               (SPADCALL (QREFELT $ 17)
                                                (PROG1
                                                 (LETT #8# |i| . #10#)
                                                  (|check-subtype|
                                                   (>= #8# 0)
                                                   '(|NonNegativeInteger|)
                                                   #8#))
                                                |k| (QREFELT $ 19))
                                               (*
                                                (SPADCALL
                                                 (QREFELT $ 17)
                                                 (PROG1
                                                  (LETT #9# |i| . #10#)
                                                   (|check-subtype|
                                                    (>= #9# 0)
                                                    '(|NonNegativeInteger|)
                                                    #9#))
                                                 |j| (QREFELT $ 19))
                                                (SPADCALL
                                                 (QREFELT $ 17) |j| |k|
                                                 (QREFELT $ 19))))
                                              (QREFELT $ 18))))
                                           (LETT |i| (+ |i| -1) . #10#)
                                           #12# G191 (EXIT NIL))))
                                        (LETT |k| (+ |k| 1) . #10#)
                                        #12# G191 (EXIT NIL))))
                                 (LETT |j| (+ |j| -1) . #10#) #12# G191
                                 (EXIT NIL)))))
           #1# (EXIT #1#))))) 

(DEFUN |IRSN;alreadyComputed?| (|lambda| $)
  (PROG (#0=#:G1879 #1=#:G1880 #2=#:G1815 #3=#:G1890 #4=#:G1886
            #5=#:G1884 #6=#:G1885 #7=#:G1887)
    (RETURN
      (SEQ (COND
             ((NULL (SPADCALL |lambda| (QREFELT $ 6) (QREFELT $ 22)))
              (SEQ (SETELT $ 6 |lambda|)
                   (SETELT $ 9 (SPADCALL |lambda| (QREFELT $ 24)))
                   (SETELT $ 11
                           (PROG1 (LETT #0# (|SPADfirst| (QREFELT $ 9))
                                        . #8=(|IRSN;alreadyComputed?|))
                             (|check-subtype| (>= #0# 0)
                                 '(|NonNegativeInteger|) #0#)))
                   (SETELT $ 12
                           (PROG1 (LETT #1#
                                        (|SPADfirst| |lambda|) . #8#)
                             (|check-subtype| (>= #1# 0)
                                 '(|NonNegativeInteger|) #1#)))
                   (SETELT $ 10
                           (PROG1 (LETT #7#
                                        (PROGN
                                          (LETT #6# NIL . #8#)
                                          (SEQ (LETT #2# NIL . #8#)
                                           (LETT #3# |lambda| . #8#)
                                           G190
                                           (COND
                                             ((OR (ATOM #3#)
                                               (PROGN
                                                 (LETT #2#
                                                  (CAR #3#) . #8#)
                                                 NIL))
                                              (GO G191)))
                                           (SEQ
                                            (EXIT
                                             (PROGN
                                               (LETT #4# #2# . #8#)
                                               (COND
                                                 (#6#
                                                  (LETT #5#
                                                   (+ #5# #4#) . #8#))
                                                 ('T
                                                  (PROGN
                                                    (LETT #5#
                                                     #4# . #8#)
                                                    (LETT #6# 'T . #8#)))))))
                                           (LETT #3# (CDR #3#) . #8#)
                                           (GO G190) G191 (EXIT NIL))
                                          (COND (#6# #5#) ('T 0))) . #8#)
                             (|check-subtype| (>= #7# 0)
                                 '(|NonNegativeInteger|) #7#)))
                   (SETELT $ 8 (SPADCALL |lambda| (QREFELT $ 27)))
                   (SETELT $ 7 (LENGTH (QREFELT $ 8)))
                   (EXIT (|IRSN;aIdInverse| $))))))))) 

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

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

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

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

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

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

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

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

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

(DEFUN |IrrRepSymNatPackage;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|IrrRepSymNatPackage|)
              . #0=(|IrrRepSymNatPackage|))
        (LETT $ (GETREFV 47) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|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 . |new|) (67 . |setelt|)
             (74 . |member?|) (|IntegerCombinatoricFunctions| 14)
             (80 . |factorial|)
             |IRSN;dimensionOfIrreducibleRepresentation;LNni;7|
             (85 . *) |IRSN;irreducibleRepresentation;LPM;8|
             (91 . |One|) (95 . |cycle|) (|List| 28)
             |IRSN;irreducibleRepresentation;LLL;10|
             |IRSN;irreducibleRepresentation;LL;9|)
          '#(|irreducibleRepresentation| 100
             |dimensionOfIrreducibleRepresentation| 117)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 46
                                '(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 2 33 0 13 20 34 3 33 20
                                  0 14 20 35 2 33 20 20 0 36 1 37 14 14
                                  38 2 15 0 0 0 40 0 28 0 42 1 28 0 21
                                  43 2 0 15 21 28 41 2 0 25 21 44 45 1
                                  0 25 21 46 1 0 13 21 39)))))
          '|lookupComplete|)) 

(MAKEPROP '|IrrRepSymNatPackage| 'NILADIC T) 
