
(/VERSIONCHECK 2) 

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

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

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

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

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

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

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

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

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

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

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

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

(DEFUN |PERMGRP;reduceGenerators| (|kkk| $)
  (PROG (|orbitLength| |i| |removedGenerator| #1=#:G820 |test| |obs2| |sgs2|
         |pt2| #2=#:G831 |j| |pos| |obs| |pt| #3=#:G830 |nnn| |baseLength|
         #4=#:G829)
    (RETURN
     (SEQ
      (LETT |orbitLength| (|PERMGRP;computeOrbits| |kkk| $)
            . #5=(|PERMGRP;reduceGenerators|))
      (SETELT $ 8 NIL) (SETELT $ 15 NIL)
      (SEQ (LETT |i| 1 . #5#) (LETT #4# (- |kkk| 1) . #5#) G190
           (COND ((QSGREATERP |i| #4#) #6=(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|) . #5#) #7=(GO G190) G191 (EXIT NIL))
      (LETT |removedGenerator| 'NIL . #5#)
      (LETT |baseLength| (SPADCALL (QREFELT $ 9) (QREFELT $ 62)) . #5#)
      (SEQ (LETT |nnn| |kkk| . #5#) (LETT #3# (- |baseLength| 1) . #5#) G190
           (COND ((> |nnn| #3#) #6#))
           (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) . #5#)
            (LETT |obs|
                  (|PERMGRP;orbitWithSvc| (QREFELT $ 8)
                   (SPADCALL (QREFELT $ 9) |pt| (QREFELT $ 30)) $)
                  . #5#)
            (LETT |i| 1 . #5#)
            (EXIT
             (SEQ G190
                  (COND
                   ((NULL
                     (COND
                      ((<
                        (LENGTH (SPADCALL (QREFELT $ 13) |nnn| (QREFELT $ 65)))
                        |i|)
                       'NIL)
                      ('T 'T)))
                    #6#))
                  (SEQ
                   (LETT |pos|
                         (SPADCALL
                          (SPADCALL
                           (SPADCALL (QREFELT $ 13) |nnn| (QREFELT $ 65)) |i|
                           (QREFELT $ 44))
                          (QREFELT $ 8) (QREFELT $ 68))
                         . #5#)
                   (LETT |sgs2| (SPADCALL (QREFELT $ 8) |pos| (QREFELT $ 69))
                         . #5#)
                   (LETT |obs2|
                         (|PERMGRP;orbitWithSvc| |sgs2|
                          (SPADCALL (QREFELT $ 9) |pt| (QREFELT $ 30)) $)
                         . #5#)
                   (EXIT
                    (COND
                     ((EQL (SPADCALL (QCAR |obs2|) (QREFELT $ 62))
                           (SPADCALL |orbitLength| |nnn| (QREFELT $ 30)))
                      (SEQ (LETT |test| 'T . #5#)
                           (SEQ
                            (EXIT
                             (SEQ (LETT |j| (+ |nnn| 1) . #5#)
                                  (LETT #2# (- |baseLength| 1) . #5#) G190
                                  (COND ((> |j| #2#) #6#))
                                  (SEQ
                                   (LETT |pt2| (+ (- |baseLength| |j|) 1)
                                         . #5#)
                                   (LETT |sgs2|
                                         (APPEND |sgs2|
                                                 (SPADCALL (QREFELT $ 13) |j|
                                                           (QREFELT $ 65)))
                                         . #5#)
                                   (LETT |obs2|
                                         (|PERMGRP;orbitWithSvc| |sgs2|
                                          (SPADCALL (QREFELT $ 9) |pt2|
                                                    (QREFELT $ 30))
                                          $)
                                         . #5#)
                                   (EXIT
                                    (COND
                                     ((NULL
                                       (EQL
                                        (SPADCALL (QCAR |obs2|) (QREFELT $ 62))
                                        (SPADCALL |orbitLength| |j|
                                                  (QREFELT $ 30))))
                                      (SEQ (LETT |test| 'NIL . #5#)
                                           (EXIT
                                            (PROGN
                                             (LETT #1# |$NoValue| . #5#)
                                             (GO #1#))))))))
                                  (LETT |j| (+ |j| 1) . #5#) #7# G191
                                  (EXIT NIL)))
                            #1# (EXIT #1#))
                           (EXIT
                            (COND
                             (|test|
                              (SEQ (LETT |removedGenerator| 'T . #5#)
                                   (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) . #5#))))))
                     ('T (LETT |i| (+ |i| 1) . #5#)))))
                  NIL #7# G191 (EXIT NIL))))
           (LETT |nnn| (+ |nnn| 1) . #5#) #7# G191 (EXIT NIL))
      (COND
       (|removedGenerator|
        (LETT |orbitLength| (|PERMGRP;computeOrbits| |kkk| $) . #5#)))
      (EXIT (SPADCALL (QREFELT $ 74))))))) 

(DEFUN |PERMGRP;bsgs| (|group| |maxLoops| |diff| $)
  (PROG (#1=#:G886 |j| |kkk| #2=#:G869 #3=#:G885 |i| |word| |ttt| |word2|
         #4=#:G884 |wd| |noAnswer| |noresult| |z| |ee| #5=#:G846 #6=#:G850
         |entry| |p| |s| |ppp| #7=#:G883 |jjj| |word3| |y1| #8=#:G882 |pt|
         |gporbi| #9=#:G881 #10=#:G880 |newGroup| |k| |words| |pos2| |newEl|
         #11=#:G879 |q| #12=#:G878 |ggg| |gp| #13=#:G877)
    (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 #13# (QREFELT $ 10) . #14=(|PERMGRP;bsgs|))
                     (GO #13#))))))
            (LETT |newGroup| NIL . #14#) (LETT |gp| (QCAR |group|) . #14#)
            (LETT |words| NIL . #14#)
            (SEQ (LETT |ggg| 1 . #14#) (LETT #12# (LENGTH |gp|) . #14#) G190
                 (COND ((QSGREATERP |ggg| #12#) #15=(GO G191)))
                 (SEQ
                  (LETT |q| (SPADCALL (QREFELT $ 11) 0 (QREFELT $ 53)) . #14#)
                  (SEQ (LETT |i| 1 . #14#) (LETT #11# (QREFELT $ 11) . #14#)
                       G190 (COND ((QSGREATERP |i| #11#) #15#))
                       (SEQ
                        (LETT |newEl|
                              (SPADCALL (SPADCALL |gp| |ggg| (QREFELT $ 75))
                                        (SPADCALL (QREFELT $ 18) |i|
                                                  (QREFELT $ 50))
                                        (QREFELT $ 51))
                              . #14#)
                        (LETT |pos2|
                              (SPADCALL |newEl| (QREFELT $ 18) (QREFELT $ 76))
                              . #14#)
                        (EXIT (SPADCALL |q| |i| |pos2| (QREFELT $ 54))))
                       (LETT |i| (QSADD1 |i|) . #14#) #16=(GO G190) G191
                       (EXIT NIL))
                  (LETT |newGroup| (CONS |q| |newGroup|) . #14#)
                  (EXIT
                   (COND
                    ((QREFELT $ 20)
                     (LETT |words|
                           (CONS (SPADCALL |ggg| (QREFELT $ 77)) |words|)
                           . #14#)))))
                 (LETT |ggg| (QSADD1 |ggg|) . #14#) #16# 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
                            $)
                           . #14#)
                     (SETELT $ 20 'T)
                     (EXIT
                      (LETT |maxLoops|
                            (- (SPADCALL (QREFELT $ 9) (QREFELT $ 62)) 1)
                            . #14#))))
               ('T
                (LETT |maxLoops|
                      (- (SPADCALL (QVELT (QCDR |group|) 2) (QREFELT $ 62)) 1)
                      . #14#)))))
            (LETT |k|
                  (|PERMGRP;bsgs1| |newGroup| 1 |words| |maxLoops| |group|
                   |diff| $)
                  . #14#)
            (LETT |kkk| 1 . #14#) (LETT |newGroup| (REVERSE |newGroup|) . #14#)
            (LETT |noAnswer| 'T . #14#)
            (SEQ G190 (COND ((NULL |noAnswer|) #15#))
                 (SEQ (|PERMGRP;reduceGenerators| |kkk| $) (SETELT $ 8 NIL)
                      (SETELT $ 15 NIL)
                      (SEQ (LETT |i| 1 . #14#) (LETT #10# (- |kkk| 1) . #14#)
                           G190 (COND ((QSGREATERP |i| #10#) #15#))
                           (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|) . #14#) #16# G191 (EXIT NIL))
                      (LETT |noresult| 'T . #14#)
                      (SEQ (LETT |i| |kkk| . #14#)
                           (LETT #9# (SPADCALL (QREFELT $ 9) (QREFELT $ 62))
                                 . #14#)
                           G190
                           (COND ((OR (> |i| #9#) (NULL |noresult|)) #15#))
                           (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))
                                  . #14#)
                            (EXIT
                             (SEQ (LETT |pt| NIL . #14#)
                                  (LETT #8# (QCAR |gporbi|) . #14#) G190
                                  (COND
                                   ((OR (ATOM #8#)
                                        (PROGN
                                         (LETT |pt| (CAR #8#) . #14#)
                                         NIL)
                                        (NULL |noresult|))
                                    #15#))
                                  (SEQ
                                   (LETT |ppp|
                                         (|PERMGRP;cosetRep| |pt| |gporbi|
                                          (QREFELT $ 8) $)
                                         . #14#)
                                   (LETT |y1| (|PERMGRP;inv| (QCAR |ppp|) $)
                                         . #14#)
                                   (LETT |word3| (QCDR |ppp|) . #14#)
                                   (EXIT
                                    (SEQ (LETT |jjj| 1 . #14#)
                                         (LETT #7# (LENGTH (QREFELT $ 8))
                                               . #14#)
                                         G190
                                         (COND
                                          ((OR (QSGREATERP |jjj| #7#)
                                               (NULL |noresult|))
                                           #15#))
                                         (SEQ (LETT |word| NIL . #14#)
                                              (LETT |z|
                                                    (|PERMGRP;times|
                                                     (SPADCALL (QREFELT $ 8)
                                                               |jjj|
                                                               (QREFELT $ 44))
                                                     |y1| $)
                                                    . #14#)
                                              (COND
                                               ((QREFELT $ 20)
                                                (LETT |word|
                                                      (APPEND
                                                       (SPADCALL (QREFELT $ 15)
                                                                 |jjj|
                                                                 (QREFELT $
                                                                          46))
                                                       |word|)
                                                      . #14#)))
                                              (LETT |ppp|
                                                    (|PERMGRP;cosetRep|
                                                     (SPADCALL
                                                      (SPADCALL (QREFELT $ 8)
                                                                |jjj|
                                                                (QREFELT $ 44))
                                                      |pt| (QREFELT $ 40))
                                                     |gporbi| (QREFELT $ 8) $)
                                                    . #14#)
                                              (LETT |z|
                                                    (|PERMGRP;times|
                                                     (QCAR |ppp|) |z| $)
                                                    . #14#)
                                              (COND
                                               ((QREFELT $ 20)
                                                (LETT |word|
                                                      (APPEND (QCDR |ppp|)
                                                              |word|)
                                                      . #14#)))
                                              (SETELT $ 17 'NIL)
                                              (SEQ (LETT |j| (- |i| 1) . #14#)
                                                   G190
                                                   (COND
                                                    ((OR (< |j| 1)
                                                         (NULL |noresult|))
                                                     #15#))
                                                   (SEQ
                                                    (LETT |s|
                                                          (QCDR
                                                           (SPADCALL
                                                            (QREFELT $ 12) |j|
                                                            (QREFELT $ 80)))
                                                          . #14#)
                                                    (LETT |p|
                                                          (SPADCALL
                                                           (QCAR
                                                            (SPADCALL
                                                             (QREFELT $ 12) |j|
                                                             (QREFELT $ 80)))
                                                           1 (QREFELT $ 30))
                                                          . #14#)
                                                    (EXIT
                                                     (SEQ
                                                      (EXIT
                                                       (SEQ G190
                                                            (COND
                                                             ((NULL
                                                               (COND
                                                                ((< 0
                                                                    (QREFELT $
                                                                             11))
                                                                 |noresult|)
                                                                ('T 'NIL)))
                                                              #15#))
                                                            (SEQ
                                                             (LETT |entry|
                                                                   (SPADCALL
                                                                    |s|
                                                                    (SPADCALL
                                                                     |z| |p|
                                                                     (QREFELT $
                                                                              40))
                                                                    (QREFELT $
                                                                             42))
                                                                   . #14#)
                                                             (EXIT
                                                              (COND
                                                               ((< |entry| 0)
                                                                (SEQ
                                                                 (COND
                                                                  ((EQL |entry|
                                                                        -1)
                                                                   (PROGN
                                                                    (LETT #6#
                                                                          |$NoValue|
                                                                          . #14#)
                                                                    (GO #6#))))
                                                                 (SETELT $ 16
                                                                         (PROG1
                                                                             (LETT
                                                                              #5#
                                                                              |j|
                                                                              . #14#)
                                                                           (|check-subtype|
                                                                            (>=
                                                                             #5#
                                                                             0)
                                                                            '(|NonNegativeInteger|)
                                                                            #5#)))
                                                                 (EXIT
                                                                  (LETT
                                                                   |noresult|
                                                                   'NIL
                                                                   . #14#))))
                                                               ('T
                                                                (SEQ
                                                                 (LETT |ee|
                                                                       (SPADCALL
                                                                        (QREFELT
                                                                         $ 8)
                                                                        |entry|
                                                                        (QREFELT
                                                                         $ 44))
                                                                       . #14#)
                                                                 (LETT |z|
                                                                       (|PERMGRP;times|
                                                                        |ee|
                                                                        |z| $)
                                                                       . #14#)
                                                                 (EXIT
                                                                  (COND
                                                                   ((QREFELT $
                                                                             20)
                                                                    (LETT
                                                                     |word|
                                                                     (APPEND
                                                                      (SPADCALL
                                                                       (QREFELT
                                                                        $ 15)
                                                                       |entry|
                                                                       (QREFELT
                                                                        $ 46))
                                                                      |word|)
                                                                     . #14#)))))))))
                                                            NIL #16# G191
                                                            (EXIT NIL)))
                                                      #6# (EXIT #6#))))
                                                   (LETT |j| (+ |j| -1) . #14#)
                                                   #16# G191 (EXIT NIL))
                                              (EXIT
                                               (COND
                                                (|noresult|
                                                 (SEQ (SETELT $ 16 1)
                                                      (SETELT $ 17 'T)
                                                      (EXIT
                                                       (LETT |noresult|
                                                             (|PERMGRP;testIdentity|
                                                              |z| $)
                                                             . #14#)))))))
                                         (LETT |jjj| (QSADD1 |jjj|) . #14#)
                                         #16# G191 (EXIT NIL))))
                                  (LETT #8# (CDR #8#) . #14#) #16# G191
                                  (EXIT NIL))))
                           (LETT |i| (+ |i| 1) . #14#) #16# G191 (EXIT NIL))
                      (LETT |noAnswer|
                            (COND ((|PERMGRP;testIdentity| |z| $) 'NIL)
                                  ('T 'T))
                            . #14#)
                      (EXIT
                       (COND
                        (|noAnswer|
                         (SEQ (LETT |word2| NIL . #14#)
                              (COND
                               ((QREFELT $ 20)
                                (SEQ
                                 (SEQ (LETT |wd| NIL . #14#)
                                      (LETT #4# |word3| . #14#) G190
                                      (COND
                                       ((OR (ATOM #4#)
                                            (PROGN
                                             (LETT |wd| (CAR #4#) . #14#)
                                             NIL))
                                        #15#))
                                      (SEQ
                                       (LETT |ttt|
                                             (SPADCALL |newGroup| |wd|
                                                       (QREFELT $ 44))
                                             . #14#)
                                       (EXIT
                                        (SEQ G190
                                             (COND
                                              ((NULL
                                                (COND
                                                 ((|PERMGRP;testIdentity| |ttt|
                                                   $)
                                                  'NIL)
                                                 ('T 'T)))
                                               #15#))
                                             (SEQ
                                              (LETT |word2| (CONS |wd| |word2|)
                                                    . #14#)
                                              (EXIT
                                               (LETT |ttt|
                                                     (|PERMGRP;times| |ttt|
                                                      (SPADCALL |newGroup| |wd|
                                                                (QREFELT $ 44))
                                                      $)
                                                     . #14#)))
                                             NIL #16# G191 (EXIT NIL))))
                                      (LETT #4# (CDR #4#) . #14#) #16# G191
                                      (EXIT NIL))
                                 (LETT |word| (APPEND |word| |word2|) . #14#)
                                 (EXIT
                                  (LETT |word|
                                        (|PERMGRP;shortenWord| |word| |group|
                                         $)
                                        . #14#)))))
                              (COND
                               ((QREFELT $ 17)
                                (SEQ
                                 (SEQ
                                  (EXIT
                                   (SEQ (LETT |i| 1 . #14#)
                                        (LETT #3# (QREFELT $ 11) . #14#) G190
                                        (COND ((QSGREATERP |i| #3#) #15#))
                                        (SEQ
                                         (EXIT
                                          (COND
                                           ((NULL
                                             (EQL
                                              (SPADCALL |z| |i| (QREFELT $ 40))
                                              |i|))
                                            (SEQ
                                             (SETELT $ 9
                                                     (APPEND (QREFELT $ 9)
                                                             (LIST |i|)))
                                             (EXIT
                                              (PROGN
                                               (LETT #2# |$NoValue| . #14#)
                                               (GO #2#))))))))
                                        (LETT |i| (QSADD1 |i|) . #14#) #16#
                                        G191 (EXIT NIL)))
                                  #2# (EXIT #2#))
                                 (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) . #14#)))))))
                 NIL #16# G191 (EXIT NIL))
            (SETELT $ 10 1)
            (SEQ (LETT |j| 1 . #14#)
                 (LETT #1# (SPADCALL (QREFELT $ 9) (QREFELT $ 62)) . #14#) G190
                 (COND ((QSGREATERP |j| #1#) #15#))
                 (SEQ
                  (EXIT
                   (SETELT $ 10
                           (* (QREFELT $ 10)
                              (SPADCALL
                               (QCAR
                                (SPADCALL (QREFELT $ 12) |j| (QREFELT $ 80)))
                               (QREFELT $ 62))))))
                 (LETT |j| (QSADD1 |j|) . #14#) #16# G191 (EXIT NIL))
            (EXIT (QREFELT $ 10))))
      #13# (EXIT #13#))))) 

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

(DEFUN |PERMGRP;knownGroup?| (|gp| $)
  (PROG (|result|)
    (RETURN
     (SEQ (LETT |result| (QCDR |gp|) . #1=(|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)
                       . #1#)
                 (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 (#1=#:G901 #2=#:G904 #3=#:G905 |el| |gpset2| |gpset1|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |gpset1| (|PERMGRP;initialize| |gp1| $)
              . #4=(|PERMGRP;subgroup|))
        (LETT |gpset2| (|PERMGRP;initialize| |gp2| $) . #4#)
        (EXIT
         (COND
          ((SPADCALL (SPADCALL |gpset1| |gpset2| (QREFELT $ 87))
                     (QREFELT $ 88))
           'T)
          ('T
           (SEQ
            (SEQ
             (EXIT
              (SEQ (LETT |el| NIL . #4#)
                   (LETT #3# (SPADCALL |gpset1| (QREFELT $ 89)) . #4#) G190
                   (COND
                    ((OR (ATOM #3#) (PROGN (LETT |el| (CAR #3#) . #4#) NIL))
                     (GO G191)))
                   (SEQ
                    (EXIT
                     (COND
                      ((NULL (SPADCALL |el| |gp2| (QREFELT $ 90)))
                       (PROGN
                        (LETT #1# (PROGN (LETT #2# 'NIL . #4#) (GO #2#)) . #4#)
                        (GO #1#))))))
                   (LETT #3# (CDR #3#) . #4#) (GO G190) G191 (EXIT NIL)))
             #1# (EXIT #1#))
            (EXIT 'T)))))))
      #2# (EXIT #2#))))) 

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

(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 (|strongGens| |pairs| #1=#:G935 |j| #2=#:G934 |i|)
    (RETURN
     (SEQ (|PERMGRP;knownGroup?| |group| $)
          (SETELT $ 11 (LENGTH (QREFELT $ 18)))
          (LETT |strongGens| NIL . #3=(|PERMGRP;strongGenerators;$L;21|))
          (SEQ (LETT |i| NIL . #3#) (LETT #2# (QREFELT $ 8) . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |i| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ (LETT |pairs| NIL . #3#)
                    (SEQ (LETT |j| 1 . #3#) (LETT #1# (QREFELT $ 11) . #3#)
                         G190 (COND ((QSGREATERP |j| #1#) #4#))
                         (SEQ
                          (EXIT
                           (LETT |pairs|
                                 (CONS
                                  (LIST
                                   (SPADCALL (QREFELT $ 18) |j| (QREFELT $ 50))
                                   (SPADCALL (QREFELT $ 18)
                                             (SPADCALL |i| |j| (QREFELT $ 40))
                                             (QREFELT $ 50)))
                                  |pairs|)
                                 . #3#)))
                         (LETT |j| (QSADD1 |j|) . #3#) #5=(GO G190) G191
                         (EXIT NIL))
                    (EXIT
                     (LETT |strongGens|
                           (CONS (SPADCALL |pairs| (QREFELT $ 95))
                                 |strongGens|)
                           . #3#)))
               (LETT #2# (CDR #2#) . #3#) #5# 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 (|numberOfLoops| |randomElement| |randomInteger| |numberOfGenerators|
         |gp|)
    (RETURN
     (SEQ
      (COND ((< |maximalNumberOfFactors| 1) (|spadConstant| $ 35))
            ('T
             (SEQ (LETT |gp| (QCAR |group|) . #1=(|PERMGRP;random;$IP;24|))
                  (LETT |numberOfGenerators| (LENGTH |gp|) . #1#)
                  (LETT |randomInteger| (+ 1 (RANDOM |numberOfGenerators|))
                        . #1#)
                  (LETT |randomElement|
                        (SPADCALL |gp| |randomInteger| (QREFELT $ 75)) . #1#)
                  (LETT |numberOfLoops| (+ 1 (RANDOM |maximalNumberOfFactors|))
                        . #1#)
                  (SEQ G190 (COND ((NULL (< 0 |numberOfLoops|)) (GO G191)))
                       (SEQ
                        (LETT |randomInteger|
                              (+ 1 (RANDOM |numberOfGenerators|)) . #1#)
                        (LETT |randomElement|
                              (SPADCALL
                               (SPADCALL |gp| |randomInteger| (QREFELT $ 75))
                               |randomElement| (QREFELT $ 100))
                              . #1#)
                        (EXIT
                         (LETT |numberOfLoops| (- |numberOfLoops| 1) . #1#)))
                       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 (|groupBase| #1=#:G951 |i|)
    (RETURN
     (SEQ (|PERMGRP;knownGroup?| |group| $)
          (LETT |groupBase| NIL . #2=(|PERMGRP;base;$L;28|))
          (SEQ (LETT |i| NIL . #2#) (LETT #1# (QREFELT $ 9) . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (EXIT
                 (LETT |groupBase|
                       (CONS (SPADCALL (QREFELT $ 18) |i| (QREFELT $ 50))
                             |groupBase|)
                       . #2#)))
               (LETT #1# (CDR #1#) . #2#) (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 (|group| |result|)
    (RETURN
     (SEQ
      (LETT |result| (VECTOR 0 NIL NIL NIL NIL NIL)
            . #1=(|PERMGRP;coerce;L$;30|))
      (EXIT (LETT |group| (CONS |gp| |result|) . #1#)))))) 

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

(DEFUN |PERMGRP;coerce;$Of;32| (|group| $)
  (PROG (|outList| |i| |gp|)
    (RETURN
     (SEQ (LETT |outList| NIL . #1=(|PERMGRP;coerce;$Of;32|))
          (LETT |gp| (QCAR |group|) . #1#)
          (SEQ (LETT |i| (SPADCALL |gp| (QREFELT $ 109)) . #1#) G190
               (COND ((< |i| 1) (GO G191)))
               (SEQ
                (EXIT
                 (LETT |outList|
                       (CONS
                        (SPADCALL (SPADCALL |gp| |i| (QREFELT $ 75))
                                  (QREFELT $ 111))
                        |outList|)
                       . #1#)))
               (LETT |i| (+ |i| -1) . #1#) (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 (#1=#:G968 |i| |outSet| |outList| |elList|)
    (RETURN
     (SEQ (LETT |elList| (LIST |el|) . #2=(|PERMGRP;orbit;$SS;33|))
          (LETT |outList| (|PERMGRP;orbitInternal| |gp| |elList| $) . #2#)
          (LETT |outSet| (SPADCALL (QREFELT $ 56)) . #2#)
          (SEQ (LETT |i| 1 . #2#) (LETT #1# (LENGTH |outList|) . #2#) G190
               (COND ((QSGREATERP |i| #1#) (GO G191)))
               (SEQ
                (EXIT
                 (SPADCALL
                  (SPADCALL (SPADCALL |outList| |i| (QREFELT $ 49)) 1
                            (QREFELT $ 50))
                  |outSet| (QREFELT $ 120))))
               (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT |outSet|))))) 

(DEFUN |PERMGRP;orbits;$S;34| (|gp| $)
  (PROG (|spp| |orbits| |orbitSet| |el|)
    (RETURN
     (SEQ
      (LETT |spp| (SPADCALL |gp| (QREFELT $ 99)) . #1=(|PERMGRP;orbits;$S;34|))
      (LETT |orbits| NIL . #1#)
      (SEQ G190
           (COND ((NULL (< 0 (SPADCALL |spp| (QREFELT $ 122)))) (GO G191)))
           (SEQ (LETT |el| (SPADCALL |spp| (QREFELT $ 123)) . #1#)
                (LETT |orbitSet| (SPADCALL |gp| |el| (QREFELT $ 121)) . #1#)
                (LETT |orbits| (CONS |orbitSet| |orbits|) . #1#)
                (EXIT
                 (LETT |spp| (SPADCALL |spp| |orbitSet| (QREFELT $ 124))
                       . #1#)))
           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 (|outlist| #1=#:G982 |wd| |lll|)
    (RETURN
     (SEQ
      (LETT |lll| (SPADCALL |p| |gp| (QREFELT $ 130))
            . #2=(|PERMGRP;wordInGenerators;P$L;37|))
      (LETT |outlist| NIL . #2#)
      (SEQ (LETT |wd| NIL . #2#) (LETT #1# |lll| . #2#) G190
           (COND
            ((OR (ATOM #1#) (PROGN (LETT |wd| (CAR #1#) . #2#) NIL))
             (GO G191)))
           (SEQ
            (EXIT
             (LETT |outlist|
                   (APPEND |outlist|
                           (SPADCALL (QREFELT $ 15) |wd| (QREFELT $ 46)))
                   . #2#)))
           (LETT #1# (CDR #1#) . #2#) (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 (#1=#:G997)
    (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 #1# 'NIL . #2=(|PERMGRP;=;2$B;40|)) (GO #1#))))))
           ((NULL (|PERMGRP;subgroup| |gp1| |gp2| $))
            (EXIT (PROGN (LETT #1# 'NIL . #2#) (GO #1#)))))
          (EXIT
           (COND
            ((EQL (SPADCALL |gp1| (QREFELT $ 103))
                  (SPADCALL |gp2| (QREFELT $ 103)))
             'T)
            ('T 'NIL)))))))
      #1# (EXIT #1#))))) 

(DEFUN |PERMGRP;orbit;$SS;41| (|gp| |startSet| $)
  (PROG (|newSet| #1=#:G1002 |i| |outSet| |outList| |startList|)
    (RETURN
     (SEQ
      (LETT |startList| (SPADCALL |startSet| (QREFELT $ 59))
            . #2=(|PERMGRP;orbit;$SS;41|))
      (LETT |outList| (|PERMGRP;orbitInternal| |gp| |startList| $) . #2#)
      (LETT |outSet| (SPADCALL (QREFELT $ 137)) . #2#)
      (SEQ (LETT |i| 1 . #2#) (LETT #1# (LENGTH |outList|) . #2#) G190
           (COND ((QSGREATERP |i| #1#) (GO G191)))
           (SEQ
            (LETT |newSet|
                  (SPADCALL (SPADCALL |outList| |i| (QREFELT $ 49))
                            (QREFELT $ 98))
                  . #2#)
            (EXIT (SPADCALL |newSet| |outSet| (QREFELT $ 138))))
           (LETT |i| (QSADD1 |i|) . #2#) (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| (#1=#:G1008)
  (PROG ()
    (RETURN
     (PROG (#2=#:G1009)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|PermutationGroup|)
                                           '|domainEqualList|)
                . #3=(|PermutationGroup|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|PermutationGroup;| #1#) (LETT #2# T . #3#))
            (COND
             ((NOT #2#) (HREM |$ConstructorCache| '|PermutationGroup|))))))))))) 

(DEFUN |PermutationGroup;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PermutationGroup|))
      (LETT |dv$| (LIST '|PermutationGroup| DV$1) . #1#)
      (LETT $ (GETREFV 145) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|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|)) 
