
(/VERSIONCHECK 2) 

(DEFUN |CYCLES;trm| (|pt| $)
  (SPADCALL
      (SPADCALL (SPADCALL (SPADCALL |pt| (QREFELT $ 8)) (QREFELT $ 10))
          (QREFELT $ 11))
      |pt| (QREFELT $ 13))) 

(DEFUN |CYCLES;list| (|st| $)
  (SPADCALL (SPADCALL |st| (QREFELT $ 15)) (QREFELT $ 17))) 

(DEFUN |CYCLES;complete;ISp;3| (|i| $)
  (PROG (|pt| #0=#:G1833 #1=#:G1831 #2=#:G1829 #3=#:G1830)
    (RETURN
      (SEQ (COND
             ((EQL |i| 0) (|spadConstant| $ 19))
             ((< |i| 0) (|spadConstant| $ 18))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|CYCLES;complete;ISp;3|))
                (SEQ (LETT |pt| NIL . #5#)
                     (LETT #0#
                           (|CYCLES;list| (SPADCALL |i| (QREFELT $ 21))
                               $) . #5#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |pt| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (|CYCLES;trm|
                                         (SPADCALL |pt| (QREFELT $ 23))
                                         $) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 24)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 18)))))))))) 

(DEFUN |CYCLES;even?| (|li| $)
  (PROG (#0=#:G1837 |i| #1=#:G1838)
    (RETURN
      (SEQ (SPADCALL
               (LENGTH (PROGN
                         (LETT #0# NIL . #2=(|CYCLES;even?|))
                         (SEQ (LETT |i| NIL . #2#)
                              (LETT #1# |li| . #2#) G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |i| (CAR #1#) . #2#)
                                       NIL))
                                 (GO G191)))
                              (SEQ (EXIT
                                    (COND
                                      ((SPADCALL |i| (QREFELT $ 27))
                                       (LETT #0# (CONS |i| #0#) . #2#)))))
                              (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                              (EXIT (NREVERSE0 #0#)))))
               (QREFELT $ 27)))))) 

(DEFUN |CYCLES;alternating;ISp;5| (|i| $)
  (PROG (|li| #0=#:G1843 #1=#:G1841 #2=#:G1839 #3=#:G1840)
    (RETURN
      (SEQ (SPADCALL 2
               (PROGN
                 (LETT #3# NIL . #4=(|CYCLES;alternating;ISp;5|))
                 (SEQ (LETT |li| NIL . #4#)
                      (LETT #0#
                            (|CYCLES;list|
                                (SPADCALL |i| (QREFELT $ 21)) $) . #4#)
                      G190
                      (COND
                        ((OR (ATOM #0#)
                             (PROGN (LETT |li| (CAR #0#) . #4#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (COND
                                   ((|CYCLES;even?| |li| $)
                                    (PROGN
                                      (LETT #1#
                                       (|CYCLES;trm|
                                        (SPADCALL |li| (QREFELT $ 23))
                                        $) . #4#)
                                      (COND
                                        (#3#
                                         (LETT #2#
                                          (SPADCALL #2# #1#
                                           (QREFELT $ 24)) . #4#))
                                        ('T
                                         (PROGN
                                           (LETT #2# #1# . #4#)
                                           (LETT #3# 'T . #4#)))))))))
                      (LETT #0# (CDR #0#) . #4#) (GO G190) G191
                      (EXIT NIL))
                 (COND (#3# #2#) ('T (|spadConstant| $ 18))))
               (QREFELT $ 29)))))) 

(DEFUN |CYCLES;elementary;ISp;6| (|i| $)
  (PROG (|pt| #0=#:G1849 |spol| #1=#:G1846 #2=#:G1844 #3=#:G1845)
    (RETURN
      (SEQ (COND
             ((EQL |i| 0) (|spadConstant| $ 19))
             ((< |i| 0) (|spadConstant| $ 18))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|CYCLES;elementary;ISp;6|))
                (SEQ (LETT |pt| NIL . #5#)
                     (LETT #0#
                           (|CYCLES;list| (SPADCALL |i| (QREFELT $ 21))
                               $) . #5#)
                     G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |pt| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SEQ
                                         (LETT |spol|
                                          (|CYCLES;trm|
                                           (SPADCALL |pt|
                                            (QREFELT $ 23))
                                           $) . #5#)
                                         (EXIT
                                          (COND
                                            ((|CYCLES;even?| |pt| $)
                                             |spol|)
                                            ('T
                                             (SPADCALL |spol|
                                              (QREFELT $ 31)))))) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 24)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 18)))))))))) 

(DEFUN |CYCLES;divisors| (|n| $)
  (PROG (|b| |a| #0=#:G1860 #1=#:G1861 |j| #2=#:G1862 #3=#:G1855
             #4=#:G1853 #5=#:G1854 |c|)
    (RETURN
      (SEQ (LETT |b|
                 (SPADCALL (SPADCALL |n| (QREFELT $ 34))
                     (QREFELT $ 37))
                 . #6=(|CYCLES;divisors|))
           (LETT |c|
                 (CONS 1
                       (PROGN
                         (LETT #5# NIL . #6#)
                         (SEQ (LETT |a| NIL . #6#) (LETT #0# |b| . #6#)
                              G190
                              (COND
                                ((OR (ATOM #0#)
                                     (PROGN
                                       (LETT |a| (CAR #0#) . #6#)
                                       NIL))
                                 #7=(GO G191)))
                              (SEQ (EXIT
                                    (PROGN
                                      (LETT #3#
                                       (PROGN
                                         (LETT #1# NIL . #6#)
                                         (SEQ (LETT |j| 1 . #6#)
                                          (LETT #2# (QCDR |a|) . #6#)
                                          G190
                                          (COND
                                            ((QSGREATERP |j| #2#) #7#))
                                          (SEQ
                                           (EXIT
                                            (LETT #1#
                                             (CONS
                                              (EXPT (QCAR |a|) |j|)
                                              #1#) . #6#)))
                                          (LETT |j| (QSADD1 |j|) . #6#)
                                          #8=(GO G190) G191
                                          (EXIT (NREVERSE0 #1#)))) . #6#)
                                      (COND
                                        (#5#
                                         (LETT #4#
                                          (APPEND #4# #3#) . #6#))
                                        ('T
                                         (PROGN
                                           (LETT #4# #3# . #6#)
                                           (LETT #5# 'T . #6#)))))))
                              (LETT #0# (CDR #0#) . #6#) #8# G191
                              (EXIT NIL))
                         (COND (#5# #4#) ('T NIL)))) . #6#)
           (EXIT (COND ((EQL (LENGTH |b|) 1) |c|) ('T (CONS |n| |c|)))))))) 

(DEFUN |CYCLES;ss| (|n| |m| $)
  (PROG (#0=#:G1866 |j| |li|)
    (RETURN
      (SEQ (LETT |li|
                 (PROGN
                   (LETT #0# NIL . #1=(|CYCLES;ss|))
                   (SEQ (LETT |j| 1 . #1#) G190
                        (COND ((QSGREATERP |j| |m|) (GO G191)))
                        (SEQ (EXIT (LETT #0# (CONS |n| #0#) . #1#)))
                        (LETT |j| (QSADD1 |j|) . #1#) (GO G190) G191
                        (EXIT (NREVERSE0 #0#)))) . #1#)
           (EXIT (SPADCALL (|spadConstant| $ 39)
                     (SPADCALL |li| (QREFELT $ 23)) (QREFELT $ 13))))))) 

(DEFUN |CYCLES;powerSum;ISp;9| (|n| $) (|CYCLES;ss| |n| 1 $)) 

(DEFUN |CYCLES;cyclic;ISp;10| (|n| $)
  (PROG (|i| #0=#:G1872 #1=#:G1870 #2=#:G1868 #3=#:G1869)
    (RETURN
      (SEQ (COND
             ((EQL |n| 1) (SPADCALL 1 (QREFELT $ 40)))
             (#4='T
              (PROGN
                (LETT #3# NIL . #5=(|CYCLES;cyclic;ISp;10|))
                (SEQ (LETT |i| NIL . #5#)
                     (LETT #0# (|CYCLES;divisors| |n| $) . #5#) G190
                     (COND
                       ((OR (ATOM #0#)
                            (PROGN (LETT |i| (CAR #0#) . #5#) NIL))
                        (GO G191)))
                     (SEQ (EXIT (PROGN
                                  (LETT #1#
                                        (SPADCALL
                                         (SPADCALL
                                          (SPADCALL |i| (QREFELT $ 42))
                                          |n| (QREFELT $ 43))
                                         (|CYCLES;ss| |i|
                                          (SPADCALL
                                           (SPADCALL |n| |i|
                                            (QREFELT $ 43))
                                           (QREFELT $ 44))
                                          $)
                                         (QREFELT $ 45)) . #5#)
                                  (COND
                                    (#3#
                                     (LETT #2#
                                      (SPADCALL #2# #1# (QREFELT $ 24)) . #5#))
                                    ('T
                                     (PROGN
                                       (LETT #2# #1# . #5#)
                                       (LETT #3# 'T . #5#)))))))
                     (LETT #0# (CDR #0#) . #5#) (GO G190) G191
                     (EXIT NIL))
                (COND (#3# #2#) (#4# (|spadConstant| $ 18)))))))))) 

(DEFUN |CYCLES;dihedral;ISp;11| (|n| $)
  (PROG (|k|)
    (RETURN
      (SEQ (LETT |k| (QUOTIENT2 |n| 2) |CYCLES;dihedral;ISp;11|)
           (EXIT (COND
                   ((ODDP |n|)
                    (SPADCALL
                        (SPADCALL (SPADCALL 1 2 (QREFELT $ 43))
                            (SPADCALL |n| (QREFELT $ 46))
                            (QREFELT $ 45))
                        (SPADCALL
                            (SPADCALL (SPADCALL 1 2 (QREFELT $ 43))
                                (|CYCLES;ss| 2 |k| $) (QREFELT $ 45))
                            (SPADCALL 1 (QREFELT $ 40)) (QREFELT $ 47))
                        (QREFELT $ 24)))
                   ('T
                    (SPADCALL
                        (SPADCALL
                            (SPADCALL (SPADCALL 1 2 (QREFELT $ 43))
                                (SPADCALL |n| (QREFELT $ 46))
                                (QREFELT $ 45))
                            (SPADCALL (SPADCALL 1 4 (QREFELT $ 43))
                                (|CYCLES;ss| 2 |k| $) (QREFELT $ 45))
                            (QREFELT $ 24))
                        (SPADCALL
                            (SPADCALL (SPADCALL 1 4 (QREFELT $ 43))
                                (|CYCLES;ss| 2 (- |k| 1) $)
                                (QREFELT $ 45))
                            (|CYCLES;ss| 1 2 $) (QREFELT $ 47))
                        (QREFELT $ 24))))))))) 

(DEFUN |CYCLES;trm2| (|li| $)
  (PROG (|lli| |xx| |ll| #0=#:G1882 |ll0| |ll1| |k| |c| |r| #1=#:G1883
               |r0| |r1| |prod2| |prod|)
    (RETURN
      (SEQ (LETT |lli| (SPADCALL |li| (QREFELT $ 49))
                 . #2=(|CYCLES;trm2|))
           (LETT |xx|
                 (SPADCALL 1
                     (SPADCALL (SPADCALL |li| (QREFELT $ 23))
                         (QREFELT $ 8))
                     (QREFELT $ 43)) . #2#)
           (LETT |prod| (|spadConstant| $ 19) . #2#)
           (SEQ (LETT |ll| NIL . #2#) (LETT #0# |lli| . #2#) G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |ll| (CAR #0#) . #2#) NIL))
                   #3=(GO G191)))
                (SEQ (LETT |ll0| (|SPADfirst| |ll|) . #2#)
                     (LETT |ll1| (SPADCALL |ll| (QREFELT $ 50)) . #2#)
                     (LETT |k| (QUOTIENT2 |ll0| 2) . #2#)
                     (LETT |c|
                           (COND
                             ((ODDP |ll0|)
                              (|CYCLES;ss| |ll0| (* |ll1| |k|) $))
                             ('T
                              (SPADCALL (|CYCLES;ss| |k| |ll1| $)
                                  (|CYCLES;ss| |ll0|
                                      (* |ll1| (- |k| 1)) $)
                                  (QREFELT $ 47)))) . #2#)
                     (LETT |c|
                           (SPADCALL |c|
                               (|CYCLES;ss| |ll0|
                                   (* |ll0|
                                    (QUOTIENT2 (* |ll1| (- |ll1| 1)) 2))
                                   $)
                               (QREFELT $ 47)) . #2#)
                     (LETT |prod2| (|spadConstant| $ 19) . #2#)
                     (SEQ (LETT |r| NIL . #2#) (LETT #1# |lli| . #2#)
                          G190
                          (COND
                            ((OR (ATOM #1#)
                                 (PROGN
                                   (LETT |r| (CAR #1#) . #2#)
                                   NIL))
                             #3#))
                          (SEQ (EXIT (COND
                                       ((< (|SPADfirst| |r|) |ll0|)
                                        (SEQ
                                         (LETT |r0|
                                          (|SPADfirst| |r|) . #2#)
                                         (LETT |r1|
                                          (SPADCALL |r| (QREFELT $ 50)) . #2#)
                                         (EXIT
                                          (LETT |prod2|
                                           (SPADCALL
                                            (|CYCLES;ss|
                                             (SPADCALL |r0| |ll0|
                                              (QREFELT $ 51))
                                             (*
                                              (* (GCD |r0| |ll0|) |r1|)
                                              |ll1|)
                                             $)
                                            |prod2| (QREFELT $ 47)) . #2#)))))))
                          (LETT #1# (CDR #1#) . #2#) #4=(GO G190) G191
                          (EXIT NIL))
                     (EXIT (LETT |prod|
                                 (SPADCALL
                                     (SPADCALL |c| |prod2|
                                      (QREFELT $ 47))
                                     |prod| (QREFELT $ 47)) . #2#)))
                (LETT #0# (CDR #0#) . #2#) #4# G191 (EXIT NIL))
           (EXIT (SPADCALL |xx| |prod| (QREFELT $ 45))))))) 

(DEFUN |CYCLES;graphs;ISp;13| (|n| $)
  (PROG (|li| #0=#:G1888 #1=#:G1886 #2=#:G1884 #3=#:G1885)
    (RETURN
      (SEQ (PROGN
             (LETT #3# NIL . #4=(|CYCLES;graphs;ISp;13|))
             (SEQ (LETT |li| NIL . #4#)
                  (LETT #0#
                        (|CYCLES;list| (SPADCALL |n| (QREFELT $ 21)) $) . #4#)
                  G190
                  (COND
                    ((OR (ATOM #0#)
                         (PROGN (LETT |li| (CAR #0#) . #4#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #1# (|CYCLES;trm2| |li| $) . #4#)
                               (COND
                                 (#3# (LETT #2#
                                       (SPADCALL #2# #1#
                                        (QREFELT $ 24)) . #4#))
                                 ('T
                                  (PROGN
                                    (LETT #2# #1# . #4#)
                                    (LETT #3# 'T . #4#)))))))
                  (LETT #0# (CDR #0#) . #4#) (GO G190) G191 (EXIT NIL))
             (COND (#3# #2#) ('T (|spadConstant| $ 18)))))))) 

(DEFUN |CYCLES;cupp| (|pt| |spol| $)
  (PROG (|dg|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |spol| (QREFELT $ 53)) (|spadConstant| $ 18))
             ('T
              (SEQ (LETT |dg| (SPADCALL |spol| (QREFELT $ 54))
                         |CYCLES;cupp|)
                   (EXIT (COND
                           ((SPADCALL |dg| |pt| (QREFELT $ 55))
                            (|spadConstant| $ 18))
                           ((SPADCALL |dg| |pt| (QREFELT $ 56))
                            (SPADCALL (SPADCALL |pt| (QREFELT $ 8))
                                (SPADCALL
                                    (SPADCALL |spol| (QREFELT $ 57))
                                    |dg| (QREFELT $ 13))
                                (QREFELT $ 58)))
                           ('T
                            (|CYCLES;cupp| |pt|
                                (SPADCALL |spol| (QREFELT $ 59)) $))))))))))) 

(DEFUN |CYCLES;cup;3Sp;15| (|spol1| |spol2| $)
  (PROG (|p|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |spol1| (QREFELT $ 53)) (|spadConstant| $ 18))
             ('T
              (SEQ (LETT |p|
                         (SPADCALL (SPADCALL |spol1| (QREFELT $ 57))
                             (|CYCLES;cupp|
                                 (SPADCALL |spol1| (QREFELT $ 54))
                                 |spol2| $)
                             (QREFELT $ 45))
                         |CYCLES;cup;3Sp;15|)
                   (EXIT (SPADCALL |p|
                             (SPADCALL
                                 (SPADCALL |spol1| (QREFELT $ 59))
                                 |spol2| (QREFELT $ 60))
                             (QREFELT $ 24)))))))))) 

(DEFUN |CYCLES;eval;SpF;16| (|spol| $)
  (COND
    ((SPADCALL |spol| (QREFELT $ 53)) (|spadConstant| $ 61))
    ('T
     (SPADCALL (SPADCALL |spol| (QREFELT $ 57))
         (SPADCALL (SPADCALL |spol| (QREFELT $ 59)) (QREFELT $ 62))
         (QREFELT $ 63))))) 

(DEFUN |CYCLES;cap;2SpF;17| (|spol1| |spol2| $)
  (SPADCALL (SPADCALL |spol1| |spol2| (QREFELT $ 60)) (QREFELT $ 62))) 

(DEFUN |CYCLES;mtpol| (|n| |spol| $)
  (PROG (#0=#:G1903 |k| #1=#:G1904 |deg|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |spol| (QREFELT $ 53)) (|spadConstant| $ 18))
             ('T
              (SEQ (LETT |deg|
                         (SPADCALL
                             (PROGN
                               (LETT #0# NIL . #2=(|CYCLES;mtpol|))
                               (SEQ (LETT |k| NIL . #2#)
                                    (LETT #1#
                                     (SPADCALL
                                      (SPADCALL |spol| (QREFELT $ 54))
                                      (QREFELT $ 65)) . #2#)
                                    G190
                                    (COND
                                      ((OR (ATOM #1#)
                                        (PROGN
                                          (LETT |k| (CAR #1#) . #2#)
                                          NIL))
                                       (GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS (* |n| |k|) #0#) . #2#)))
                                    (LETT #1# (CDR #1#) . #2#)
                                    (GO G190) G191
                                    (EXIT (NREVERSE0 #0#))))
                             (QREFELT $ 23)) . #2#)
                   (EXIT (SPADCALL
                             (SPADCALL (SPADCALL |spol| (QREFELT $ 57))
                                 |deg| (QREFELT $ 13))
                             (|CYCLES;mtpol| |n|
                                 (SPADCALL |spol| (QREFELT $ 59)) $)
                             (QREFELT $ 24)))))))))) 

(DEFUN |CYCLES;evspol| (|fn2| |spol| $)
  (PROG (|lc| |i| #0=#:G1911 #1=#:G1907 #2=#:G1905 #3=#:G1906 |prod|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |spol| (QREFELT $ 53)) (|spadConstant| $ 18))
             ('T
              (SEQ (LETT |lc| (SPADCALL |spol| (QREFELT $ 57))
                         . #4=(|CYCLES;evspol|))
                   (LETT |prod|
                         (PROGN
                           (LETT #3# NIL . #4#)
                           (SEQ (LETT |i| NIL . #4#)
                                (LETT #0#
                                      (SPADCALL
                                       (SPADCALL |spol| (QREFELT $ 54))
                                       (QREFELT $ 65)) . #4#)
                                G190
                                (COND
                                  ((OR (ATOM #0#)
                                    (PROGN
                                      (LETT |i| (CAR #0#) . #4#)
                                      NIL))
                                   (GO G191)))
                                (SEQ (EXIT
                                      (PROGN
                                        (LETT #1#
                                         (SPADCALL |i| |fn2|) . #4#)
                                        (COND
                                          (#3#
                                           (LETT #2#
                                            (SPADCALL #2# #1#
                                             (QREFELT $ 47)) . #4#))
                                          ('T
                                           (PROGN
                                             (LETT #2# #1# . #4#)
                                             (LETT #3# 'T . #4#)))))))
                                (LETT #0# (CDR #0#) . #4#) (GO G190)
                                G191 (EXIT NIL))
                           (COND (#3# #2#) ('T (|spadConstant| $ 19)))) . #4#)
                   (EXIT (SPADCALL
                             (SPADCALL |lc| |prod| (QREFELT $ 45))
                             (|CYCLES;evspol| |fn2|
                                 (SPADCALL |spol| (QREFELT $ 59)) $)
                             (QREFELT $ 24)))))))))) 

(DEFUN |CYCLES;wreath;3Sp;20| (|spol1| |spol2| $)
  (|CYCLES;evspol| (CONS #'|CYCLES;wreath;3Sp;20!0| (VECTOR $ |spol2|))
      |spol1| $)) 

(DEFUN |CYCLES;wreath;3Sp;20!0| (|#1| $$)
  (|CYCLES;mtpol| |#1| (QREFELT $$ 1) (QREFELT $$ 0))) 

(DEFUN |CYCLES;hh| (|n| $)
  (COND
    ((EQL |n| 0) (|spadConstant| $ 19))
    ((< |n| 0) (|spadConstant| $ 18))
    ('T (SPADCALL |n| (QREFELT $ 25))))) 

(DEFUN |CYCLES;SFunction;LSp;22| (|li| $)
  (PROG (#0=#:G1918 |i| #1=#:G1919 #2=#:G1920 |j| #3=#:G1922 |k|
            #4=#:G1921 |a|)
    (RETURN
      (SEQ (LETT |a|
                 (SPADCALL
                     (PROGN
                       (LETT #0# NIL . #5=(|CYCLES;SFunction;LSp;22|))
                       (SEQ (LETT |i| 1 . #5#)
                            (LETT #1# (LENGTH |li|) . #5#) G190
                            (COND ((QSGREATERP |i| #1#) #6=(GO G191)))
                            (SEQ (EXIT (LETT #0#
                                        (CONS
                                         (PROGN
                                           (LETT #2# NIL . #5#)
                                           (SEQ (LETT |j| 1 . #5#)
                                            (LETT #3#
                                             (LENGTH |li|) . #5#)
                                            (LETT |k| NIL . #5#)
                                            (LETT #4# |li| . #5#) G190
                                            (COND
                                              ((OR (ATOM #4#)
                                                (PROGN
                                                  (LETT |k|
                                                   (CAR #4#) . #5#)
                                                  NIL)
                                                (QSGREATERP |j| #3#))
                                               #6#))
                                            (SEQ
                                             (EXIT
                                              (LETT #2#
                                               (CONS
                                                (|CYCLES;hh|
                                                 (+ (- |k| |j|) |i|) $)
                                                #2#) . #5#)))
                                            (LETT #4#
                                             (PROG1 (CDR #4#)
                                               (LETT |j|
                                                (QSADD1 |j|) . #5#)) . #5#)
                                            #7=(GO G190) G191
                                            (EXIT (NREVERSE0 #2#))))
                                         #0#) . #5#)))
                            (LETT |i| (QSADD1 |i|) . #5#) #7# G191
                            (EXIT (NREVERSE0 #0#))))
                     (QREFELT $ 69)) . #5#)
           (EXIT (SPADCALL |a| (QREFELT $ 70))))))) 

(DEFUN |CYCLES;roundup| (|li1| |li2| $)
  (COND
    ((< (LENGTH |li2|) (LENGTH |li1|))
     (|CYCLES;roundup| |li1| (SPADCALL |li2| 0 (QREFELT $ 72)) $))
    ('T |li2|))) 

(DEFUN |CYCLES;skewSFunction;2LSp;24| (|li1| |li2| $)
  (PROG (#0=#:G1930 |i| #1=#:G1931 #2=#:G1932 |j| #3=#:G1934 |k|
            #4=#:G1933 |a|)
    (RETURN
      (SEQ (COND
             ((< (LENGTH |li1|) (LENGTH |li2|))
              (|error| "skewSFunction: partition1 does not include partition2"))
             ('T
              (SEQ (LETT |li2| (|CYCLES;roundup| |li1| |li2| $)
                         . #5=(|CYCLES;skewSFunction;2LSp;24|))
                   (LETT |a|
                         (SPADCALL
                             (PROGN
                               (LETT #0# NIL . #5#)
                               (SEQ (LETT |i| 1 . #5#)
                                    (LETT #1# (LENGTH |li1|) . #5#)
                                    G190
                                    (COND
                                      ((QSGREATERP |i| #1#)
                                       #6=(GO G191)))
                                    (SEQ
                                     (EXIT
                                      (LETT #0#
                                       (CONS
                                        (PROGN
                                          (LETT #2# NIL . #5#)
                                          (SEQ (LETT |j| 1 . #5#)
                                           (LETT #3#
                                            (LENGTH |li1|) . #5#)
                                           (LETT |k| NIL . #5#)
                                           (LETT #4# |li1| . #5#) G190
                                           (COND
                                             ((OR (ATOM #4#)
                                               (PROGN
                                                 (LETT |k|
                                                  (CAR #4#) . #5#)
                                                 NIL)
                                               (QSGREATERP |j| #3#))
                                              #6#))
                                           (SEQ
                                            (EXIT
                                             (LETT #2#
                                              (CONS
                                               (|CYCLES;hh|
                                                (+
                                                 (-
                                                  (- |k|
                                                   (SPADCALL |li2| |i|
                                                    (QREFELT $ 73)))
                                                  |j|)
                                                 |i|)
                                                $)
                                               #2#) . #5#)))
                                           (LETT #4#
                                            (PROG1 (CDR #4#)
                                              (LETT |j|
                                               (QSADD1 |j|) . #5#)) . #5#)
                                           #7=(GO G190) G191
                                           (EXIT (NREVERSE0 #2#))))
                                        #0#) . #5#)))
                                    (LETT |i| (QSADD1 |i|) . #5#) #7#
                                    G191 (EXIT (NREVERSE0 #0#))))
                             (QREFELT $ 69)) . #5#)
                   (EXIT (SPADCALL |a| (QREFELT $ 70)))))))))) 

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

(DEFUN |CycleIndicators;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|CycleIndicators|) . #0=(|CycleIndicators|))
        (LETT $ (GETREFV 75) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|CycleIndicators| NIL
            (CONS 1 $))
        (|stuffDomainSlots| $)
        $)))) 

(MAKEPROP '|CycleIndicators| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|Integer|) (|Partition|)
             (0 . |pdct|) (|Fraction| 6) (5 . |coerce|) (10 . |inv|)
             (|SymmetricPolynomial| 9) (15 . |monomial|) (|Stream| 22)
             (21 . |complete|) (|List| 22) (26 . |entries|)
             (31 . |Zero|) (35 . |One|) (|PartitionsAndPermutations|)
             (39 . |partitions|) (|List| 6) (44 . |partition|) (49 . +)
             |CYCLES;complete;ISp;3| (|Boolean|) (55 . |even?|)
             (|PositiveInteger|) (60 . *) |CYCLES;alternating;ISp;5|
             (66 . -) |CYCLES;elementary;ISp;6| (|Factored| 6)
             (71 . |coerce|)
             (|Record| (|:| |factor| 6) (|:| |exponent| 6)) (|List| 35)
             (76 . |factors|) (81 . |One|) (85 . |One|)
             |CYCLES;powerSum;ISp;9| (|IntegerNumberTheoryFunctions|)
             (89 . |eulerPhi|) (94 . /) (100 . |numer|) (105 . *)
             |CYCLES;cyclic;ISp;10| (111 . *) |CYCLES;dihedral;ISp;11|
             (117 . |powers|) (122 . |second|) (127 . |lcm|)
             |CYCLES;graphs;ISp;13| (133 . |zero?|) (138 . |degree|)
             (143 . <) (149 . =) (155 . |leadingCoefficient|) (160 . *)
             (166 . |reductum|) |CYCLES;cup;3Sp;15| (171 . |Zero|)
             |CYCLES;eval;SpF;16| (175 . +) |CYCLES;cap;2SpF;17|
             (181 . |coerce|) |CYCLES;wreath;3Sp;20|
             (|List| (|List| 12)) (|Matrix| 12) (186 . |matrix|)
             (191 . |determinant|) |CYCLES;SFunction;LSp;22|
             (196 . |concat|) (202 . |elt|)
             |CYCLES;skewSFunction;2LSp;24|)
          '#(|wreath| 208 |skewSFunction| 214 |powerSum| 220 |graphs|
             225 |eval| 230 |elementary| 235 |dihedral| 240 |cyclic|
             245 |cup| 250 |complete| 256 |cap| 261 |alternating| 267
             |SFunction| 272)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 74
                                '(1 7 6 0 8 1 9 0 6 10 1 9 0 0 11 2 12
                                  0 9 7 13 1 14 0 0 15 1 14 16 0 17 0
                                  12 0 18 0 12 0 19 1 20 14 6 21 1 7 0
                                  22 23 2 12 0 0 0 24 1 6 26 0 27 2 12
                                  0 28 0 29 1 12 0 0 31 1 33 0 6 34 1
                                  33 36 0 37 0 33 0 38 0 9 0 39 1 41 6
                                  6 42 2 9 0 6 6 43 1 9 6 0 44 2 12 0 9
                                  0 45 2 12 0 0 0 47 1 7 16 22 49 1 22
                                  6 0 50 2 6 0 0 0 51 1 12 26 0 53 1 12
                                  7 0 54 2 7 26 0 0 55 2 7 26 0 0 56 1
                                  12 9 0 57 2 12 0 6 0 58 1 12 0 0 59 0
                                  9 0 61 2 9 0 0 0 63 1 7 22 0 65 1 68
                                  0 67 69 1 68 12 0 70 2 22 0 0 6 72 2
                                  22 6 0 6 73 2 0 12 12 12 66 2 0 12 22
                                  22 74 1 0 12 6 40 1 0 12 6 52 1 0 9
                                  12 62 1 0 12 6 32 1 0 12 6 48 1 0 12
                                  6 46 2 0 12 12 12 60 1 0 12 6 25 2 0
                                  9 12 12 64 1 0 12 6 30 1 0 12 22 71)))))
          '|lookupComplete|)) 

(MAKEPROP '|CycleIndicators| 'NILADIC T) 
