
(/VERSIONCHECK 2) 

(DEFUN |PERMGRP;shortenWord| (|lw| |gp| $)
  (PROG (|gpgens| #0=#:G1874 |gen| #1=#:G1875 |orderList| #2=#:G1876
            |pos| |actualLength| #3=#:G1862 |i| #4=#:G1864 |newlw|
            |flag| |pointer| |test| |anzahl|)
    (RETURN
      (SEQ (LETT |gpgens| (SPADCALL |gp| (QREFELT $ 22))
                 . #5=(|PERMGRP;shortenWord|))
           (LETT |orderList|
                 (PROGN
                   (LETT #0# NIL . #5#)
                   (SEQ (LETT |gen| NIL . #5#)
                        (LETT #1# |gpgens| . #5#) G190
                        (COND
                          ((OR (ATOM #1#)
                               (PROGN
                                 (LETT |gen| (CAR #1#) . #5#)
                                 NIL))
                           #6=(GO G191)))
                        (SEQ (EXIT (LETT #0#
                                    (CONS
                                     (SPADCALL |gen| (QREFELT $ 25))
                                     #0#) . #5#)))
                        (LETT #1# (CDR #1#) . #5#) #7=(GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #5#)
           (LETT |newlw| (SPADCALL |lw| (QREFELT $ 27)) . #5#)
           (SEQ (LETT |i| 1 . #5#)
                (LETT #2# (SPADCALL |orderList| (QREFELT $ 29)) . #5#)
                G190 (COND ((QSGREATERP |i| #2#) #6#))
                (SEQ (EXIT (COND
                             ((EQL (SPADCALL |orderList| |i|
                                    (QREFELT $ 30))
                                   1)
                              (SEQ G190
                                   (COND
                                     ((NULL
                                       (SPADCALL |i| |newlw|
                                        (QREFELT $ 32)))
                                      #6#))
                                   (SEQ
                                    (LETT |pos|
                                     (SPADCALL |i| |newlw|
                                      (QREFELT $ 33)) . #5#)
                                    (EXIT
                                     (LETT |newlw|
                                      (SPADCALL |newlw| |pos|
                                       (QREFELT $ 34)) . #5#)))
                                   NIL #7# G191 (EXIT NIL))))))
                (LETT |i| (QSADD1 |i|) . #5#) #7# G191 (EXIT NIL))
           (LETT |flag| 'T . #5#)
           (SEQ G190 (COND ((NULL |flag|) #6#))
                (SEQ (LETT |actualLength|
                           (SPADCALL |newlw| (QREFELT $ 29)) . #5#)
                     (LETT |pointer| |actualLength| . #5#)
                     (LETT |test|
                           (SPADCALL |newlw| |pointer| (QREFELT $ 30)) . #5#)
                     (LETT |anzahl| 1 . #5#) (LETT |flag| 'NIL . #5#)
                     (EXIT (SEQ G190
                                (COND ((NULL (< 1 |pointer|)) #6#))
                                (SEQ (LETT |pointer|
                                      (PROG1
                                       (LETT #3# (- |pointer| 1) . #5#)
                                        (|check-subtype| (>= #3# 0)
                                         '(|NonNegativeInteger|) #3#)) . #5#)
                                     (EXIT
                                      (COND
                                        ((EQL
                                          (SPADCALL |newlw| |pointer|
                                           (QREFELT $ 30))
                                          |test|)
                                         (SEQ
                                          (LETT |anzahl|
                                           (+ |anzahl| 1) . #5#)
                                          (EXIT
                                           (COND
                                             ((EQL |anzahl|
                                               (SPADCALL |orderList|
                                                |test| (QREFELT $ 30)))
                                              (SEQ
                                               (SEQ
                                                (LETT |i|
                                                 (+ |pointer| |anzahl|) . #5#)
                                                G190
                                                (COND
                                                  ((> |i|
                                                    |actualLength|)
                                                   #6#))
                                                (SEQ
                                                 (EXIT
                                                  (SPADCALL |newlw|
                                                   (- |i| |anzahl|)
                                                   (SPADCALL |newlw|
                                                    |i| (QREFELT $ 30))
                                                   (QREFELT $ 36))))
                                                (LETT |i|
                                                 (+ |i| 1) . #5#)
                                                #7# G191 (EXIT NIL))
                                               (LETT |newlw|
                                                (SPADCALL |newlw|
                                                 (PROG1
                                                  (LETT #4#
                                                   (- |actualLength|
                                                    |anzahl|) . #5#)
                                                   (|check-subtype|
                                                    (>= #4# 0)
                                                    '(|NonNegativeInteger|)
                                                    #4#))
                                                 (QREFELT $ 37)) . #5#)
                                               (LETT |flag| 'T . #5#)
                                               (EXIT
                                                (LETT |pointer|
                                                 1 . #5#))))))))
                                        ('T
                                         (SEQ
                                          (LETT |test|
                                           (SPADCALL |newlw| |pointer|
                                            (QREFELT $ 30)) . #5#)
                                          (EXIT
                                           (LETT |anzahl| 1 . #5#)))))))
                                NIL #7# G191 (EXIT NIL))))
                NIL #7# G191 (EXIT NIL))
           (EXIT |newlw|))))) 

(DEFUN |PERMGRP;times| (|p| |q| $)
  (PROG (#0=#:G1879 #1=#:G1880 |i| #2=#:G1881)
    (RETURN
      (SEQ (PRIMVEC2ARR
               (PROGN
                 (LETT #0# (GETREFV #3=(QREFELT $ 11))
                       . #4=(|PERMGRP;times|))
                 (SEQ (LETT #1# 0 . #4#) (LETT |i| 1 . #4#)
                      (LETT #2# #3# . #4#) G190
                      (COND ((QSGREATERP |i| #2#) (GO G191)))
                      (SEQ (EXIT (SETELT #0# #1#
                                         (SPADCALL |p|
                                          (SPADCALL |q| |i|
                                           (QREFELT $ 39))
                                          (QREFELT $ 39)))))
                      (LETT |i|
                            (PROG1 (QSADD1 |i|)
                              (LETT #1# (QSADD1 #1#) . #4#)) . #4#)
                      (GO G190) G191 (EXIT NIL))
                 #0#)))))) 

(DEFUN |PERMGRP;strip| (|element| |orbit| |group| |words| $)
  (PROG (|schreierVector| |point| |entry| |entryLessZero| |actelt|
            #0=#:G1884 |outlist|)
    (RETURN
      (SEQ (LETT |actelt| |element| . #1=(|PERMGRP;strip|))
           (LETT |schreierVector| (QCDR |orbit|) . #1#)
           (LETT |point|
                 (SPADCALL (QCAR |orbit|) 1 (QREFELT $ 30)) . #1#)
           (LETT |outlist| NIL . #1#) (LETT |entryLessZero| 'NIL . #1#)
           (SEQ G190
                (COND
                  ((NULL (COND (|entryLessZero| 'NIL) ('T 'T)))
                   (GO G191)))
                (SEQ (LETT |entry|
                           (SPADCALL |schreierVector|
                               (SPADCALL |actelt| |point|
                                   (QREFELT $ 40))
                               (QREFELT $ 42)) . #1#)
                     (LETT |entryLessZero| (< |entry| 0) . #1#)
                     (EXIT (COND
                             ((NULL |entryLessZero|)
                              (SEQ (LETT |actelt|
                                    (|PERMGRP;times|
                                     (SPADCALL |group| |entry|
                                      (QREFELT $ 44))
                                     |actelt| $) . #1#)
                                   (EXIT
                                    (COND
                                      ((QREFELT $ 20)
                                       (LETT |outlist|
                                        (APPEND
                                         (SPADCALL |words|
                                          (PROG1
                                           (LETT #0# |entry| . #1#)
                                            (|check-subtype| (>= #0# 0)
                                             '(|NonNegativeInteger|)
                                             #0#))
                                          (QREFELT $ 46))
                                         |outlist|) . #1#)))))))))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (CONS |actelt| (REVERSE |outlist|))))))) 

(DEFUN |PERMGRP;orbitInternal| (|gp| |startList| $)
  (PROG (|gpset| |gen| #0=#:G1899 |workList| |j| |newList| |orbitList|
                 |pos|)
    (RETURN
      (SEQ (LETT |orbitList| (LIST |startList|)
                 . #1=(|PERMGRP;orbitInternal|))
           (LETT |pos| 1 . #1#)
           (SEQ G190
                (COND
                  ((NULL (COND ((ZEROP |pos|) 'NIL) ('T 'T)))
                   #2=(GO G191)))
                (SEQ (LETT |gpset| (QCAR |gp|) . #1#)
                     (SEQ (LETT |gen| NIL . #1#)
                          (LETT #0# |gpset| . #1#) G190
                          (COND
                            ((OR (ATOM #0#)
                                 (PROGN
                                   (LETT |gen| (CAR #0#) . #1#)
                                   NIL))
                             #2#))
                          (SEQ (LETT |newList| NIL . #1#)
                               (LETT |workList|
                                     (SPADCALL |orbitList| |pos|
                                      (QREFELT $ 49)) . #1#)
                               (SEQ (LETT |j|
                                     (LENGTH |workList|) . #1#)
                                    G190 (COND ((< |j| 1) #2#))
                                    (SEQ
                                     (EXIT
                                      (LETT |newList|
                                       (CONS
                                        (SPADCALL |gen|
                                         (SPADCALL |workList| |j|
                                          (QREFELT $ 50))
                                         (QREFELT $ 51))
                                        |newList|) . #1#)))
                                    (LETT |j| (+ |j| -1) . #1#)
                                    #3=(GO G190) G191 (EXIT NIL))
                               (EXIT (COND
                                       ((NULL
                                         (SPADCALL |newList|
                                          |orbitList| (QREFELT $ 52)))
                                        (SEQ
                                         (LETT |orbitList|
                                          (CONS |newList| |orbitList|) . #1#)
                                         (EXIT
                                          (LETT |pos|
                                           (+ |pos| 1) . #1#)))))))
                          (LETT #0# (CDR #0#) . #1#) #3# G191
                          (EXIT NIL))
                     (EXIT (LETT |pos| (- |pos| 1) . #1#)))
                NIL #3# G191 (EXIT NIL))
           (EXIT (REVERSE |orbitList|)))))) 

(DEFUN |PERMGRP;inv| (|p| $)
  (PROG (|q| |i| #0=#:G1903)
    (RETURN
      (SEQ (LETT |q| (SPADCALL (QREFELT $ 11) 0 (QREFELT $ 53))
                 . #1=(|PERMGRP;inv|))
           (SEQ (LETT |i| 1 . #1#) (LETT #0# (QREFELT $ 11) . #1#) G190
                (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (EXIT (SPADCALL |q|
                               (SPADCALL |p| |i| (QREFELT $ 39)) |i|
                               (QREFELT $ 54))))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (EXIT |q|))))) 

(DEFUN |PERMGRP;ranelt| (|group| |word| |maxLoops| $)
  (PROG (|numberOfGenerators| #0=#:G1904 |randomInteger|
            |randomElement| #1=#:G1906 |words| |numberOfLoops|)
    (RETURN
      (SEQ (LETT |numberOfGenerators| (LENGTH |group|)
                 . #2=(|PERMGRP;ranelt|))
           (LETT |randomInteger|
                 (+ 1 (RANDOM |numberOfGenerators|)) . #2#)
           (LETT |randomElement|
                 (SPADCALL |group| |randomInteger| (QREFELT $ 44)) . #2#)
           (LETT |words| NIL . #2#)
           (COND
             ((QREFELT $ 20)
              (LETT |words|
                    (SPADCALL |word|
                        (PROG1 (LETT #0# |randomInteger| . #2#)
                          (|check-subtype| (>= #0# 0)
                              '(|NonNegativeInteger|) #0#))
                        (QREFELT $ 46)) . #2#)))
           (COND
             ((< 0 |maxLoops|)
              (LETT |numberOfLoops| (+ 1 (RANDOM |maxLoops|)) . #2#))
             ('T (LETT |numberOfLoops| |maxLoops| . #2#)))
           (SEQ G190 (COND ((NULL (< 0 |numberOfLoops|)) (GO G191)))
                (SEQ (LETT |randomInteger|
                           (+ 1 (RANDOM |numberOfGenerators|)) . #2#)
                     (LETT |randomElement|
                           (|PERMGRP;times|
                               (SPADCALL |group| |randomInteger|
                                   (QREFELT $ 44))
                               |randomElement| $) . #2#)
                     (COND
                       ((QREFELT $ 20)
                        (LETT |words|
                              (APPEND (SPADCALL |word|
                                       (PROG1
                                        (LETT #1#
                                         |randomInteger| . #2#)
                                         (|check-subtype| (>= #1# 0)
                                          '(|NonNegativeInteger|) #1#))
                                       (QREFELT $ 46))
                                      |words|) . #2#)))
                     (EXIT (LETT |numberOfLoops|
                                 (- |numberOfLoops| 1) . #2#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (CONS |randomElement| |words|)))))) 

(DEFUN |PERMGRP;testIdentity| (|p| $)
  (PROG (|i| #0=#:G1916 #1=#:G1915 #2=#:G1913)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i| 1
                                       . #3=(|PERMGRP;testIdentity|))
                                      (LETT #0# (QREFELT $ 11) . #3#)
                                      G190
                                      (COND
                                        ((QSGREATERP |i| #0#)
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (EQL
                                             (SPADCALL |p| |i|
                                              (QREFELT $ 39))
                                             |i|))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT |i| (QSADD1 |i|) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |PERMGRP;pointList| (|group| $)
  (PROG (|perm| #0=#:G1920 |support|)
    (RETURN
      (SEQ (LETT |support| (SPADCALL (QREFELT $ 56))
                 . #1=(|PERMGRP;pointList|))
           (SEQ (LETT |perm| NIL . #1#) (LETT #0# (QCAR |group|) . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |perm| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |support|
                                 (SPADCALL |support|
                                     (SPADCALL |perm| (QREFELT $ 57))
                                     (QREFELT $ 58)) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |support| (QREFELT $ 59))))))) 

(DEFUN |PERMGRP;orbitWithSvc| (|group| |point| $)
  (PROG (|el| #0=#:G1931 |newGroup| |schreierVector| |i| #1=#:G1932
              |newPoint| |orbit| |position|)
    (RETURN
      (SEQ (LETT |newGroup| NIL . #2=(|PERMGRP;orbitWithSvc|))
           (SEQ (LETT |el| NIL . #2#) (LETT #0# |group| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |el| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (EXIT (LETT |newGroup|
                                 (CONS (|PERMGRP;inv| |el| $)
                                       |newGroup|) . #2#)))
                (LETT #0# (CDR #0#) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (LETT |newGroup| (REVERSE |newGroup|) . #2#)
           (LETT |orbit| (LIST |point|) . #2#)
           (LETT |schreierVector|
                 (SPADCALL (QREFELT $ 11) -2 (QREFELT $ 60)) . #2#)
           (SPADCALL |schreierVector| |point| -1 (QREFELT $ 61))
           (LETT |position| 1 . #2#)
           (SEQ G190
                (COND
                  ((NULL (COND ((ZEROP |position|) 'NIL) ('T 'T))) #3#))
                (SEQ (SEQ (LETT |i| 1 . #2#)
                          (LETT #1# (LENGTH |newGroup|) . #2#) G190
                          (COND ((QSGREATERP |i| #1#) #3#))
                          (SEQ (LETT |newPoint|
                                     (SPADCALL |orbit| |position|
                                      (QREFELT $ 30)) . #2#)
                               (LETT |newPoint|
                                     (SPADCALL
                                      (SPADCALL |newGroup| |i|
                                       (QREFELT $ 44))
                                      |newPoint| (QREFELT $ 40)) . #2#)
                               (EXIT (COND
                                       ((NULL
                                         (SPADCALL |newPoint| |orbit|
                                          (QREFELT $ 32)))
                                        (SEQ
                                         (LETT |orbit|
                                          (CONS |newPoint| |orbit|) . #2#)
                                         (LETT |position|
                                          (+ |position| 1) . #2#)
                                         (EXIT
                                          (SPADCALL |schreierVector|
                                           |newPoint| |i|
                                           (QREFELT $ 61))))))))
                          (LETT |i| (QSADD1 |i|) . #2#) #4# G191
                          (EXIT NIL))
                     (EXIT (LETT |position| (- |position| 1) . #2#)))
                NIL #4# G191 (EXIT NIL))
           (EXIT (CONS (REVERSE |orbit|) |schreierVector|)))))) 

(DEFUN |PERMGRP;cosetRep| (|point| |o| |group| $)
  (PROG (#0=#:G1940 #1=#:G1941 |n| #2=#:G1942 |oorb| |osvc| |p|
            #3=#:G1939 |x| |xelt| |word| |ppt|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ppt| |point| . #4=(|PERMGRP;cosetRep|))
                      (LETT |xelt|
                            (PRIMVEC2ARR
                                (PROGN
                                  (LETT #0#
                                        (GETREFV #5=(QREFELT $ 11)) . #4#)
                                  (SEQ (LETT #1# 0 . #4#)
                                       (LETT |n| 1 . #4#)
                                       (LETT #2# #5# . #4#) G190
                                       (COND
                                         ((QSGREATERP |n| #2#)
                                          #6=(GO G191)))
                                       (SEQ
                                        (EXIT (SETELT #0# #1# |n|)))
                                       (LETT |n|
                                        (PROG1 (QSADD1 |n|)
                                          (LETT #1# (QSADD1 #1#) . #4#)) . #4#)
                                       #7=(GO G190) G191 (EXIT NIL))
                                  #0#)) . #4#)
                      (LETT |word| NIL . #4#)
                      (LETT |oorb| (QCAR |o|) . #4#)
                      (LETT |osvc| (QCDR |o|) . #4#)
                      (EXIT (SEQ G190
                                 (COND
                                   ((NULL (< 0 (QREFELT $ 11))) #6#))
                                 (SEQ (LETT |p|
                                       (SPADCALL |osvc| |ppt|
                                        (QREFELT $ 42)) . #4#)
                                      (EXIT
                                       (COND
                                         ((< |p| 0)
                                          (PROGN
                                            (LETT #3#
                                             (CONS |xelt| |word|) . #4#)
                                            (GO #3#)))
                                         ('T
                                          (SEQ
                                           (LETT |x|
                                            (SPADCALL |group| |p|
                                             (QREFELT $ 44)) . #4#)
                                           (LETT |xelt|
                                            (|PERMGRP;times| |x| |xelt|
                                             $) . #4#)
                                           (COND
                                             ((QREFELT $ 20)
                                              (LETT |word|
                                               (APPEND
                                                (SPADCALL
                                                 (QREFELT $ 15) |p|
                                                 (QREFELT $ 46))
                                                |word|) . #4#)))
                                           (EXIT
                                            (LETT |ppt|
                                             (SPADCALL |x| |ppt|
                                              (QREFELT $ 40)) . #4#)))))))
                                 NIL #7# G191 (EXIT NIL)))))
           #3# (EXIT #3#))))) 

(DEFUN |PERMGRP;bsgs1|
       (|group| |number1| |words| |maxLoops| |gp| |diff| $)
  (PROG (|i| #0=#:G1962 |ort| |k1| #1=#:G1944 |gplength| |jj|
             #2=#:G1947 |k| |gpsgs| |words2| |ran| |str| |el2| |group2|
             |help| |words3| |j| #3=#:G1961 |k2|)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |i| |number1|
                                       . #4=(|PERMGRP;bsgs1|))
                                      (LETT #0# (QREFELT $ 11) . #4#)
                                      G190
                                      (COND
                                        ((> |i| #0#) #5=(GO G191)))
                                      (SEQ
                                       (LETT |ort|
                                        (|PERMGRP;orbitWithSvc| |group|
                                         |i| $) . #4#)
                                       (LETT |k| (QCAR |ort|) . #4#)
                                       (LETT |k1|
                                        (SPADCALL |k| (QREFELT $ 62)) . #4#)
                                       (EXIT
                                        (COND
                                          ((NULL (EQL |k1| 1))
                                           (PROGN
                                             (LETT #1#
                                              |$NoValue| . #4#)
                                             (GO #1#))))))
                                      (LETT |i| (+ |i| 1) . #4#)
                                      #6=(GO G190) G191 (EXIT NIL)))
                           #1# (EXIT #1#))
                      (LETT |gpsgs| NIL . #4#)
                      (LETT |words2| NIL . #4#)
                      (LETT |gplength| (LENGTH |group|) . #4#)
                      (SEQ (EXIT (SEQ (LETT |jj| 1 . #4#) G190
                                      (COND
                                        ((QSGREATERP |jj| |gplength|)
                                         #5#))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (EQL
                                             (SPADCALL
                                              (SPADCALL |group| |jj|
                                               (QREFELT $ 44))
                                              |i| (QREFELT $ 40))
                                             |i|))
                                           (PROGN
                                             (LETT #2#
                                              |$NoValue| . #4#)
                                             (GO #2#))))))
                                      (LETT |jj| (QSADD1 |jj|) . #4#)
                                      #6# G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (SEQ (LETT |k| 1 . #4#) G190
                           (COND ((QSGREATERP |k| |gplength|) #5#))
                           (SEQ (LETT |el2|
                                      (SPADCALL |group| |k|
                                       (QREFELT $ 44)) . #4#)
                                (EXIT (COND
                                        ((EQL
                                          (SPADCALL |el2| |i|
                                           (QREFELT $ 40))
                                          |i|)
                                         (SEQ
                                          (LETT |gpsgs|
                                           (CONS
                                            (|PERMGRP;times|
                                             (SPADCALL |group| |jj|
                                              (QREFELT $ 44))
                                             |el2| $)
                                            |gpsgs|) . #4#)
                                          (EXIT
                                           (COND
                                             ((QREFELT $ 20)
                                              (LETT |words2|
                                               (CONS
                                                (APPEND
                                                 (SPADCALL |words| |jj|
                                                  (QREFELT $ 46))
                                                 (SPADCALL |words| |k|
                                                  (QREFELT $ 46)))
                                                |words2|) . #4#))))))
                                        ('T
                                         (SEQ
                                          (LETT |gpsgs|
                                           (CONS |el2| |gpsgs|) . #4#)
                                          (EXIT
                                           (COND
                                             ((QREFELT $ 20)
                                              (LETT |words2|
                                               (CONS
                                                (SPADCALL |words| |k|
                                                 (QREFELT $ 46))
                                                |words2|) . #4#)))))))))
                           (LETT |k| (QSADD1 |k|) . #4#) #6# G191
                           (EXIT NIL))
                      (LETT |group2| NIL . #4#)
                      (LETT |words3| NIL . #4#) (LETT |j| 15 . #4#)
                      (SEQ G190 (COND ((NULL (< 0 |j|)) #5#))
                           (SEQ (LETT |ran|
                                      (|PERMGRP;ranelt| |group| |words|
                                       |maxLoops| $) . #4#)
                                (LETT |str|
                                      (|PERMGRP;strip| (QCAR |ran|)
                                       |ort| |group| |words| $) . #4#)
                                (LETT |el2| (QCAR |str|) . #4#)
                                (COND
                                  ((NULL
                                    (|PERMGRP;testIdentity| |el2| $))
                                   (COND
                                     ((NULL
                                       (SPADCALL |el2| |group2|
                                        (QREFELT $ 63)))
                                      (SEQ
                                       (LETT |group2|
                                        (CONS |el2| |group2|) . #4#)
                                       (COND
                                         ((QREFELT $ 20)
                                          (SEQ
                                           (LETT |help|
                                            (APPEND
                                             (REVERSE (QCDR |str|))
                                             (QCDR |ran|)) . #4#)
                                           (LETT |help|
                                            (|PERMGRP;shortenWord|
                                             |help| |gp| $) . #4#)
                                           (EXIT
                                            (LETT |words3|
                                             (CONS |help| |words3|) . #4#)))))
                                       (EXIT
                                        (LETT |j| (- |j| 2) . #4#)))))))
                                (EXIT (LETT |j| (- |j| 1) . #4#)))
                           NIL #6# G191 (EXIT NIL))
                      (COND
                        ((QREFELT $ 20)
                         (LETT |maxLoops| (- |maxLoops| |diff|) . #4#)))
                      (COND
                        ((OR (NULL |group2|) (< |maxLoops| 0))
                         (SEQ (SETELT $ 10 |k1|)
                              (SETELT $ 9 (LIST |i|))
                              (SETELT $ 13 (LIST |gpsgs|))
                              (SETELT $ 14 (LIST |words2|))
                              (EXIT (PROGN
                                      (LETT #3# (QREFELT $ 10) . #4#)
                                      (GO #3#))))))
                      (LETT |k2|
                            (|PERMGRP;bsgs1| |group2| (+ |i| 1)
                                |words3| |maxLoops| |gp| |diff| $) . #4#)
                      (SETELT $ 10 (* |k1| |k2|))
                      (SETELT $ 13
                              (APPEND (QREFELT $ 13) (LIST |gpsgs|)))
                      (SETELT $ 14
                              (APPEND (QREFELT $ 14) (LIST |words2|)))
                      (SETELT $ 9 (CONS |i| (QREFELT $ 9)))
                      (EXIT (QREFELT $ 10))))
           #3# (EXIT #3#))))) 

(DEFUN |PERMGRP;computeOrbits| (|kkk| $)
  (PROG (|i| #0=#:G1967 |pt| |obs| |orbitLength|)
    (RETURN
      (SEQ (SETELT $ 8 NIL)
           (LETT |orbitLength| NIL . #1=(|PERMGRP;computeOrbits|))
           (SETELT $ 12 NIL)
           (SEQ (LETT |i| 1 . #1#)
                (LETT #0#
                      (SPADCALL (QREFELT $ 9) (QREFELT $ 62)) . #1#)
                G190 (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (SETELT $ 8
                             (APPEND (QREFELT $ 8)
                                     (SPADCALL (QREFELT $ 13) |i|
                                      (QREFELT $ 65))))
                     (LETT |pt|
                           (+ (- (SPADCALL (QREFELT $ 9)
                                     (QREFELT $ 62))
                                 |i|)
                              1) . #1#)
                     (LETT |obs|
                           (|PERMGRP;orbitWithSvc| (QREFELT $ 8)
                               (SPADCALL (QREFELT $ 9) |pt|
                                   (QREFELT $ 30))
                               $) . #1#)
                     (LETT |orbitLength|
                           (CONS (SPADCALL (QCAR |obs|) (QREFELT $ 62))
                                 |orbitLength|) . #1#)
                     (EXIT (SETELT $ 12 (CONS |obs| (QREFELT $ 12)))))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (SETELT $ 12 (REVERSE (QREFELT $ 12)))
           (EXIT (REVERSE |orbitLength|)))))) 

(DEFUN |PERMGRP;reduceGenerators| (|kkk| $)
  (PROG (#0=#:G1983 |baseLength| |nnn| #1=#:G1984 |pt| |obs| |pos| |j|
            #2=#:G1985 |pt2| |sgs2| |obs2| |test| #3=#:G1974
            |removedGenerator| |i| |orbitLength|)
    (RETURN
      (SEQ (LETT |orbitLength| (|PERMGRP;computeOrbits| |kkk| $)
                 . #4=(|PERMGRP;reduceGenerators|))
           (SETELT $ 8 NIL) (SETELT $ 15 NIL)
           (SEQ (LETT |i| 1 . #4#) (LETT #0# (- |kkk| 1) . #4#) G190
                (COND ((QSGREATERP |i| #0#) #5=(GO G191)))
                (SEQ (SETELT $ 8
                             (APPEND (QREFELT $ 8)
                                     (SPADCALL (QREFELT $ 13) |i|
                                      (QREFELT $ 65))))
                     (EXIT (COND
                             ((QREFELT $ 20)
                              (SETELT $ 15
                                      (APPEND (QREFELT $ 15)
                                       (SPADCALL (QREFELT $ 14) |i|
                                        (QREFELT $ 67))))))))
                (LETT |i| (QSADD1 |i|) . #4#) #6=(GO G190) G191
                (EXIT NIL))
           (LETT |removedGenerator| 'NIL . #4#)
           (LETT |baseLength|
                 (SPADCALL (QREFELT $ 9) (QREFELT $ 62)) . #4#)
           (SEQ (LETT |nnn| |kkk| . #4#)
                (LETT #1# (- |baseLength| 1) . #4#) G190
                (COND ((> |nnn| #1#) #5#))
                (SEQ (SETELT $ 8
                             (APPEND (QREFELT $ 8)
                                     (SPADCALL (QREFELT $ 13) |nnn|
                                      (QREFELT $ 65))))
                     (COND
                       ((QREFELT $ 20)
                        (SETELT $ 15
                                (APPEND (QREFELT $ 15)
                                        (SPADCALL (QREFELT $ 14) |nnn|
                                         (QREFELT $ 67))))))
                     (LETT |pt| (+ (- |baseLength| |nnn|) 1) . #4#)
                     (LETT |obs|
                           (|PERMGRP;orbitWithSvc| (QREFELT $ 8)
                               (SPADCALL (QREFELT $ 9) |pt|
                                   (QREFELT $ 30))
                               $) . #4#)
                     (LETT |i| 1 . #4#)
                     (EXIT (SEQ G190
                                (COND
                                  ((NULL
                                    (COND
                                      ((<
                                        (LENGTH
                                         (SPADCALL (QREFELT $ 13) |nnn|
                                          (QREFELT $ 65)))
                                        |i|)
                                       'NIL)
                                      ('T 'T)))
                                   #5#))
                                (SEQ (LETT |pos|
                                      (SPADCALL
                                       (SPADCALL
                                        (SPADCALL (QREFELT $ 13) |nnn|
                                         (QREFELT $ 65))
                                        |i| (QREFELT $ 44))
                                       (QREFELT $ 8) (QREFELT $ 68)) . #4#)
                                     (LETT |sgs2|
                                      (SPADCALL (QREFELT $ 8) |pos|
                                       (QREFELT $ 69)) . #4#)
                                     (LETT |obs2|
                                      (|PERMGRP;orbitWithSvc| |sgs2|
                                       (SPADCALL (QREFELT $ 9) |pt|
                                        (QREFELT $ 30))
                                       $) . #4#)
                                     (EXIT
                                      (COND
                                        ((EQL
                                          (SPADCALL (QCAR |obs2|)
                                           (QREFELT $ 62))
                                          (SPADCALL |orbitLength| |nnn|
                                           (QREFELT $ 30)))
                                         (SEQ (LETT |test| 'T . #4#)
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (LETT |j|
                                              (+ |nnn| 1) . #4#)
                                             (LETT #2#
                                              (- |baseLength| 1) . #4#)
                                             G190
                                             (COND ((> |j| #2#) #5#))
                                             (SEQ
                                              (LETT |pt2|
                                               (+ (- |baseLength| |j|)
                                                1) . #4#)
                                              (LETT |sgs2|
                                               (APPEND |sgs2|
                                                (SPADCALL
                                                 (QREFELT $ 13) |j|
                                                 (QREFELT $ 65))) . #4#)
                                              (LETT |obs2|
                                               (|PERMGRP;orbitWithSvc|
                                                |sgs2|
                                                (SPADCALL (QREFELT $ 9)
                                                 |pt2| (QREFELT $ 30))
                                                $) . #4#)
                                              (EXIT
                                               (COND
                                                 ((NULL
                                                   (EQL
                                                    (SPADCALL
                                                     (QCAR |obs2|)
                                                     (QREFELT $ 62))
                                                    (SPADCALL
                                                     |orbitLength| |j|
                                                     (QREFELT $ 30))))
                                                  (SEQ
                                                   (LETT |test|
                                                    'NIL . #4#)
                                                   (EXIT
                                                    (PROGN
                                                      (LETT #3#
                                                       |$NoValue| . #4#)
                                                      (GO #3#))))))))
                                             (LETT |j| (+ |j| 1) . #4#)
                                             #6# G191 (EXIT NIL)))
                                           #3# (EXIT #3#))
                                          (EXIT
                                           (COND
                                             (|test|
                                              (SEQ
                                               (LETT |removedGenerator|
                                                'T . #4#)
                                               (SETELT $ 8
                                                (SPADCALL (QREFELT $ 8)
                                                 |pos| (QREFELT $ 69)))
                                               (COND
                                                 ((QREFELT $ 20)
                                                  (SETELT $ 15
                                                   (SPADCALL
                                                    (QREFELT $ 15)
                                                    |pos|
                                                    (QREFELT $ 70)))))
                                               (SPADCALL (QREFELT $ 13)
                                                |nnn|
                                                (SPADCALL
                                                 (SPADCALL
                                                  (QREFELT $ 13) |nnn|
                                                  (QREFELT $ 65))
                                                 |i| (QREFELT $ 69))
                                                (QREFELT $ 71))
                                               (EXIT
                                                (COND
                                                  ((QREFELT $ 20)
                                                   (SPADCALL
                                                    (QREFELT $ 14)
                                                    |nnn|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (QREFELT $ 14)
                                                      |nnn|
                                                      (QREFELT $ 67))
                                                     |i|
                                                     (QREFELT $ 70))
                                                    (QREFELT $ 72)))))))
                                             ('T
                                              (LETT |i|
                                               (+ |i| 1) . #4#))))))
                                        ('T (LETT |i| (+ |i| 1) . #4#)))))
                                NIL #6# G191 (EXIT NIL))))
                (LETT |nnn| (+ |nnn| 1) . #4#) #6# G191 (EXIT NIL))
           (COND
             (|removedGenerator|
                 (LETT |orbitLength|
                       (|PERMGRP;computeOrbits| |kkk| $) . #4#)))
           (EXIT (SPADCALL (QREFELT $ 74))))))) 

(DEFUN |PERMGRP;bsgs| (|group| |maxLoops| |diff| $)
  (PROG (#0=#:G2031 |gp| |ggg| #1=#:G2032 |q| #2=#:G2033 |newEl| |pos2|
            |words| |k| |newGroup| #3=#:G2034 #4=#:G2035 |gporbi| |pt|
            #5=#:G2036 |y1| |word3| |jjj| #6=#:G2037 |ppp| |s| |p|
            |entry| #7=#:G2004 #8=#:G2000 |ee| |z| |noresult|
            |noAnswer| |wd| #9=#:G2038 |word2| |ttt| |word| |i|
            #10=#:G2039 #11=#:G2023 |kkk| |j| #12=#:G2040)
    (RETURN
      (SEQ (EXIT (SEQ (SETELT $ 18 (|PERMGRP;pointList| |group| $))
                      (SETELT $ 11 (LENGTH (QREFELT $ 18)))
                      (COND
                        ((EQL (QREFELT $ 11) 0)
                         (SEQ (SETELT $ 10 1)
                              (SETELT $ 8 (LIST (VECTOR 0)))
                              (SETELT $ 9 NIL) (SETELT $ 12 NIL)
                              (EXIT (PROGN
                                      (LETT #0# (QREFELT $ 10)
                                       . #13=(|PERMGRP;bsgs|))
                                      (GO #0#))))))
                      (LETT |newGroup| NIL . #13#)
                      (LETT |gp| (QCAR |group|) . #13#)
                      (LETT |words| NIL . #13#)
                      (SEQ (LETT |ggg| 1 . #13#)
                           (LETT #1# (LENGTH |gp|) . #13#) G190
                           (COND
                             ((QSGREATERP |ggg| #1#) #14=(GO G191)))
                           (SEQ (LETT |q|
                                      (SPADCALL (QREFELT $ 11) 0
                                       (QREFELT $ 53)) . #13#)
                                (SEQ (LETT |i| 1 . #13#)
                                     (LETT #2# (QREFELT $ 11) . #13#)
                                     G190
                                     (COND
                                       ((QSGREATERP |i| #2#) #14#))
                                     (SEQ
                                      (LETT |newEl|
                                       (SPADCALL
                                        (SPADCALL |gp| |ggg|
                                         (QREFELT $ 75))
                                        (SPADCALL (QREFELT $ 18) |i|
                                         (QREFELT $ 50))
                                        (QREFELT $ 51)) . #13#)
                                      (LETT |pos2|
                                       (SPADCALL |newEl| (QREFELT $ 18)
                                        (QREFELT $ 76)) . #13#)
                                      (EXIT
                                       (SPADCALL |q| |i| |pos2|
                                        (QREFELT $ 54))))
                                     (LETT |i| (QSADD1 |i|) . #13#)
                                     #15=(GO G190) G191 (EXIT NIL))
                                (LETT |newGroup|
                                      (CONS |q| |newGroup|) . #13#)
                                (EXIT (COND
                                        ((QREFELT $ 20)
                                         (LETT |words|
                                          (CONS
                                           (SPADCALL |ggg|
                                            (QREFELT $ 77))
                                           |words|) . #13#)))))
                           (LETT |ggg| (QSADD1 |ggg|) . #13#) #15# G191
                           (EXIT NIL))
                      (COND
                        ((< |maxLoops| 1)
                         (COND
                           ((ZEROP (SPADCALL (QVELT (QCDR |group|) 2)
                                    (QREFELT $ 62)))
                            (SEQ (SETELT $ 20 'NIL)
                                 (LETT |k|
                                       (|PERMGRP;bsgs1| |newGroup| 1
                                        |words| 20 |group| 0 $) . #13#)
                                 (SETELT $ 20 'T)
                                 (EXIT (LETT |maxLoops|
                                        (-
                                         (SPADCALL (QREFELT $ 9)
                                          (QREFELT $ 62))
                                         1) . #13#))))
                           ('T
                            (LETT |maxLoops|
                                  (- (SPADCALL (QVELT (QCDR |group|) 2)
                                      (QREFELT $ 62))
                                     1) . #13#)))))
                      (LETT |k|
                            (|PERMGRP;bsgs1| |newGroup| 1 |words|
                                |maxLoops| |group| |diff| $) . #13#)
                      (LETT |kkk| 1 . #13#)
                      (LETT |newGroup| (REVERSE |newGroup|) . #13#)
                      (LETT |noAnswer| 'T . #13#)
                      (SEQ G190 (COND ((NULL |noAnswer|) #14#))
                           (SEQ (|PERMGRP;reduceGenerators| |kkk| $)
                                (SETELT $ 8 NIL) (SETELT $ 15 NIL)
                                (SEQ (LETT |i| 1 . #13#)
                                     (LETT #3# (- |kkk| 1) . #13#) G190
                                     (COND
                                       ((QSGREATERP |i| #3#) #14#))
                                     (SEQ
                                      (SETELT $ 8
                                       (APPEND (QREFELT $ 8)
                                        (SPADCALL (QREFELT $ 13) |i|
                                         (QREFELT $ 65))))
                                      (EXIT
                                       (COND
                                         ((QREFELT $ 20)
                                          (SETELT $ 15
                                           (APPEND (QREFELT $ 15)
                                            (SPADCALL (QREFELT $ 14)
                                             |i| (QREFELT $ 67))))))))
                                     (LETT |i| (QSADD1 |i|) . #13#)
                                     #15# G191 (EXIT NIL))
                                (LETT |noresult| 'T . #13#)
                                (SEQ (LETT |i| |kkk| . #13#)
                                     (LETT #4#
                                      (SPADCALL (QREFELT $ 9)
                                       (QREFELT $ 62)) . #13#)
                                     G190
                                     (COND
                                       ((OR (> |i| #4#)
                                         (NULL |noresult|))
                                        #14#))
                                     (SEQ
                                      (SETELT $ 8
                                       (APPEND (QREFELT $ 8)
                                        (SPADCALL (QREFELT $ 13) |i|
                                         (QREFELT $ 65))))
                                      (COND
                                        ((QREFELT $ 20)
                                         (SETELT $ 15
                                          (APPEND (QREFELT $ 15)
                                           (SPADCALL (QREFELT $ 14) |i|
                                            (QREFELT $ 67))))))
                                      (LETT |gporbi|
                                       (SPADCALL (QREFELT $ 12) |i|
                                        (QREFELT $ 80)) . #13#)
                                      (EXIT
                                       (SEQ (LETT |pt| NIL . #13#)
                                        (LETT #5#
                                         (QCAR |gporbi|) . #13#)
                                        G190
                                        (COND
                                          ((OR (ATOM #5#)
                                            (PROGN
                                              (LETT |pt|
                                               (CAR #5#) . #13#)
                                              NIL)
                                            (NULL |noresult|))
                                           #14#))
                                        (SEQ
                                         (LETT |ppp|
                                          (|PERMGRP;cosetRep| |pt|
                                           |gporbi| (QREFELT $ 8) $) . #13#)
                                         (LETT |y1|
                                          (|PERMGRP;inv| (QCAR |ppp|)
                                           $) . #13#)
                                         (LETT |word3|
                                          (QCDR |ppp|) . #13#)
                                         (EXIT
                                          (SEQ (LETT |jjj| 1 . #13#)
                                           (LETT #6#
                                            (LENGTH (QREFELT $ 8)) . #13#)
                                           G190
                                           (COND
                                             ((OR
                                               (QSGREATERP |jjj| #6#)
                                               (NULL |noresult|))
                                              #14#))
                                           (SEQ
                                            (LETT |word| NIL . #13#)
                                            (LETT |z|
                                             (|PERMGRP;times|
                                              (SPADCALL (QREFELT $ 8)
                                               |jjj| (QREFELT $ 44))
                                              |y1| $) . #13#)
                                            (COND
                                              ((QREFELT $ 20)
                                               (LETT |word|
                                                (APPEND
                                                 (SPADCALL
                                                  (QREFELT $ 15) |jjj|
                                                  (QREFELT $ 46))
                                                 |word|) . #13#)))
                                            (LETT |ppp|
                                             (|PERMGRP;cosetRep|
                                              (SPADCALL
                                               (SPADCALL (QREFELT $ 8)
                                                |jjj| (QREFELT $ 44))
                                               |pt| (QREFELT $ 40))
                                              |gporbi| (QREFELT $ 8) $) . #13#)
                                            (LETT |z|
                                             (|PERMGRP;times|
                                              (QCAR |ppp|) |z| $) . #13#)
                                            (COND
                                              ((QREFELT $ 20)
                                               (LETT |word|
                                                (APPEND (QCDR |ppp|)
                                                 |word|) . #13#)))
                                            (SETELT $ 17 'NIL)
                                            (SEQ
                                             (LETT |j|
                                              (- |i| 1) . #13#)
                                             G190
                                             (COND
                                               ((OR (< |j| 1)
                                                 (NULL |noresult|))
                                                #14#))
                                             (SEQ
                                              (LETT |s|
                                               (QCDR
                                                (SPADCALL
                                                 (QREFELT $ 12) |j|
                                                 (QREFELT $ 80))) . #13#)
                                              (LETT |p|
                                               (SPADCALL
                                                (QCAR
                                                 (SPADCALL
                                                  (QREFELT $ 12) |j|
                                                  (QREFELT $ 80)))
                                                1 (QREFELT $ 30)) . #13#)
                                              (EXIT
                                               (SEQ
                                                (EXIT
                                                 (SEQ G190
                                                  (COND
                                                    ((NULL
                                                      (COND
                                                        ((< 0
                                                          (QREFELT $
                                                           11))
                                                         |noresult|)
                                                        ('T 'NIL)))
                                                     #14#))
                                                  (SEQ
                                                   (LETT |entry|
                                                    (SPADCALL |s|
                                                     (SPADCALL |z| |p|
                                                      (QREFELT $ 40))
                                                     (QREFELT $ 42)) . #13#)
                                                   (EXIT
                                                    (COND
                                                      ((< |entry| 0)
                                                       (SEQ
                                                        (COND
                                                          ((EQL |entry|
                                                            -1)
                                                           (PROGN
                                                             (LETT #7#
                                                              |$NoValue| . #13#)
                                                             (GO #7#))))
                                                        (SETELT $ 16
                                                         (PROG1
                                                          (LETT #8#
                                                           |j| . #13#)
                                                           (|check-subtype|
                                                            (>= #8# 0)
                                                            '(|NonNegativeInteger|)
                                                            #8#)))
                                                        (EXIT
                                                         (LETT
                                                          |noresult|
                                                          'NIL . #13#))))
                                                      ('T
                                                       (SEQ
                                                        (LETT |ee|
                                                         (SPADCALL
                                                          (QREFELT $ 8)
                                                          |entry|
                                                          (QREFELT $
                                                           44)) . #13#)
                                                        (LETT |z|
                                                         (|PERMGRP;times|
                                                          |ee| |z| $) . #13#)
                                                        (EXIT
                                                         (COND
                                                           ((QREFELT $
                                                             20)
                                                            (LETT
                                                             |word|
                                                             (APPEND
                                                              (SPADCALL
                                                               (QREFELT
                                                                $ 15)
                                                               |entry|
                                                               (QREFELT
                                                                $ 46))
                                                              |word|) . #13#)))))))))
                                                  NIL #15# G191
                                                  (EXIT NIL)))
                                                #7# (EXIT #7#))))
                                             (LETT |j|
                                              (+ |j| -1) . #13#)
                                             #15# G191 (EXIT NIL))
                                            (EXIT
                                             (COND
                                               (|noresult|
                                                (SEQ (SETELT $ 16 1)
                                                 (SETELT $ 17 'T)
                                                 (EXIT
                                                  (LETT |noresult|
                                                   (|PERMGRP;testIdentity|
                                                    |z| $) . #13#)))))))
                                           (LETT |jjj|
                                            (QSADD1 |jjj|) . #13#)
                                           #15# G191 (EXIT NIL))))
                                        (LETT #5# (CDR #5#) . #13#)
                                        #15# G191 (EXIT NIL))))
                                     (LETT |i| (+ |i| 1) . #13#) #15#
                                     G191 (EXIT NIL))
                                (LETT |noAnswer|
                                      (COND
                                        ((|PERMGRP;testIdentity| |z| $)
                                         'NIL)
                                        ('T 'T)) . #13#)
                                (EXIT (COND
                                        (|noAnswer|
                                         (SEQ (LETT |word2| NIL . #13#)
                                          (COND
                                            ((QREFELT $ 20)
                                             (SEQ
                                              (SEQ
                                               (LETT |wd| NIL . #13#)
                                               (LETT #9#
                                                |word3| . #13#)
                                               G190
                                               (COND
                                                 ((OR (ATOM #9#)
                                                   (PROGN
                                                     (LETT |wd|
                                                      (CAR #9#) . #13#)
                                                     NIL))
                                                  #14#))
                                               (SEQ
                                                (LETT |ttt|
                                                 (SPADCALL |newGroup|
                                                  |wd| (QREFELT $ 44)) . #13#)
                                                (EXIT
                                                 (SEQ G190
                                                  (COND
                                                    ((NULL
                                                      (COND
                                                        ((|PERMGRP;testIdentity|
                                                          |ttt| $)
                                                         'NIL)
                                                        ('T 'T)))
                                                     #14#))
                                                  (SEQ
                                                   (LETT |word2|
                                                    (CONS |wd| |word2|) . #13#)
                                                   (EXIT
                                                    (LETT |ttt|
                                                     (|PERMGRP;times|
                                                      |ttt|
                                                      (SPADCALL
                                                       |newGroup| |wd|
                                                       (QREFELT $ 44))
                                                      $) . #13#)))
                                                  NIL #15# G191
                                                  (EXIT NIL))))
                                               (LETT #9#
                                                (CDR #9#) . #13#)
                                               #15# G191 (EXIT NIL))
                                              (LETT |word|
                                               (APPEND |word| |word2|) . #13#)
                                              (EXIT
                                               (LETT |word|
                                                (|PERMGRP;shortenWord|
                                                 |word| |group| $) . #13#)))))
                                          (COND
                                            ((QREFELT $ 17)
                                             (SEQ
                                              (SEQ
                                               (EXIT
                                                (SEQ
                                                 (LETT |i| 1 . #13#)
                                                 (LETT #10#
                                                  (QREFELT $ 11) . #13#)
                                                 G190
                                                 (COND
                                                   ((QSGREATERP |i|
                                                     #10#)
                                                    #14#))
                                                 (SEQ
                                                  (EXIT
                                                   (COND
                                                     ((NULL
                                                       (EQL
                                                        (SPADCALL |z|
                                                         |i|
                                                         (QREFELT $ 40))
                                                        |i|))
                                                      (SEQ
                                                       (SETELT $ 9
                                                        (APPEND
                                                         (QREFELT $ 9)
                                                         (LIST |i|)))
                                                       (EXIT
                                                        (PROGN
                                                          (LETT #11#
                                                           |$NoValue| . #13#)
                                                          (GO #11#))))))))
                                                 (LETT |i|
                                                  (QSADD1 |i|) . #13#)
                                                 #15# G191 (EXIT NIL)))
                                               #11# (EXIT #11#))
                                              (SETELT $ 13
                                               (CONS
                                                (SPADCALL |z|
                                                 (QREFELT $ 81))
                                                (QREFELT $ 13)))
                                              (EXIT
                                               (COND
                                                 ((QREFELT $ 20)
                                                  (SETELT $ 14
                                                   (CONS
                                                    (SPADCALL |word|
                                                     (QREFELT $ 82))
                                                    (QREFELT $ 14))))))))
                                            ('T
                                             (SEQ
                                              (SPADCALL (QREFELT $ 13)
                                               (QREFELT $ 16)
                                               (CONS |z|
                                                (SPADCALL
                                                 (QREFELT $ 13)
                                                 (QREFELT $ 16)
                                                 (QREFELT $ 65)))
                                               (QREFELT $ 71))
                                              (EXIT
                                               (COND
                                                 ((QREFELT $ 20)
                                                  (SPADCALL
                                                   (QREFELT $ 14)
                                                   (QREFELT $ 16)
                                                   (CONS |word|
                                                    (SPADCALL
                                                     (QREFELT $ 14)
                                                     (QREFELT $ 16)
                                                     (QREFELT $ 67)))
                                                   (QREFELT $ 72))))))))
                                          (EXIT
                                           (LETT |kkk|
                                            (QREFELT $ 16) . #13#)))))))
                           NIL #15# G191 (EXIT NIL))
                      (SETELT $ 10 1)
                      (SEQ (LETT |j| 1 . #13#)
                           (LETT #12#
                                 (SPADCALL (QREFELT $ 9)
                                     (QREFELT $ 62)) . #13#)
                           G190 (COND ((QSGREATERP |j| #12#) #14#))
                           (SEQ (EXIT (SETELT $ 10
                                       (* (QREFELT $ 10)
                                        (SPADCALL
                                         (QCAR
                                          (SPADCALL (QREFELT $ 12) |j|
                                           (QREFELT $ 80)))
                                         (QREFELT $ 62))))))
                           (LETT |j| (QSADD1 |j|) . #13#) #15# G191
                           (EXIT NIL))
                      (EXIT (QREFELT $ 10))))
           #0# (EXIT #0#))))) 

(DEFUN |PERMGRP;initialize| (|group| $)
  (PROG (|group2| |gp| |gen| #0=#:G2046)
    (RETURN
      (SEQ (LETT |group2| (SPADCALL (QREFELT $ 84))
                 . #1=(|PERMGRP;initialize|))
           (LETT |gp| (QCAR |group|) . #1#)
           (SEQ (LETT |gen| NIL . #1#) (LETT #0# |gp| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |gen| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (COND
                             ((< 0 (SPADCALL |gen| (QREFELT $ 85)))
                              (SPADCALL |gen| |group2| (QREFELT $ 86))))))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT |group2|))))) 

(DEFUN |PERMGRP;knownGroup?| (|gp| $)
  (PROG (|result|)
    (RETURN
      (SEQ (LETT |result| (QCDR |gp|) . #0=(|PERMGRP;knownGroup?|))
           (COND
             ((EQL (QVELT |result| 0) 0)
              (SEQ (SETELT $ 20 'NIL)
                   (SETELT $ 19 (|PERMGRP;bsgs| |gp| 20 0 $))
                   (LETT |result|
                         (VECTOR (QREFELT $ 19) (QREFELT $ 8)
                                 (QREFELT $ 9) (QREFELT $ 12)
                                 (QREFELT $ 18) NIL) . #0#)
                   (EXIT (PROGN (RPLACD |gp| |result|) (QCDR |gp|)))))
             ('T
              (SEQ (SETELT $ 19 (QVELT |result| 0))
                   (SETELT $ 8 (QVELT |result| 1))
                   (SETELT $ 9 (QVELT |result| 2))
                   (SETELT $ 12 (QVELT |result| 3))
                   (SETELT $ 18 (QVELT |result| 4))
                   (EXIT (SETELT $ 15 (QVELT |result| 5))))))
           (EXIT (SPADCALL (QREFELT $ 74))))))) 

(DEFUN |PERMGRP;subgroup| (|gp1| |gp2| $)
  (PROG (|gpset1| |gpset2| |el| #0=#:G2059 #1=#:G2058 #2=#:G2055)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |gpset1| (|PERMGRP;initialize| |gp1| $)
                            . #3=(|PERMGRP;subgroup|))
                      (LETT |gpset2|
                            (|PERMGRP;initialize| |gp2| $) . #3#)
                      (EXIT (COND
                              ((SPADCALL
                                   (SPADCALL |gpset1| |gpset2|
                                    (QREFELT $ 87))
                                   (QREFELT $ 88))
                               'T)
                              ('T
                               (SEQ (SEQ
                                     (EXIT
                                      (SEQ (LETT |el| NIL . #3#)
                                       (LETT #0#
                                        (SPADCALL |gpset1|
                                         (QREFELT $ 89)) . #3#)
                                       G190
                                       (COND
                                         ((OR (ATOM #0#)
                                           (PROGN
                                             (LETT |el|
                                              (CAR #0#) . #3#)
                                             NIL))
                                          (GO G191)))
                                       (SEQ
                                        (EXIT
                                         (COND
                                           ((NULL
                                             (SPADCALL |el| |gp2|
                                              (QREFELT $ 90)))
                                            (PROGN
                                              (LETT #2#
                                               (PROGN
                                                 (LETT #1# 'NIL . #3#)
                                                 (GO #1#)) . #3#)
                                              (GO #2#))))))
                                       (LETT #0# (CDR #0#) . #3#)
                                       (GO G190) G191 (EXIT NIL)))
                                     #2# (EXIT #2#))
                                    (EXIT 'T)))))))
           #1# (EXIT #1#))))) 

(DEFUN |PERMGRP;memberInternal| (|p| |gp| |flag| $)
  (PROG (|mP| |x| #0=#:G2078 #1=#:G2062 #2=#:G2077 |result| #3=#:G2079
              |el| |pos| #4=#:G2068 #5=#:G2080 #6=#:G2071 |lw| |words|
              |i| |str| |pp| |outlist|)
    (RETURN
      (SEQ (EXIT (SEQ (SETELT $ 18 (|PERMGRP;pointList| |gp| $))
                      (LETT |outlist| NIL
                            . #7=(|PERMGRP;memberInternal|))
                      (LETT |mP|
                            (SPADCALL (SPADCALL |p| (QREFELT $ 57))
                                (QREFELT $ 59)) . #7#)
                      (SEQ (EXIT (SEQ (LETT |x| NIL . #7#)
                                      (LETT #0# |mP| . #7#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |x| (CAR #0#) . #7#)
                                            NIL))
                                         #8=(GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |x|
                                             (QREFELT $ 18)
                                             (QREFELT $ 91)))
                                           (PROGN
                                             (LETT #1#
                                              (PROGN
                                                (LETT #2#
                                                 (CONS 'NIL NIL) . #7#)
                                                (GO #2#)) . #7#)
                                             (GO #1#))))))
                                      (LETT #0# (CDR #0#) . #7#)
                                      #9=(GO G190) G191 (EXIT NIL)))
                           #1# (EXIT #1#))
                      (COND
                        (|flag| (COND
                                  ((SPADCALL |p| (QCAR |gp|)
                                    (QREFELT $ 92))
                                   (PROGN
                                     (LETT #2# (CONS 'T NIL) . #7#)
                                     (GO #2#)))
                                  ('T (|PERMGRP;knownGroup?| |gp| $))))
                        ('T
                         (SEQ (LETT |result| (QCDR |gp|) . #7#)
                              (EXIT (COND
                                      ((EQL (LENGTH (QVELT |result| 5))
                                        0)
                                       (SPADCALL |gp| (QREFELT $ 93)))
                                      ('T
                                       (SEQ
                                        (SETELT $ 19
                                         (QVELT |result| 0))
                                        (SETELT $ 8 (QVELT |result| 1))
                                        (SETELT $ 9 (QVELT |result| 2))
                                        (SETELT $ 12
                                         (QVELT |result| 3))
                                        (SETELT $ 18
                                         (QVELT |result| 4))
                                        (EXIT
                                         (SETELT $ 15
                                          (QVELT |result| 5))))))))))
                      (SETELT $ 11 (LENGTH (QREFELT $ 18)))
                      (LETT |pp|
                            (SPADCALL (QREFELT $ 11) 0 (QREFELT $ 53)) . #7#)
                      (SEQ (LETT |i| 1 . #7#)
                           (LETT #3# (QREFELT $ 11) . #7#) G190
                           (COND ((QSGREATERP |i| #3#) #8#))
                           (SEQ (LETT |el|
                                      (SPADCALL |p|
                                       (SPADCALL (QREFELT $ 18) |i|
                                        (QREFELT $ 50))
                                       (QREFELT $ 51)) . #7#)
                                (LETT |pos|
                                      (SPADCALL |el| (QREFELT $ 18)
                                       (QREFELT $ 76)) . #7#)
                                (EXIT (SPADCALL |pp| |i|
                                       (PROG1 (LETT #4# |pos| . #7#)
                                         (|check-subtype| (>= #4# 0)
                                          '(|NonNegativeInteger|) #4#))
                                       (QREFELT $ 54))))
                           (LETT |i| (QSADD1 |i|) . #7#) #9# G191
                           (EXIT NIL))
                      (LETT |words| NIL . #7#)
                      (COND
                        ((QREFELT $ 20)
                         (SEQ (LETT |i| 1 . #7#)
                              (LETT #5# (LENGTH (QREFELT $ 8)) . #7#)
                              G190 (COND ((QSGREATERP |i| #5#) #8#))
                              (SEQ (LETT |lw|
                                    (LIST
                                     (PROG1
                                      (LETT #6#
                                       (+
                                        (- (LENGTH (QREFELT $ 8)) |i|)
                                        1) . #7#)
                                       (|check-subtype| (>= #6# 0)
                                        '(|NonNegativeInteger|) #6#))) . #7#)
                                   (EXIT
                                    (LETT |words|
                                     (CONS |lw| |words|) . #7#)))
                              (LETT |i| (QSADD1 |i|) . #7#) #9# G191
                              (EXIT NIL))))
                      (SEQ (LETT |i|
                                 (SPADCALL (QREFELT $ 9)
                                     (QREFELT $ 62)) . #7#)
                           G190 (COND ((< |i| 1) #8#))
                           (SEQ (LETT |str|
                                      (|PERMGRP;strip| |pp|
                                       (SPADCALL (QREFELT $ 12) |i|
                                        (QREFELT $ 80))
                                       (QREFELT $ 8) |words| $) . #7#)
                                (LETT |pp| (QCAR |str|) . #7#)
                                (EXIT (COND
                                        ((QREFELT $ 20)
                                         (LETT |outlist|
                                          (APPEND |outlist|
                                           (QCDR |str|)) . #7#)))))
                           (LETT |i| (+ |i| -1) . #7#) #9# G191
                           (EXIT NIL))
                      (EXIT (CONS (|PERMGRP;testIdentity| |pp| $)
                                  (REVERSE |outlist|)))))
           #2# (EXIT #2#))))) 

(PUT '|PERMGRP;coerce;$L;19| '|SPADreplace| 'QCAR) 

(DEFUN |PERMGRP;coerce;$L;19| (|gp| $) (QCAR |gp|)) 

(PUT '|PERMGRP;generators;$L;20| '|SPADreplace| 'QCAR) 

(DEFUN |PERMGRP;generators;$L;20| (|gp| $) (QCAR |gp|)) 

(DEFUN |PERMGRP;strongGenerators;$L;21| (|group| $)
  (PROG (|i| #0=#:G2088 |j| #1=#:G2089 |pairs| |strongGens|)
    (RETURN
      (SEQ (|PERMGRP;knownGroup?| |group| $)
           (SETELT $ 11 (LENGTH (QREFELT $ 18)))
           (LETT |strongGens| NIL
                 . #2=(|PERMGRP;strongGenerators;$L;21|))
           (SEQ (LETT |i| NIL . #2#) (LETT #0# (QREFELT $ 8) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |i| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (LETT |pairs| NIL . #2#)
                     (SEQ (LETT |j| 1 . #2#)
                          (LETT #1# (QREFELT $ 11) . #2#) G190
                          (COND ((QSGREATERP |j| #1#) #3#))
                          (SEQ (EXIT (LETT |pairs|
                                      (CONS
                                       (LIST
                                        (SPADCALL (QREFELT $ 18) |j|
                                         (QREFELT $ 50))
                                        (SPADCALL (QREFELT $ 18)
                                         (SPADCALL |i| |j|
                                          (QREFELT $ 40))
                                         (QREFELT $ 50)))
                                       |pairs|) . #2#)))
                          (LETT |j| (QSADD1 |j|) . #2#) #4=(GO G190)
                          G191 (EXIT NIL))
                     (EXIT (LETT |strongGens|
                                 (CONS (SPADCALL |pairs|
                                        (QREFELT $ 95))
                                       |strongGens|) . #2#)))
                (LETT #0# (CDR #0#) . #2#) #4# G191 (EXIT NIL))
           (EXIT (REVERSE |strongGens|)))))) 

(DEFUN |PERMGRP;elt;$NniP;22| (|gp| |i| $)
  (SPADCALL (QCAR |gp|) |i| (QREFELT $ 75))) 

(DEFUN |PERMGRP;movedPoints;$S;23| (|gp| $)
  (SPADCALL (|PERMGRP;pointList| |gp| $) (QREFELT $ 98))) 

(DEFUN |PERMGRP;random;$IP;24| (|group| |maximalNumberOfFactors| $)
  (PROG (|gp| |numberOfGenerators| |randomInteger| |randomElement|
              |numberOfLoops|)
    (RETURN
      (SEQ (COND
             ((< |maximalNumberOfFactors| 1) (|spadConstant| $ 35))
             ('T
              (SEQ (LETT |gp| (QCAR |group|)
                         . #0=(|PERMGRP;random;$IP;24|))
                   (LETT |numberOfGenerators| (LENGTH |gp|) . #0#)
                   (LETT |randomInteger|
                         (+ 1 (RANDOM |numberOfGenerators|)) . #0#)
                   (LETT |randomElement|
                         (SPADCALL |gp| |randomInteger| (QREFELT $ 75)) . #0#)
                   (LETT |numberOfLoops|
                         (+ 1 (RANDOM |maximalNumberOfFactors|)) . #0#)
                   (SEQ G190
                        (COND
                          ((NULL (< 0 |numberOfLoops|)) (GO G191)))
                        (SEQ (LETT |randomInteger|
                                   (+ 1 (RANDOM |numberOfGenerators|)) . #0#)
                             (LETT |randomElement|
                                   (SPADCALL
                                    (SPADCALL |gp| |randomInteger|
                                     (QREFELT $ 75))
                                    |randomElement| (QREFELT $ 100)) . #0#)
                             (EXIT (LETT |numberOfLoops|
                                    (- |numberOfLoops| 1) . #0#)))
                        NIL (GO G190) G191 (EXIT NIL))
                   (EXIT |randomElement|)))))))) 

(DEFUN |PERMGRP;random;$P;25| (|group| $)
  (SPADCALL |group| 20 (QREFELT $ 101))) 

(DEFUN |PERMGRP;order;$Nni;26| (|group| $)
  (SEQ (|PERMGRP;knownGroup?| |group| $) (EXIT (QREFELT $ 19)))) 

(DEFUN |PERMGRP;degree;$Nni;27| (|group| $)
  (LENGTH (|PERMGRP;pointList| |group| $))) 

(DEFUN |PERMGRP;base;$L;28| (|group| $)
  (PROG (|i| #0=#:G2105 |groupBase|)
    (RETURN
      (SEQ (|PERMGRP;knownGroup?| |group| $)
           (LETT |groupBase| NIL . #1=(|PERMGRP;base;$L;28|))
           (SEQ (LETT |i| NIL . #1#) (LETT #0# (QREFELT $ 9) . #1#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |i| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |groupBase|
                                 (CONS (SPADCALL (QREFELT $ 18) |i|
                                        (QREFELT $ 50))
                                       |groupBase|) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (REVERSE |groupBase|)))))) 

(DEFUN |PERMGRP;wordsForStrongGenerators;$L;29| (|group| $)
  (SEQ (|PERMGRP;knownGroup?| |group| $) (EXIT (QREFELT $ 15)))) 

(DEFUN |PERMGRP;coerce;L$;30| (|gp| $)
  (PROG (|result| |group|)
    (RETURN
      (SEQ (LETT |result| (VECTOR 0 NIL NIL NIL NIL NIL)
                 . #0=(|PERMGRP;coerce;L$;30|))
           (EXIT (LETT |group| (CONS |gp| |result|) . #0#)))))) 

(DEFUN |PERMGRP;permutationGroup;L$;31| (|gp| $)
  (PROG (|result| |group|)
    (RETURN
      (SEQ (LETT |result| (VECTOR 0 NIL NIL NIL NIL NIL)
                 . #0=(|PERMGRP;permutationGroup;L$;31|))
           (EXIT (LETT |group| (CONS |gp| |result|) . #0#)))))) 

(DEFUN |PERMGRP;coerce;$Of;32| (|group| $)
  (PROG (|gp| |i| |outList|)
    (RETURN
      (SEQ (LETT |outList| NIL . #0=(|PERMGRP;coerce;$Of;32|))
           (LETT |gp| (QCAR |group|) . #0#)
           (SEQ (LETT |i| (SPADCALL |gp| (QREFELT $ 109)) . #0#) G190
                (COND ((< |i| 1) (GO G191)))
                (SEQ (EXIT (LETT |outList|
                                 (CONS (SPADCALL
                                        (SPADCALL |gp| |i|
                                         (QREFELT $ 75))
                                        (QREFELT $ 111))
                                       |outList|) . #0#)))
                (LETT |i| (+ |i| -1) . #0#) (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL
                     (SPADCALL (SPADCALL ">" (QREFELT $ 114))
                         (QREFELT $ 115))
                     (SPADCALL (SPADCALL |outList| (QREFELT $ 117))
                         (SPADCALL (SPADCALL "<" (QREFELT $ 114))
                             (QREFELT $ 115))
                         (QREFELT $ 118))
                     (QREFELT $ 118))))))) 

(DEFUN |PERMGRP;orbit;$SS;33| (|gp| |el| $)
  (PROG (|elList| |outList| |outSet| |i| #0=#:G2122)
    (RETURN
      (SEQ (LETT |elList| (LIST |el|) . #1=(|PERMGRP;orbit;$SS;33|))
           (LETT |outList|
                 (|PERMGRP;orbitInternal| |gp| |elList| $) . #1#)
           (LETT |outSet| (SPADCALL (QREFELT $ 56)) . #1#)
           (SEQ (LETT |i| 1 . #1#) (LETT #0# (LENGTH |outList|) . #1#)
                G190 (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (EXIT (SPADCALL
                               (SPADCALL
                                   (SPADCALL |outList| |i|
                                    (QREFELT $ 49))
                                   1 (QREFELT $ 50))
                               |outSet| (QREFELT $ 120))))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (EXIT |outSet|))))) 

(DEFUN |PERMGRP;orbits;$S;34| (|gp| $)
  (PROG (|el| |orbitSet| |orbits| |spp|)
    (RETURN
      (SEQ (LETT |spp| (SPADCALL |gp| (QREFELT $ 99))
                 . #0=(|PERMGRP;orbits;$S;34|))
           (LETT |orbits| NIL . #0#)
           (SEQ G190
                (COND
                  ((NULL (< 0 (SPADCALL |spp| (QREFELT $ 122))))
                   (GO G191)))
                (SEQ (LETT |el| (SPADCALL |spp| (QREFELT $ 123)) . #0#)
                     (LETT |orbitSet|
                           (SPADCALL |gp| |el| (QREFELT $ 121)) . #0#)
                     (LETT |orbits| (CONS |orbitSet| |orbits|) . #0#)
                     (EXIT (LETT |spp|
                                 (SPADCALL |spp| |orbitSet|
                                     (QREFELT $ 124)) . #0#)))
                NIL (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL |orbits| (QREFELT $ 127))))))) 

(DEFUN |PERMGRP;member?;P$B;35| (|p| |gp| $)
  (PROG (|mi|)
    (RETURN
      (SEQ (SETELT $ 20 'NIL)
           (LETT |mi| (|PERMGRP;memberInternal| |p| |gp| 'T $)
                 |PERMGRP;member?;P$B;35|)
           (EXIT (QCAR |mi|)))))) 

(DEFUN |PERMGRP;wordInStrongGenerators;P$L;36| (|p| |gp| $)
  (PROG (|mi|)
    (RETURN
      (SEQ (LETT |mi|
                 (|PERMGRP;memberInternal|
                     (SPADCALL |p| (QREFELT $ 129)) |gp| 'NIL $)
                 |PERMGRP;wordInStrongGenerators;P$L;36|)
           (COND
             ((NULL (QCAR |mi|))
              (EXIT (|error| "p is not an element of gp"))))
           (EXIT (QCDR |mi|)))))) 

(DEFUN |PERMGRP;wordInGenerators;P$L;37| (|p| |gp| $)
  (PROG (|lll| |wd| #0=#:G2136 |outlist|)
    (RETURN
      (SEQ (LETT |lll| (SPADCALL |p| |gp| (QREFELT $ 130))
                 . #1=(|PERMGRP;wordInGenerators;P$L;37|))
           (LETT |outlist| NIL . #1#)
           (SEQ (LETT |wd| NIL . #1#) (LETT #0# |lll| . #1#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |wd| (CAR #0#) . #1#) NIL))
                   (GO G191)))
                (SEQ (EXIT (LETT |outlist|
                                 (APPEND |outlist|
                                         (SPADCALL (QREFELT $ 15) |wd|
                                          (QREFELT $ 46))) . #1#)))
                (LETT #0# (CDR #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (|PERMGRP;shortenWord| |outlist| |gp| $)))))) 

(DEFUN |PERMGRP;<;2$B;38| (|gp1| |gp2| $)
  (COND
    ((NULL (SPADCALL
               (SPADCALL (SPADCALL |gp1| (QREFELT $ 99))
                   (SPADCALL |gp2| (QREFELT $ 99)) (QREFELT $ 124))
               (QREFELT $ 132)))
     'NIL)
    ((NULL (|PERMGRP;subgroup| |gp1| |gp2| $)) 'NIL)
    ('T
     (COND
       ((EQL (SPADCALL |gp1| (QREFELT $ 103))
             (SPADCALL |gp2| (QREFELT $ 103)))
        'NIL)
       ('T 'T))))) 

(DEFUN |PERMGRP;<=;2$B;39| (|gp1| |gp2| $)
  (COND
    ((NULL (SPADCALL
               (SPADCALL (SPADCALL |gp1| (QREFELT $ 99))
                   (SPADCALL |gp2| (QREFELT $ 99)) (QREFELT $ 124))
               (QREFELT $ 132)))
     'NIL)
    ('T (|PERMGRP;subgroup| |gp1| |gp2| $)))) 

(DEFUN |PERMGRP;=;2$B;40| (|gp1| |gp2| $)
  (PROG (#0=#:G2151)
    (RETURN
      (SEQ (EXIT (COND
                   ((NULL (SPADCALL (SPADCALL |gp1| (QREFELT $ 99))
                              (SPADCALL |gp2| (QREFELT $ 99))
                              (QREFELT $ 135)))
                    'NIL)
                   ('T
                    (SEQ (COND
                           ((< (LENGTH (QCAR |gp2|))
                               (LENGTH (QCAR |gp1|)))
                            (COND
                              ((NULL (|PERMGRP;subgroup| |gp2| |gp1| $))
                               (EXIT (PROGN
                                       (LETT #0# 'NIL
                                        . #1=(|PERMGRP;=;2$B;40|))
                                       (GO #0#))))))
                           ((NULL (|PERMGRP;subgroup| |gp1| |gp2| $))
                            (EXIT (PROGN
                                    (LETT #0# 'NIL . #1#)
                                    (GO #0#)))))
                         (EXIT (COND
                                 ((EQL (SPADCALL |gp1| (QREFELT $ 103))
                                       (SPADCALL |gp2| (QREFELT $ 103)))
                                  'T)
                                 ('T 'NIL)))))))
           #0# (EXIT #0#))))) 

(DEFUN |PERMGRP;orbit;$SS;41| (|gp| |startSet| $)
  (PROG (|startList| |outList| |outSet| |i| #0=#:G2156 |newSet|)
    (RETURN
      (SEQ (LETT |startList| (SPADCALL |startSet| (QREFELT $ 59))
                 . #1=(|PERMGRP;orbit;$SS;41|))
           (LETT |outList|
                 (|PERMGRP;orbitInternal| |gp| |startList| $) . #1#)
           (LETT |outSet| (SPADCALL (QREFELT $ 137)) . #1#)
           (SEQ (LETT |i| 1 . #1#) (LETT #0# (LENGTH |outList|) . #1#)
                G190 (COND ((QSGREATERP |i| #0#) (GO G191)))
                (SEQ (LETT |newSet|
                           (SPADCALL (SPADCALL |outList| |i|
                                      (QREFELT $ 49))
                                     (QREFELT $ 98)) . #1#)
                     (EXIT (SPADCALL |newSet| |outSet| (QREFELT $ 138))))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (EXIT |outSet|))))) 

(DEFUN |PERMGRP;orbit;$LS;42| (|gp| |startList| $)
  (SPADCALL (|PERMGRP;orbitInternal| |gp| |startList| $)
      (QREFELT $ 141))) 

(DEFUN |PERMGRP;initializeGroupForWordProblem;$2IV;43|
       (|gp| |maxLoops| |diff| $)
  (SEQ (SETELT $ 20 'T)
       (SETELT $ 19 (|PERMGRP;bsgs| |gp| |maxLoops| |diff| $))
       (PROGN
         (RPLACD |gp|
                 (VECTOR (QREFELT $ 19) (QREFELT $ 8) (QREFELT $ 9)
                         (QREFELT $ 12) (QREFELT $ 18) (QREFELT $ 15)))
         (QCDR |gp|))
       (EXIT (SPADCALL (QREFELT $ 74))))) 

(DEFUN |PERMGRP;initializeGroupForWordProblem;$V;44| (|gp| $)
  (SPADCALL |gp| 0 1 (QREFELT $ 143))) 

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

(DEFUN |PermutationGroup;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|PermutationGroup|))
        (LETT |dv$| (LIST '|PermutationGroup| DV$1) . #0#)
        (LETT $ (GETREFV 145) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|PermutationGroup| (LIST DV$1)
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7
            (|Record| (|:| |gens| (|List| (|Permutation| |#1|)))
                (|:| |information|
                     (|Record| (|:| |order| (|NonNegativeInteger|))
                         (|:| |sgset|
                              (|List| (|Vector| (|NonNegativeInteger|))))
                         (|:| |gpbase| (|List| (|NonNegativeInteger|)))
                         (|:| |orbs|
                              (|List| (|Record|
                                       (|:| |orb|
                                        (|List| (|NonNegativeInteger|)))
                                       (|:| |svc|
                                        (|Vector| (|Integer|))))))
                         (|:| |mp| (|List| |#1|))
                         (|:| |wd|
                              (|List| (|List| (|NonNegativeInteger|))))))))
        (QSETREFV $ 8 NIL)
        (QSETREFV $ 9 NIL)
        (QSETREFV $ 10 1)
        (QSETREFV $ 11 0)
        (QSETREFV $ 12 NIL)
        (QSETREFV $ 13 NIL)
        (QSETREFV $ 14 NIL)
        (QSETREFV $ 15 NIL)
        (QSETREFV $ 16 0)
        (QSETREFV $ 17 'T)
        (QSETREFV $ 18 NIL)
        (QSETREFV $ 19 1)
        (QSETREFV $ 20 'T)
        $)))) 

(MAKEPROP '|PermutationGroup| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep| '|sgs|
             '|baseOfGroup| '|sizeOfGroup| '|degree| '|gporb| '|out|
             '|outword| '|wordlist| '|basePoint| '|newBasePoint|
             '|supp| '|ord| '|wordProblem| (|List| 24)
             |PERMGRP;coerce;$L;19| (|NonNegativeInteger|)
             (|Permutation| 6) (0 . |order|) (|List| 23) (5 . |copy|)
             (|Integer|) (10 . |maxIndex|) (15 . |elt|) (|Boolean|)
             (21 . |member?|) (27 . |position|) (33 . |delete|)
             (39 . |One|) (43 . |setelt|) (50 . |first|) (|Vector| 23)
             (56 . |qelt|) (62 . |elt|) (|Vector| 28) (68 . |elt|)
             (|List| 38) (74 . |elt|) (|List| 26) (80 . |elt|)
             (|List| 6) (|List| 47) (86 . |elt|) (92 . |elt|)
             (98 . |eval|) (104 . |member?|) (110 . |new|)
             (116 . |setelt|) (|Set| 6) (123 . |brace|)
             (127 . |movedPoints|) (132 . |union|) (138 . |parts|)
             (143 . |new|) (149 . |setelt|) (156 . |#|)
             (161 . |member?|) (|List| 43) (167 . |elt|) (|List| 45)
             (173 . |elt|) (179 . |position|) (185 . |delete|)
             (191 . |delete|) (197 . |setelt|) (204 . |setelt|)
             (|Void|) (211 . |void|) (215 . |elt|) (221 . |position|)
             (227 . |list|) (|Record| (|:| |orb| 26) (|:| |svc| 41))
             (|List| 78) (232 . |elt|) (238 . |list|) (243 . |list|)
             (|Set| 24) (248 . |brace|) (252 . |degree|)
             (257 . |insert!|) (263 . |difference|) (269 . |empty?|)
             (274 . |parts|) |PERMGRP;member?;P$B;35| (279 . |member?|)
             (285 . |member?|)
             |PERMGRP;initializeGroupForWordProblem;$V;44|
             |PERMGRP;generators;$L;20| (291 . |coerceListOfPairs|)
             |PERMGRP;strongGenerators;$L;21| |PERMGRP;elt;$NniP;22|
             (296 . |brace|) |PERMGRP;movedPoints;$S;23| (301 . *)
             |PERMGRP;random;$IP;24| |PERMGRP;random;$P;25|
             |PERMGRP;order;$Nni;26| |PERMGRP;degree;$Nni;27|
             |PERMGRP;base;$L;28|
             |PERMGRP;wordsForStrongGenerators;$L;29|
             |PERMGRP;coerce;L$;30| |PERMGRP;permutationGroup;L$;31|
             (307 . |maxIndex|) (|OutputForm|) (312 . |coerce|)
             (|String|) (|Symbol|) (317 . |coerce|)
             (322 . |outputForm|) (|List| $) (327 . |commaSeparate|)
             (332 . |postfix|) |PERMGRP;coerce;$Of;32|
             (338 . |insert!|) |PERMGRP;orbit;$SS;33|
             (344 . |cardinality|) (349 . |extract!|)
             (354 . |difference|) (|List| 55) (|Set| 55)
             (360 . |brace|) |PERMGRP;orbits;$S;34| (365 . |inv|)
             |PERMGRP;wordInStrongGenerators;P$L;36|
             |PERMGRP;wordInGenerators;P$L;37| (370 . |empty?|)
             |PERMGRP;<;2$B;38| |PERMGRP;<=;2$B;39| (375 . =)
             |PERMGRP;=;2$B;40| (381 . |brace|) (385 . |insert!|)
             |PERMGRP;orbit;$SS;41| (|Set| 47) (391 . |brace|)
             |PERMGRP;orbit;$LS;42|
             |PERMGRP;initializeGroupForWordProblem;$2IV;43|
             (|SingleInteger|))
          '#(~= 396 |wordsForStrongGenerators| 402
             |wordInStrongGenerators| 407 |wordInGenerators| 413
             |strongGenerators| 419 |random| 424 |permutationGroup| 435
             |order| 440 |orbits| 445 |orbit| 450 |movedPoints| 468
             |member?| 473 |latex| 479 |initializeGroupForWordProblem|
             484 |hash| 496 |generators| 501 |elt| 506 |degree| 512
             |coerce| 517 |base| 532 = 537 <= 543 < 549)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0 0 0))
                (CONS '#(|SetCategory&| |BasicType&| NIL)
                      (CONS '#((|SetCategory|) (|BasicType|)
                               (|CoercibleTo| 110))
                            (|makeByteWordVec2| 144
                                '(1 24 23 0 25 1 26 0 0 27 1 26 28 0 29
                                  2 26 23 0 28 30 2 26 31 23 0 32 2 26
                                  28 23 0 33 2 26 0 0 28 34 0 24 0 35 3
                                  26 23 0 28 23 36 2 26 0 0 23 37 2 38
                                  23 0 28 39 2 38 23 0 28 40 2 41 28 0
                                  28 42 2 43 38 0 28 44 2 45 26 0 28 46
                                  2 48 47 0 28 49 2 47 6 0 28 50 2 24 6
                                  0 6 51 2 48 31 47 0 52 2 38 0 23 23
                                  53 3 38 23 0 28 23 54 0 55 0 56 1 24
                                  55 0 57 2 55 0 0 0 58 1 55 47 0 59 2
                                  41 0 23 28 60 3 41 28 0 28 28 61 1 26
                                  23 0 62 2 43 31 38 0 63 2 64 43 0 28
                                  65 2 66 45 0 28 67 2 43 28 38 0 68 2
                                  43 0 0 28 69 2 45 0 0 28 70 3 64 43 0
                                  28 43 71 3 66 45 0 28 45 72 0 73 0 74
                                  2 21 24 0 28 75 2 47 28 6 0 76 1 26 0
                                  23 77 2 79 78 0 28 80 1 43 0 38 81 1
                                  45 0 26 82 0 83 0 84 1 24 23 0 85 2
                                  83 0 24 0 86 2 83 0 0 0 87 1 83 31 0
                                  88 1 83 21 0 89 2 47 31 6 0 91 2 21
                                  31 24 0 92 1 24 0 48 95 1 55 0 47 98
                                  2 24 0 0 0 100 1 21 28 0 109 1 24 110
                                  0 111 1 113 0 112 114 1 110 0 113 115
                                  1 110 0 116 117 2 110 0 0 0 118 2 55
                                  0 6 0 120 1 55 23 0 122 1 55 6 0 123
                                  2 55 0 0 0 124 1 126 0 125 127 1 24 0
                                  0 129 1 55 31 0 132 2 55 31 0 0 135 0
                                  126 0 137 2 126 0 55 0 138 1 140 0 48
                                  141 2 0 31 0 0 1 1 0 45 0 106 2 0 26
                                  24 0 130 2 0 26 24 0 131 1 0 21 0 96
                                  2 0 24 0 28 101 1 0 24 0 102 1 0 0 21
                                  108 1 0 23 0 103 1 0 126 0 128 2 0
                                  126 0 55 139 2 0 140 0 47 142 2 0 55
                                  0 6 121 1 0 55 0 99 2 0 31 24 0 90 1
                                  0 112 0 1 3 0 73 0 28 28 143 1 0 73 0
                                  93 1 0 144 0 1 1 0 21 0 94 2 0 24 0
                                  23 97 1 0 23 0 104 1 0 0 21 107 1 0
                                  21 0 22 1 0 110 0 119 1 0 47 0 105 2
                                  0 31 0 0 136 2 0 31 0 0 134 2 0 31 0
                                  0 133)))))
          '|lookupComplete|)) 
