Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 

Benutzer

Quelle  test-schreier-sims.cpp

  Sprache: C
 

// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2019 James D. Mitchell
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

// These tests are derived from:
//
//   https://github.com/james-d-mitchell/libsemigroups/pull/39
//
// by Alex Levine and Luke Elliott. Many examples here taken from
//
//   http://brauer.maths.qmul.ac.uk/Atlas/

#include <cstddef>  // for size_t
#include <cstdint>  // for uint64_t

#include "catch.hpp"                        // for LIBSEMIGROUPS_TEST_CASE
#include "libsemigroups/config.hpp"         // for LIBSEMIGROUPS_HPCOMBI_ENABLED
#include "libsemigroups/report.hpp"         // for ReportGuard
#include "libsemigroups/schreier-sims.hpp"  // for SchreierSims, SchreierSims<>::ele...
#include "libsemigroups/transf.hpp"         // for Perm
#include "test-main.hpp"                    // for LIBSEMIGROUPS_TEST_CASE

namespace libsemigroups {
  struct LibsemigroupsException;

  constexpr bool REPORT = false;

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "001",
                          "trivial perm. group (degree 1)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<1> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({0}));
    REQUIRE(S.size() == 1);
    REQUIRE(S.contains(Perm({0})));
    // REQUIRE(!S.contains(Perm({1, 0})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "002",
                          "trivial perm. group (degree 2)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<2> S;
    using Perm = SchreierSims<2>::element_type;
    S.add_generator(Perm({01}));
    REQUIRE(S.size() == 1);
    REQUIRE(S.sift(Perm({10})) == Perm({10}));
    REQUIRE(!S.contains(Perm({10})));
    REQUIRE(S.contains(Perm({01})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "003",
                          "trivial perm. group (degree 500)",
                          "[quick][schreier-sims]") {
    auto rg            = ReportGuard(REPORT);
    size_t constexpr N = 100;
    // We allocate using "new" to avoid allocation on the stack,
    // since 100 is too large, and causes this test to seg fault.
    auto S     = new SchreierSims<N>();
    using Perm = std::remove_pointer<decltype(S)>::type::element_type;

    auto p = Perm::identity(N);

    S->add_generator(p);

    REQUIRE(S->size() == 1);
    REQUIRE(S->contains(p));

    std::swap(p[30], p[31]);
    REQUIRE(!S->contains(p));
    std::swap(p[73], p[32]);
    REQUIRE(!S->contains(p));
    std::swap(p[73], p[32]);
    std::swap(p[30], p[31]);
    std::swap(p[0], p[99]);
    REQUIRE(!S->contains(p));
    delete S;
  }

  // The next tests fail (04 to 09, inclusive), with default template
  // parameters, due to HPCombi 0.0.3 currently composing functions from
  // right to left.
  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "004",
                          "symmetric perm. group (degree 5)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<5> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({10234}));
    S.add_generator(Perm({12340}));
    REQUIRE(S.size() == 120);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "005",
                          "symmetric perm. group (degree 8)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<8> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({06234517}));
    S.add_generator(Perm({12345670}));
    REQUIRE(S.size() == 40320);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "006",
                          "symmetric perm. group (degree 9)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<9> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({102345678}));
    S.add_generator(Perm({123456780}));
    REQUIRE(S.size() == 362880);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "007",
                          "alternating perm. group (degree 12)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<12> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({12034567891011}));
    S.add_generator(Perm({02345678910111}));

    REQUIRE(!S.contains(Perm({11100682354791})));
    REQUIRE(S.contains(Perm({71123069108541})));
    // REQUIRE(!S.contains(Perm({11, 10, 0, 6, 8, 2, 3, 5, 4, 7, 9, 1, 12})));
    REQUIRE(S.size() == 239500800);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "008",
                          "symmetric perm. group (degree 16)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<16> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(
        Perm({1203456789101112131415}));
    S.add_generator(
        Perm({1234567891011121314150}));
    REQUIRE(S.size() == static_cast<uint64_t>(20922789888000));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "009",
                          "alternating perm. group (degree 15)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<15> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({12034567891011121314}));
    S.add_generator(Perm({12345678910111213140}));
    REQUIRE(S.size() == static_cast<uint64_t>(653837184000));

    REQUIRE(
        S.contains(Perm({01789101112131423456})));
    REQUIRE(
        S.contains(Perm({11201314234567891011})));
    REQUIRE(
        S.contains(Perm({12011314234567891011})));
    REQUIRE(
        !S.contains(Perm({12011314235467891011})));
    REQUIRE(
        !S.contains(Perm({11201413325467891011})));
    REQUIRE(
        !S.contains(Perm({01798111012131423654})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "010",
                          "alternating perm. group (degree 16)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<16> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(
        Perm({1203456789101112131415}));
    S.add_generator(
        Perm({1234567891011121314015}));
    S.add_generator(
        Perm({0123456789101112141513}));
    REQUIRE(S.size() == static_cast<uint64_t>(10461394944000));
    REQUIRE(S.contains(
        Perm({0123456789101112141513})));
    REQUIRE(!S.contains(
        Perm({1023456789101112141513})));
    REQUIRE(S.contains(
        Perm({1032456789101112141513})));

    REQUIRE(S.contains(
        Perm({1203456789101112131415})));
    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(S.generator(2)));
    REQUIRE(S.contains(
        Perm({0178910111213142345615})));
    REQUIRE(S.contains(
        Perm({1120131423456789101115})));
    REQUIRE(S.contains(
        Perm({1201131423456789101115})));
    REQUIRE(!S.contains(
        Perm({1201131423546789101115})));
    REQUIRE(!S.contains(
        Perm({1120141332546789101115})));
    REQUIRE(!S.contains(
        Perm({0179811101213142365415})));

    REQUIRE(!S.contains(
        Perm({1023456789101112141513})));
    S.add_generator(
        Perm({1023456789101112141513}));
    REQUIRE(S.contains(
        Perm({1023456789101112141513})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "011",
                          "dihedral perm. group (order 10)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<5> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({04321}));
    S.add_generator(Perm({12340}));

    REQUIRE(S.size() == 10);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "012",
                          "dihedral perm. group (order 200)",
                          "[quick][schreier-sims]") {
    auto rg = ReportGuard(REPORT);
    // At N = 4000 or so, this starts to take an appreciable amount of time.
    constexpr size_t N = 200;
    auto             S = new SchreierSims<N>();
    using Perm         = std::remove_pointer<decltype(S)>::type::element_type;

    Perm::container_type cntnr;
    std::fill(cntnr.begin(), cntnr.end(), 0);
    std::iota(cntnr.begin(), cntnr.end() - 11);
    S->add_generator(Perm(cntnr));
    std::iota(cntnr.rbegin(), cntnr.rend() - 11);
    cntnr[0] = 0;
    S->add_generator(Perm(cntnr));
    REQUIRE(S->size() == 2 * N);

    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));
    REQUIRE(S->contains(S->generator(1) * S->generator(0)));

    std::iota(cntnr.begin(), cntnr.end(), 0);
    for (auto it = cntnr.begin(); it < cntnr.end(); it += 2) {
      std::swap(*it, *(it + 1));
    }
    REQUIRE(!S->contains(Perm(cntnr)));
    std::swap(*cntnr.begin(), *(cntnr.begin() + 1));
    REQUIRE(!S->contains(Perm(cntnr)));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "013",
                          "perm. group T (order 12)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<12> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({12345078910116}));
    S.add_generator(Perm({61110987321054}));
    REQUIRE(S.size() == 12);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "014",
                          "quaternion perm. group (order 8)",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<9> S;
    using Perm = decltype(S)::element_type;
    S.add_generator(Perm({024673815}));
    S.add_generator(Perm({035487261}));
    REQUIRE(S.generator(0) == Perm({024673815}));

    REQUIRE(S.size() == 8);
    REQUIRE(S.sift(S.generator(0)) == S.identity());
    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(Perm({063751482})));
    REQUIRE(S.contains(Perm({086132754})));
    REQUIRE(!S.contains(Perm({015487263})));
    REQUIRE(!S.contains(Perm({354618270})));
    REQUIRE(!S.contains(Perm({132578640})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "015",
                          "perm. group (order 84129611558952960)",
                          "[quick][schreier-sims][no-valgrind]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 729;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,
         14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,
         28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,
         42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,
         56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,
         70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
         84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,
         98,  99,  100101102103104105106107108109110111,
         112113114115116117118119120121122123124125,
         126127128129130131132133134135136137138139,
         140141142143144145146147148149150151152153,
         154155156157158159160161162163164165166167,
         168169170171172173174175176177178179180181,
         182183184185186187188189190191192193194195,
         196197198199200201202203204205206207208209,
         210211212213214215216217218219220221222223,
         224225226227228229230231232233234235236237,
         238239240241242486487488489490491492493494,
         495496497498499500501502503504505506507508,
         509510511512513514515516517518519520521522,
         523524525526527528529530531532533534535536,
         537538539540541542543544545546547548549550,
         551552553554555556557558559560561562563564,
         565566567568569570571572573574575576577578,
         579580581582583584585586587588589590591592,
         593594595596597598599600601602603604605606,
         607608609610611612613614615616617618619620,
         621622623624625626627628629630631632633634,
         635636637638639640641642643644645646647648,
         649650651652653654655656657658659660661662,
         663664665666667668669670671672673674675676,
         677678679680681682683684685686687688689690,
         691692693694695696697698699700701702703704,
         705706707708709710711712713714715716717718,
         719720721722723724725726727728243244245246,
         247248249250251252253254255256257258259260,
         261262263264265266267268269270271272273274,
         275276277278279280281282283284285286287288,
         289290291292293294295296297298299300301302,
         303304305306307308309310311312313314315316,
         317318319320321322323324325326327328329330,
         331332333334335336337338339340341342343344,
         345346347348349350351352353354355356357358,
         359360361362363364365366367368369370371372,
         373374375376377378379380381382383384385386,
         387388389390391392393394395396397398399400,
         401402403404405406407408409410411412413414,
         415416417418419420421422423424425426427428,
         429430431432433434435436437438439440441442,
         443444445446447448449450451452453454455456,
         457458459460461462463464465466467468469470,
         471472473474475476477478479480481482483484,
         485}));
    S->add_generator(Perm(
        {0,   6,   3,   18,  24,  21,  9,   15,  12,  54,  60,  57,  72,  78,
         75,  63,  69,  66,  27,  33,  30,  45,  51,  48,  36,  42,  39,  162,
         168165180186183171177174216222219234240237,
         22523122818919519220721321019820420181,  87,
         84,  99,  10510290,  96,  93,  135141138153159156144,
         150147108114111126132129117123120486492489,
         504510507495501498540546543558564561549555,
         552513519516531537534522528525648654651666,
         672669657663660702708705720726723711717714,
         675681678693699696684690687567573570585591,
         588576582579621627624639645642630636633594,
         600597612618615603609606243249246261267264,
         252258255297303300315321318306312309270276,
         273288294291279285282405411408423429426414,
         420417459465462477483480468474471432438435,
         450456453441447444324330327342348345333339,
         336378384381396402399387393390351357354369,
         375372360366363487493490505511508496502499,
         541547544559565562550556553514520517532538,
         535523529526649655652667673670658664661703,
         709706721727724712718715676682679694700697,
         685691688568574571586592589577583580622628,
         625640646643631637634595601598613619616604,
         610607244250247262268265253259256298304301,
         316322319307313310271277274289295292280286,
         283406412409424430427415421418460466463478,
         484481469475472433439436451457454442448445,
         325331328343349346334340337379385382397403,
         4003883943913523583553703763733613673641,
         7,   4,   19,  25,  22,  10,  16,  13,  55,  61,  58,  73,  79,  76,
         64,  70,  67,  28,  34,  31,  46,  52,  49,  37,  43,  40,  163169,
         166181187184172178175217223220235241238226,
         23222919019619320821421119920520282,  88,  85,
         10010610391,  97,  94,  136142139154160157145151,
         148109115112127133130118124121245251248263,
         269266254260257299305302317323320308314311,
         272278275290296293281287284407413410425431,
         428416422419461467464479485482470476473434,
         440437452458455443449446326332329344350347,
         335341338380386383398404401389395392353359,
         3563713773743623683652,   8,   5,   20,  26,  23,  11,
         17,  14,  56,  62,  59,  74,  80,  77,  65,  71,  68,  29,  35,  32,
         47,  53,  50,  38,  44,  41,  164170167182188185173179,
         176218224221236242239227233230191197194209,
         21521220020620383,  89,  86,  10110710492,  98,  95,
         137143140155161158146152149110116113128134,
         131119125122488494491506512509497503500542,
         548545560566563551557554515521518533539536,
         524530527650656653668674671659665662704710,
         707722728725713719716677683680695701698686,
         692689569575572587593590578584581623629626,
         641647644632638635596602599614620617605611,
         608}));

    REQUIRE(S->size() == static_cast<uint64_t>(84129611558952960));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "016",
                          "perm. group SL(3, 5) (order 372000)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 126;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(
        Perm({0,  1,  76,  10126516,  811063156118611136,
              611691,  1164166219612146712,  7710227,
              527,  82,  107325712871123762179211742,
              672297,  12247723,  7810328538,  8310833,
              581388,  113386318931184368239812348,
              734,  79,  10429549,  841093459148911439,
              641994,  1194469249912449745,  8010530,
              551085,  110356015901154065209512045,
              70251001255075}));
    S->add_generator(
        Perm({0,  1,  7710329556,  8210834601187,  11339,
              6516921184470219712349752,  78,  10526,
              547,  831103159128811536641793,  12041,
              69229812546743,  8010427518,  85,  10932,
              5613901143761189511942662310012447,
              714,  7610230539,  8110735581486,  11240,
              6319911174568249612250735,  79,  10128,
              5210841063357158911138622094,  11643,
              6725991214872}));
    S->add_generator(
        Perm({0,  1,  8111141716,  86,  1212666119611631,
              51167610646612191,  10136562,  8211242,
              727,  8712227671297,  1173252177710747,
              62229210237573,  83,  11343738,  8812328,
              68139811833531878,  1084863239310338,
              584,  8411444749,  89,  1242969149911934,
              54197910949642494,  10439595,  8511545,
              7510901253070151001203555208011050,
              6525951054060}));
    S->add_generator(
        Perm({0,  1,  7610126517,  82,  1073257138811338,
              63199411944692510012550752,  7710227,
              528,  8310833581590,  1154065169111641,
              66249912449743,  78,  1032853108511035,
              60148911439641792,  1174267219612146,
              714,  7910429546,  81,  1063156128711237,
              62209512045702398,  12348735,  8010530,
              559,  8410934591186,  1113661189311843,
              6822971224772}));

    REQUIRE(S->size() == 372000);

    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));
    REQUIRE(S->contains(S->generator(2)));
    REQUIRE(S->contains(S->generator(3)));
    REQUIRE(!S->contains(
        Perm({0,  1,  76,  10126517,  82,  1073257138811338,
              631994,  11944692510012550752,  7710227,
              528,  83,  10833581590,  1154065169111641,
              662499,  12449743,  78,  1032853108511035,
              601489,  11439641792,  1174267219612146,
              714,  79,  10429546,  81,  1063156128711237,
              622012095,  45702398,  12348735,  8010530,
              559,  84,  10934591186,  1113661189311843,
              682297,  1224772})));

    REQUIRE(!S->contains(
        Perm({1,  77103109556,  8210834,  601187,  11339,  65,
              169211844,  70219712349,  752,  78,  10526,  54,
              7,  8311031,  59128811536,  641793,  12041,  69,
              229812546,  743,  8010427,  518,  85,  29,  32,  56,
              139011437,  61189511942,  662310012447,  71,
              4,  760,   10230539,  81,  107355814,  86,  11240,
              631991,  11745682496,  12250735,   79,  10128,
              521084,  10633571589,  111386220,  94,  11643,
              672599,  1214872})));

    REQUIRE(!S->contains(Perm(
        {0,  1,  8077,  103109556,  82,  108346011,  87,  113,
         39651692,  11844,  702197,  12349752,   78,  105,
         26547,  83,  11031,  591288,  115366417,  93,  120,
         41692298,  12546,  743,  10427,  518,  85,  29,  32,
         56139011437,  61,  189511942,  662310012447,
         714,  7610230,  53,  9,  8110735,  581486,  11240,
         63199111745,  68,  249612250,  735,  79,  10128,
         52108410633,  57,  158911138,  622094,  11643,
         67259912148,  72})));

    REQUIRE(S->contains(
        Perm({0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,
              13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,
              41,  42,  43,  44,  45,  26,  27,  28,  29,  30,  31,  32,  33,
              34,  35,  46,  47,  48,  49,  50,  36,  37,  38,  39,  40,  71,
              72,  73,  74,  75,  66,  67,  68,  69,  70,  51,  52,  53,  54,
              55,  61,  62,  63,  64,  65,  56,  57,  58,  59,  60,  81,  82,
              83,  84,  85,  86,  87,  88,  89,  90,  96,  97,  98,  99,  100,
              76,  77,  78,  79,  80,  91,  92,  93,  94,  95,  111112113,
              114115121122123124125116117118119120106,
              107108109110101102103104105})));

    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "017",
                          "perm. group PSL(4, 8) (order 34558531338240)",
                          "[quick][schreier-sims][no-valgrind]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 585;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {1,   9,   17,  25,  33,  41,  49,  57,  65,  73,  81,  89,  97,  105,
         113121129137145153161169177185193201209217,
         225233241249257265273281289297305313321329,
         337345353361369377385393401409417425433441,
         449457465473481489497505513521529537545553,
         56156957774,  82,  90,  98,  106114122130138146154,
         162170178186194202210218226234242250258266,
         274282290298306314322330338346354362370378,
         386394402410418426434442450458466474482490,
         4985065145225305385465545625705780,   2,   8,
         7,   6,   5,   4,   3,   10,  18,  26,  34,  42,  50,  58,  66,  16,
         72,  24,  32,  40,  48,  56,  64,  15,  63,  71,  23,  31,  39,  47,
         55,  14,  54,  62,  70,  22,  30,  38,  46,  13,  45,  53,  61,  69,
         21,  29,  37,  12,  36,  44,  52,  60,  68,  20,  28,  11,  27,  35,
         43,  51,  59,  67,  19,  78,  11812613486,  94,  102110398,
         438446454406414422430462502510518470478486,
         494526566574582534542550558142182190198150,
         158166174206246254262214222230238270310318,
         32627828629430233437438239034235035836675,
         91,  99,  10711512313183,  203219227235243251259,
         211267283291299307315323275331347355363371,
         379387339395411419427435443451403459475483,
         491499507515467523539547555563571579531139,
         15516317117918719514780,  13688,  96,  104112120,
         128528584536544552560568576144200152160168,
         176184192208264216224232240248256272328280,
         288296304312320336392344352360368376384400,
         456408416424432440448464520472480488496504,
         51276,  10010811612413284,  92,  268292300308316,
         324276284332356364372380388340348396420428,
         436444452404412460484492500508516468476524,
         548556564572580532540140164172180188196148,
         15620422823624425226021222077,  109117125133,
         85,  93,  101333365373381389341349357397429437,
         445453405413421461493501509517469477485525,
         557565573581533541549141173181189197149157,
         165205237245253261213221229269301309317325,
         27728529379,  12713587,  95,  103111119463511519,
         471479487495503527575583535543551559567143,
         191199151159167175183207255263215223231239,
         247271319327279287295303311335383391343351,
         359367375399447455407415423431439}));
    S->add_generator(Perm(
        {0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   11,  12,  13,  14,
         15,  16,  10,  25,  27,  28,  29,  30,  31,  32,  26,  33,  35,  36,
         37,  38,  39,  40,  34,  41,  43,  44,  45,  46,  47,  48,  42,  49,
         51,  52,  53,  54,  55,  56,  50,  57,  59,  60,  61,  62,  63,  64,
         58,  65,  67,  68,  69,  70,  71,  72,  66,  17,  19,  20,  21,  22,
         23,  24,  18,  73,  80,  74,  75,  76,  77,  78,  79,  129136130,
         13113213313413581,  88,  82,  83,  84,  85,  86,  87,  89,
         96,  90,  91,  92,  93,  94,  95,  97,  10498,  99,  100101102,
         103105112106107108109110111113120114115116,
         117118119121128122123124125126127457464458,
         459460461462463513520514515516517518519465,
         472466467468469470471473480474475476477478,
         479481488482483484485486487489496490491492,
         493494495497504498499500501502503505512506,
         507508509510511521528522523524525526527577,
         584578579580581582583529536530531532533534,
         535537544538539540541542543545552546547548,
         549550551553560554555556557558559561568562,
         563564565566567569576570571572573574575137,
         144138139140141142143193200194195196197198,
         199145152146147148149150151153160154155156,
         157158159161168162163164165166167169176170,
         171172173174175177184178179180181182183185,
         192186187188189190191201208202203204205206,
         207257264258259260261262263209216210211212,
         213214215217224218219220221222223225232226,
         227228229230231233240234235236237238239241,
         248242243244245246247249256250251252253254,
         255265272266267268269270271321328322323324,
         325326327273280274275276277278279281288282,
         283284285286287289296290291292293294295297,
         304298299300301302303305312306307308309310,
         311313320314315316317318319329336330331332,
         333334335385392386387388389390391337344338,
         339340341342343345352346347348349350351353,
         360354355356357358359361368362363364365366,
         367369376370371372373374375377384378379380,
         381382383393400394395396397398399449456450,
         451452453454455401408402403404405406407409,
         416410411412413414415417424418419420421422,
         423425432426427428429430431433440434435436,
         437438439441448442443444445446447}));

    REQUIRE(S->size() == static_cast<uint64_t>(34558531338240));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "018",
                          "perm. Mathieu group M11 (order 7920)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 11;
    using Perm          = Perm<0, size_t>;
    auto S              = SchreierSims<N, size_t, Perm>();

    S.add_generator(Perm({092106548713}));
    S.add_generator(Perm({347258601910}));

    REQUIRE(S.size() == 7920);
    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(Perm({108501249763})));
    REQUIRE(S.contains(Perm({360941075281})));
    REQUIRE(!S.contains(Perm({456789100123})));
    REQUIRE(!S.contains(Perm({678910021354})));
    REQUIRE(!S.contains(Perm({910123405678})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "019",
                          "perm. Mathieu group M24 (order 244823040)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 24;
    auto             S  = SchreierSims<N>();
    using Perm          = decltype(S)::element_type;

    S.add_generator(Perm({1,  2,  3,  4,  5,  6,  7,  8,  9,  101112,
                          131415161718192021220,  23}));
    S.add_generator(Perm({0,  1,  161235,  8172,  6,  1122,
                          1318191491042115207,  23}));

    S.add_generator(Perm({232211151791913205,  162,
                          217,  183,  104146,  8,  121,  0}));

    REQUIRE(S.size() == 244823040);
    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(Perm({1,  161235,  8172,  6,  112213,
                             18191491042115207,  0,  23})));
    REQUIRE(S.contains(Perm({121618102014216,  173,  228,
                             194,  115,  157,  9,  132,  230,  1})));
    REQUIRE(S.contains(Perm({199211310226167,  81117,
                             125151,  140,  418203232})));
    REQUIRE(
        !S.contains(Perm({0,  3,  2,  1,  4,  5,  6,  7,  8,  9,  1011,
                          121314151617181920212223})));
    REQUIRE(
        !S.contains(Perm({0,  1,  3,  4,  2,  5,  6,  7,  8,  9,  1011,
                          121314151617181920212223})));
    REQUIRE(
        !S.contains(Perm({0,  1,  3,  4,  2,  6,  5,  7,  8,  9,  1011,
                          121314151617181920212223})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "020",
                          "perm. Janko Group J1 (order 175560)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 267;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,   26210721,  21319122,  133234232151139176202,
         25322216,  19520668,  55,  3,   6,   17921721625687,
         70,  13144,  10517077,  10419813724356,  124223134,
         42,  17430,  45,  51,  12894,  25026446,  18323111520,
         38,  85,  23326195,  23517724991,  24715567,  19,  219,
         28,  23721184,  19213025133,  78,  260112193156242,
         73,  57,  23827,  14316814864,  11921248,  60,  150199,
         14018918014711115934,  31,  1622,   194166200102,
         80,  12014154,  18218122592,  11325412514639,  122,
         20822147,  21075,  29,  2557,   41,  13517536,  20711,
         98,  11424088,  17218512310190,  22496,  10,  169241,
         19066,  82,  214161103236158106239229230109188,
         89,  15232,  25814418643,  13612,  62,  24523,  100117,
         11652,  20514517322816799,  1545,   74,  81,  10817,
         19620335,  97,  11025213,  19720418418,  138126248,
         12972,  93,  4,   15725925,  24,  24669,  22712715,  40,
         14911822622018716416553,  9,   58,  8,   61,  16071,
         86,  16314215383,  37,  24417821865,  20963,  49,  76,
         20114,  12113226,  26317121579,  59,  1,   25750,  266,
         265}));
    S->add_generator(Perm(
        {0,   1461323,   15624210712524517424126424836,
         11647,  1781701972331211,   22848,  20115,  136212,
         6,   17577,  23730,  22631,  12944,  16123221978,  139,
         9,   21113,  22297,  25,  17370,  15318629,  20335,  169,
         14026091,  19910820820611,  55,  10365,  95,  73,  151,
         13141,  22122518,  1437,   32,  15921793,  1812,   258,
         16315418238,  13311733,  24319112227,  20520,  135,
         98,  22913861,  19466,  10414962,  28,  16412317,  137,
         16,  69,  37,  23812824757,  16713496,  80,  19318576,
         83,  21814,  54,  8,   49,  82,  21518946,  19018318871,
         23023123920222415821,  11921418425011372,  200,
         21322,  16610222040,  92,  11425717760,  1794,   147,
         16864,  11017114823,  42,  52,  19584,  11224619,  252,
         19611110526520924,  10012026,  16039,  109157266,
         86,  74,  20422750,  18775,  21620767,  10619810151,
         14125194,  85,  17288,  53,  254261192145152240262,
         24968,  90,  59,  15526356,  21087,  18012,  11514234,
         23523645,  24425358,  10,  13016589,  23414425943,
         81,  5,   79,  22316225612615011812725599,  63,  124,
         176}));

    REQUIRE(S->size() == 175560);
    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));
    REQUIRE(S->contains(Perm(
        {0,   17456,  26221021481,  21,  16023014817067,  91,
         12623825,  85,  26032,  16,  29,  18166,  24814316739,
         24111598,  13922620,  12,  73,  15210,  141165121117,
         16984,  11,  21111211623438,  13148,  21922268,  217,
         9,   26518817674,  17369,  25516340,  77,  45,  264147,
         22563,  33,  58,  21217,  51,  2613,   11959,  65,  6,   41,
         10380,  23143,  18420115118947,  49,  42,  24512492,
         20671,  12361,  25923910517811318396,  104111195,
         19919419221683,  97,  64,  18094,  1308,   156134144,
         24689,  11022182,  24319076,  15428,  12024911487,
         23,  10215021834,  20257,  23512726,  253257258108,
         20537,  13217720818,  19123354,  35,  18225155,  27,
         24725419,  26644,  99,  5,   12218688,  60,  13624,  30,
         24216650,  26375,  25611852,  18715853,  1,   237209,
         24014,  4,   20414015590,  14514615386,  198175252,
         23612510919322325022721572,  12993,  13,  15,  213,
         7,   16817222412820324422,  200133161142171135,
         13831,  2,   10619715719618516415913779,  107149,
         22862,  17910110022916222070,  23295,  78,  36,  46,
         207})));

    REQUIRE(S->contains(Perm(
        {0,   56,  11822921712579,  1001,   25919012260,  260,
         52,  20618971,  12023,  44,  160186148265170243195,
         20415117920225416116920123596,  46,  20037,  90,
         12154,  3,   21213024815614314124610614643,  234,
         11617117810564,  20,  29,  16413711318220931,  163,
         15922719726210766,  22,  59,  58,  24473,  2301152,
         1651526,   2401581674,   26436,  255191101261192,
         23962,  11723130,  17,  24114,  75,  14440,  147119132,
         20317413313678,  16,  15518,  13995,  11,  68,  258228,
         13,  8,   5,   17719312423850,  11270,  15721861,  224,
         85,  55,  16610414297,  84,  23212974,  24,  266123215,
         10849,  17387,  12712645,  28,  24524947,  69,  22621,
         13819663,  57,  72,  91,  53,  11114048,  88,  149199187,
         21622232,  17233,  25313122581,  256221237109211,
         21025011418315015,  23615418139,  25,  214134207,
         17522025114518023377,  7,   94,  80,  16221324767,
         10341,  10211027,  18438,  18520519815399,  252242,
         26,  83,  21998,  10,  34,  26312812,  22335,  65,  42,  93,
         17676,  16825751,  89,  13592,  18820882,  86,  19,  194,
         9})));

    REQUIRE(S->contains(Perm(
        {0,   20124331,  22913612222316415518545,  3,   81,
         16648,  14,  10516216922894,  21243,  16719093,  202,
         22455,  56,  29,  11811619416118439,  13422,  18166,
         8,   21611211058,  1831311561032441442035,   59,
         9,   23110823852,  11125517822623,  92,  82,  17351,
         14526,  14613819614316337,  24924653,  191117245,
         2004,   30,  10624732,  19226349,  14217134,  188151,
         65,  26036,  6,   68,  25926512320,  73,  19363,  258100,
         2,   41,  16,  7,   12413223086,  13511383,  17,  14933,
         25684,  42,  12818023647,  18711,  74,  25361,  67,  209,
         21170,  23719825,  266130182125213250257141199,
         14713,  17510291,  27,  20575,  22224215320676,  88,
         1,   14096,  18,  69,  85,  18910,  50,  20822721,  139165,
         40,  87,  35,  20417999,  15817679,  25138,  10957,  89,
         22190,  24,  219252214159157239262129121160232,
         80,  97,  77,  60,  54,  44,  17719519,  15428,  22511462,
         24024815012012613316811921864,  17221719798,
         17078,  17415,  18610122011525413746,  20726195,
         15223514821510772,  26423421012771,  10424112,
         233})));

    REQUIRE(!S->contains(Perm(
        {0,   25019941,  14623,  54,  53,  25433,  40,  80,  18478,
         34,  92,  10226345,  19515310658,  19212793,  20970,
         12614315216685,  87,  11249,  22215942,  210238150,
         19123952,  17917455,  75,  51,  1421651,   81,  56,  9,
         19822564,  19723438,  178132183226265202241129,
         26,  36,  11610328,  90,  25257,  11967,  17121116160,
         94,  18,  18013423613613117620166,  167182124137,
         22018126250,  27,  25613574,  11324511891,  160109,
         18697,  21510520,  17524,  14971,  17,  14412520743,
         59,  22424223582,  18984,  13,  2271561207,   208139,
         1172572,   30,  35,  2446,   11421772,  44,  63,  89,  145,
         31,  26676,  12120424011516398,  26423326016265,
         2192531941511111235,   39,  46,  21299,  10816,  22,
         13883,  10414869,  2031871572063,   24629,  243232,
         10116822922114021323147,  228188100248185128,
         20088,  15512214,  10795,  73,  77,  11016979,  19332,
         22324911,  20517319025119610,  21862,  37,  21,  86,
         14725821413023716413319,  17224717725512,  158,
         48,  26125917021615423096,  15,  1414,   61,  25,  68,
         8})));

    REQUIRE(!S->contains(Perm(
        {0,   89,  18,  6,   15973,  10091,  11021666,  56,  14422,
         62,  15,  23,  14618811,  24514886,  96,  156114221103,
         2177,   12926,  11151,  23212,  141243212167225219,
         17734,  10464,  54,  25516525013620222720,  246124,
         13465,  84,  61,  77,  97,  16225924726321513915048,
         19618110618795,  44,  2,   33,  5,   26019,  12719569,
         58,  75,  14232,  20322445,  2514,   99,  88,  233184189,
         17385,  16324916,  43,  93,  27,  26414020816610139,
         21114,  20619223010787,  63,  10220420570,  115145,
         8,   3,   19818224,  15316817420015455,  40,  53,  59,
         12530,  11238,  26523622324226276,  19013328,  194,
         18321313060,  25712317125323414994,  10983,  118,
         25612617616431,  22815142,  26120122624824478,
         25822012017823971,  90,  67,  11919750,  199143175,
         92,  52,  29,  9,   80,  82,  15716014724049,  122191170,
         25213,  13120916125426674,  11341,  17911621,  185,
         1,   13717,  10821419317223810515221847,  11725,
         22235,  79,  18021013846,  37,  24181,  135169237128,
         12198,  15813223510,  36,  68,  20715523172,  57,  186,
         229})));

    REQUIRE(!S->contains(Perm(
        {0,   56,  11822921712579,  1001,   25919012260,  260,
         52,  20618971,  12023,  44,  160186148265170243195,
         20415117920225416116920123596,  46,  20037,  90,
         12154,  4,   21213024815614314124610614643,  234,
         11617117810564,  20,  29,  16413711318220931,  163,
         15922719726210766,  22,  59,  58,  24473,  2301153,
         1651522,   2401581675,   26436,  255191101261192,
         23962,  11723130,  17,  24114,  75,  14440,  147119132,
         20317413313678,  16,  15518,  13995,  11,  68,  258228,
         13,  8,   6,   17719312423850,  11270,  15721861,  224,
         85,  55,  16610414297,  84,  23212974,  24,  266123215,
         10849,  17387,  12712645,  28,  24524947,  69,  22621,
         13819663,  57,  72,  91,  53,  11114048,  88,  149199187,
         21622232,  17233,  25313122581,  256221237109211,
         21025011418315015,  23615418139,  25,  214134207,
         17522025114518023377,  7,   94,  80,  16221324767,
         10341,  10211027,  18438,  18520519815399,  252242,
         26,  83,  21998,  10,  34,  26312812,  22335,  65,  42,  93,
         17676,  16825751,  89,  13592,  18820882,  86,  19,  194,
         9})));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "021",
                          "perm. Hall-Janko group (order 604800)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 101;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,  842048568267554135407810049379476,
         1944172,  348592577528642690,  97386869,
         219,  53143161108,  7391188681,  893,  1393,
         967236747,  4,  24999563398360,  2770886,
         32336587524254251698118079,  465,  621,
         22457166472943235015595130,  775812}));
    S->add_generator(Perm(
        {0,  809,  532351377,  2711622,   6564619873,
         395,  1397961,  786,  15936057,  7169121617,
         862836245933434168914230,  8510769266,
         1814879529543520948,  5247,  7419318821,
         444581556332727090494,  1002275347984,
         89823,  504648407799385667,  58252683}));

    REQUIRE(S->size() == 604800);
    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));
    REQUIRE(S->contains(Perm(
        {0,  2211877818247,  602,  479,  31195225,  32,
         3351645867804,  3798998,  3555456573,  39,
         8257366,  941791414440686989629077,  88,
         5,  613,  56719528973827141072131250,  96,
         4230752974166381489223831,  708610084,
         46345366857643492659542120159379})));
    REQUIRE(S->contains(Perm(
        {0,  5920,  7638351373459484821014583968,
         953754,  5216892651815023187160437,  25,
         9,  8848,  972,  9646925362326680405,  2857,
         909329,  705533776,  787419311224729917,
         30421003,  2767219836418,  157956347547,
         918644,  69498765854,  2264631183611})));
    REQUIRE(S->contains(Perm(
        {0,  747868,  70209818217585444367503742,
         31726054,  3,  839,  34472813323652918746,
         24937186,  99826556531273886289455814,
         7,  661610055979451354,  69158026393027,
         2,  763829,  49575,  2348638,  9584116,  7722,
         10339661,  17902579598141649240191})));
    REQUIRE(!S->contains(Perm(
        {0,  2,  1,  4,  3,  5,  6,  8,  9,  107,  111213141516,
         1718192021222324252627282930313233,
         3435363738394041424344454647484950,
         5152535455565758596061626364656667,
         6869707172737475767778798081828384,
         858687888990919293949596979899100})));
    REQUIRE(!S->contains(Perm(
        {0,  3,  1004,  8,  5,  6,  7,  1,  3310111213141516,
         171819,  202122232425892728293031322,
         343536,  3738394041424344454647484950,
         515253,  5455565758596061626364656667,
         686970,  7172737475767778798081938384,
         858687,  8882909192269495969798999})));
    REQUIRE(!S->contains(Perm(
        {0,  5,  3,  1,  4,  1006,  7,  239,  19111213141516,
         17188,  202122,  4524252627282930313233,
         343536373839,  4041424344104647484950,
         515253545556,  5758596061626364656667,
         686970717273,  7475767778798081822,  84,
         858687888990,  91929394959697989983})));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "022",
                          "perm. Hall-Janko group (alt.) (order 604800)",
                          "[quick][schreier-sims][no-valgrind]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 841;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,   2,   1,   5,   7,   3,   10,  4,   12,  13,  6,   16,  8,   9,
         20,  21,  11,  24,  25,  27,  14,  15,  31,  32,  17,  18,  36,  19,
         38,  39,  41,  22,  23,  45,  46,  48,  26,  51,  28,  29,  55,  30,
         57,  58,  59,  33,  34,  63,  35,  65,  66,  37,  67,  68,  70,  40,
         73,  42,  43,  44,  77,  78,  80,  47,  83,  49,  50,  52,  53,  89,
         54,  91,  72,  56,  92,  93,  95,  60,  61,  99,  62,  10110264,
         10310410610811069,  11371,  74,  75,  11876,  120121,
         12379,  12681,  82,  84,  85,  13286,  13487,  13688,  138,
         13990,  14014114214494,  14796,  97,  15198,  153154,
         100155156158160162105165107168109171111112,
         114115116177117179180119181182184122187124,
         125127128193129195130197131199200133201202,
         135205206137207208210212214143217145146148,
         149223150224186152225226228230192157234159,
         237161240163164166167204203169170172173251,
         174253175255176257258178259260262264266183,
         185188189272190274191276277278194279280196,
         283284198285286288290292294295297250249209,
         302211305213308215216218219314220316221318,
         222320321322323325227328229331231232233235,
         236282281238239241242342243344244345245347,
         246247350248298352353354252355356254359360,
         256361362364366368261371263374265377267268,
         269270382271384385273386387275390391392335,
         395397398400402379287406289291409293412414,
         296407299300301303304358357306307309310422,
         311423312425313427428315429430317433434319,
         435341437439324442326327329330389388332333,
         334450451336417337338454339456340458459460,
         343351461346410462348465349467469396471473,
         420476363365480367483369370372373432431375,
         376378493380495381497498383444443501503504,
         506507393394511470399487401516403404405408,
         411523524413527415530416453418533419535536,
         421538539540424543544426545546548455488513,
         550532509436518438556440441560500445561446,
         447564448449566492567452552489568569457572,
         494573575577578463464581582466583576468586,
         491472590474475594477478479542541481482484,
         485604486606490608512609610611496612613615,
         499502617619505622508510514515571570517519,
         629520529521522632633525526528637638531607,
         639640534641642643537644645647649651602653,
         600656547659549587551553554555557558668559,
         669562672563636674565675676678661681682574,
         685687579580691693620584585588589591592593,
         595596699597701598684599704601706707603709,
         710605711626662703712714697717614616721722,
         618725621623624728625679729627628732650630,
         686631733724735634737635739740742666745646,
         720648749663652751654655727657658660664713,
         665756757667759760700670671762689673763708,
         677680765767683688770690772692774694695776,
         696778779698781782775702783705752784755754,
         715716786718719789723726773730793731795796,
         734798736764738748741801743744803746747750,
         753806758808809761805812813766816768769819,
         771820821777807780814790785802787788822825,
         791792804827794828829797799800810830833811,
         834815817818823832831824826835839837840836,
         838}));
    S->add_generator(Perm(
        {0,   3,   4,   6,   8,   9,   1,   11,  2,   14,  15,  17,  18,  19,
         5,   22,  23,  7,   26,  28,  29,  30,  10,  33,  34,  35,  12,  37,
         13,  40,  42,  43,  44,  16,  47,  49,  50,  52,  53,  54,  20,  56,
         21,  59,  60,  61,  62,  24,  64,  25,  51,  36,  27,  69,  71,  72,
         74,  75,  76,  31,  32,  79,  81,  82,  84,  85,  86,  87,  88,  38,
         90,  39,  73,  55,  41,  94,  96,  97,  98,  45,  10046,  83,  63,
         48,  10510710911111211411511611757,  11958,  122,
         12412512712812913013165,  13366,  13567,  13768,
         11389,  70,  14214314514614814915077,  15278,  126,
         99,  80,  157159161163164166167169170172173174,
         17517691,  92,  17893,  14711895,  183185186188189,
         190191192101194102196103198104165132106203,
         204108171136110209211213215216218219220221,
         222120223121187151123227229231232233235236,
         238239241242243244245134246247248249250138,
         252139254140256141217177144261263265267268,
         269270271153273154275155156234193158281282,
         160240197162287289291293168296298299300301,
         303304306307309310311312313179315180317181,
         319182184323324326327329330332333276334335,
         336195337338339340341199343200295201346202,
         348349205351206207208302251210357358212308,
         255214363365367369370372373375376378379380,
         381224225383226328272228388389230277393394,
         396237399401403404405354407408410411413290,
         344353352297288415416253417418419420421257,
         422258424259426260371314262431432264377318,
         266436438440441386443444325445274446447448,
         449278279452280453430283455284457285286406,
         342350409345292463464294466468470305472474,
         475477478479481482484485486487488316489490,
         491492320494321496322442382499500502331505,
         507508509510512513429514515517518519520521,
         522347525526528529355531356532359534360361,
         537362364541542366483425368547549454398374,
         551552553458554555557558559384385498387562,
         563390565391392567511451395397400570571402,
         493574576578579580523412527465414584585587,
         588589591592593595596597598423599600601602,
         603427605428607433434435437556495439614501,
         560616618620621623624450625626456627628609,
         459630460631461462524634635636467586530469,
         471590533473643594536476646648650480652654,
         655657658660661640662663664665666667497668,
         670671503673504622564506677679680516683684,
         686688689690692674687649694608550695696535,
         697698538700539702540703543705544545708546,
         659604548678639573713715716718719720561723,
         724726582710727566606568569730731572685629,
         575583577734736735581738740741743744746669,
         747748637728750752753676754709755693732610,
         712611612758613615699761721617725672619707,
         651764766768714769632771633773711775638641,
         777642644780645647749701751704653783656675,
         785778787742788722790733791792681794682763,
         797691772774737799800759786802804805760706,
         784807757717782810811729814815817818796798,
         770739801776803779745822823756808821824762,
         826812765816793767830825831832781827789834,
         813806835836795837809833819838840820828839,
         829}));

    REQUIRE(S->size() == 604800);
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "023",
                          "perm. Conway group Co3 (order 495766656000)",
                          "[quick][schreier-sims][no-valgrind]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 277;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,   24542,  11215,  1317,   18875,  13210,  11,  187186,
         26522,  15925643,  1011231344,   32,  20923835,  45,
         2351265,   19,  60,  66,  80,  15425111720671,  11893,
         87,  16727122126118215547,  23017223610919176,
         15673,  11614723,  12723138,  53,  12221024,  68,  86,
         25519613914921,  11120325272,  2621142149,   181,
         17485,  95,  2,   25025724390,  15817014869,  105249,
         26316,  54,  31,  11551,  10412521992,  46,  64,  2048,
         26622534,  17514516118023724122416926912,  96,
         12918919029,  17,  30,  82,  14374,  16813,  22721778,
         25822017822814658,  25427321557,  10677,  11050,
         26,  24826027410799,  25337,  25,  27244,  52,  11918,
         20165,  41,  23310324620010216019820715740,  223,
         49,  26779,  1,   1361246,   61,  26810070,  98,  171121,
         39,  62,  21120884,  13597,  55,  15214163,  14225967,
         33,  17717314,  24294,  11324026415020527,  18383,
         19521616324713336,  153197140194120270165166,
         16221813823481,  91,  89,  18521213748,  202276229,
         15117614419213024423219956,  108184193239213,
         3,   22212820,  28,  16422659,  17927588}));
    S->add_generator(Perm(
        {0,   20420333,  2365,   17277,  76,  47,  146133224229,
         53,  84,  16,  22322813013125219013,  26324210,  32,
         19619965,  24620940,  99,  24119826925175,  118176,
         27118311619723822,  29,  17826,  1741292,   153272,
         25741,  12,  59,  20,  27,  175106159218259137258261,
         16426218945,  17726085,  25,  15,  22696,  24,  1,   274,
         14826413248,  11736,  60,  17120110125395,  120142,
         21316551,  11544,  10316724366,  14110888,  97,  276,
         30,  1392221661732313,   73,  23956,  17082,  162163,
         20714512852,  10490,  21622015574,  23728,  4,   113,
         27323027024818020650,  25078,  12715054,  232217,
         12169,  1566,   12521086,  89,  46,  18421126593,  19,
         13823,  12643,  18810224421919225683,  58,  144181,
         18791,  1582052351471571149,   15257,  39,  64,  143,
         67,  11916187,  20011179,  14,  12321,  14912219161,
         19426622531,  81,  62,  16015111221525423472,  17,
         17910526722718,  16924910920827568,  23316855,
         12480,  24035,  7,   21210024598,  19524710718242,
         18594,  11,  25513515422163,  19313471,  2148,   34,
         70,  20226837,  11038,  13614049,  18692}));

    REQUIRE(S->size() == static_cast<uint64_t>(495766656000));
    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));

    REQUIRE(S->contains(Perm(
        {0,   12314,  40,  1685,   18825,  85,  22,  50,  220179169,
         2,   14816,  17,  18,  10490,  1859,   2292147,   146209,
         67,  87,  21898,  61,  11816535,  16137,  42,  2603,   192,
         38,  91,  17311912419019983,  10,  24452,  203217136,
         15417622459,  13132,  21966,  21011263,  28,  221134,
         21171,  11419725619326424284,  26712026320449,
         78,  8,   21629,  23119820,  43,  11111594,  95,  239270,
         31,  26517416611610319,  21225923010811714292,
         65,  11372,  93,  10210933,  45,  80,  2571261,   46,  184,
         12220612812916760,  16025469,  17755,  196236139,
         14024911024714414926,  18215,  145150153208151,
         56,  26115617216319413236,  23815826634,  101130,
         4,   13,  20718315744,  10021557,  13527412,  180181,
         14717112521,  2332506,   22247,  23241,  75,  159248,
         13773,  89,  48,  20027622653,  82,  25212717015227,
         64,  70,  10524624,  17586,  54,  30,  62,  11,  68,  189223,
         58,  24320222722823,  10788,  191186258275138272,
         16296,  24024177,  22551,  245213143195141187271,
         20525313325574,  12123410639,  15526281,  76,  99,
         16479,  26826997,  251237273178235201})));
    REQUIRE(S->contains(Perm(
        {0,   20548,  70,  19065,  1571722761,   146133162237,
         31,  23616510419,  24637,  17784,  20,  13746,  121234,
         11052,  90,  11513,  19422210,  16989,  10667,  144126,
         20322821132,  10817824718721710326515951,  14,
         19312720614020911411914988,  23,  40,  61,  25895,
         57,  75,  15,  41,  15576,  27254,  11315899,  7,   21617,
         20026426127192,  10017121214117662,  13216379,
         39,  2101521302191881671201501251342,   232260,
         33,  16096,  44,  12,  26911893,  68,  143218131147243,
         19927,  2682071355,   47,  18,  252111235195240189,
         20821,  12222011,  17318059,  25345,  215185123249,
         24129,  25758,  20116,  19223112426738,  16855,  183,
         74,  17010164,  17422514816694,  26627049,  3,   274,
         22,  72,  71,  24522922477,  145128153255214275179,
         26210925663,  24413810785,  97,  25425183,  87,  263,
         25916198,  34,  24,  78,  1054,   80,  66,  230197202181,
         56,  13913628,  24842,  26,  17522143,  35,  19612973,
         2428,   15123981,  60,  15420410222769,  142117198,
         25,  86,  50,  16422336,  27319115623822621311253,
         30,  91,  9,   82,  2331161842506,   186182})));
    REQUIRE(S->contains(Perm(
        {0,   20548,  70,  19065,  1571722761,   146133162237,
         31,  23616510419,  24637,  17784,  20,  13746,  121234,
         11052,  90,  11513,  19422210,  16989,  10667,  144126,
         20322821132,  10817824718721710326515951,  14,
         19312720614020911411914988,  23,  40,  61,  25895,
         57,  75,  15,  41,  15576,  27254,  11315899,  7,   21617,
         20026426127192,  10017121214117662,  13216379,
         39,  2101521302191881671201501251342,   232260,
         33,  16096,  44,  12,  26911893,  68,  143218131147243,
         19927,  2682071355,   47,  18,  252111235195240189,
         20821,  12222011,  17318059,  25345,  215185123249,
         24129,  25758,  20116,  19223112426738,  16855,  183,
         74,  17010164,  17422514816694,  26627049,  3,   274,
         22,  72,  71,  24522922477,  145128153255214275179,
         26210925663,  24413810785,  97,  25425183,  87,  263,
         25916198,  34,  24,  78,  1054,   80,  66,  230197202181,
         56,  13913628,  24842,  26,  17522143,  35,  19612973,
         2428,   15123981,  60,  15420410222769,  142117198,
         25,  86,  50,  16422336,  27319115623822621311253,
         30,  91,  9,   82,  2331161842506,   186182})));
    REQUIRE(!S->contains(Perm(
        {0,   18587,  26622,  30,  1886,   11182,  10,  13,  124136,
         21310099,  13016731,  26974,  15,  60,  67,  162154221,
         27012913110123,  21011426,  22916163,  196180170,
         3,   18,  16427,  10849,  24818215310316564,  230203,
         26014914527332,  18919720610916933,  20968,  95,
         19239,  78,  57,  1348,   55,  15113918434,  242132223,
         20085,  69,  42,  27624491,  24310741,  21586,  125202,
         19315919119,  17517210496,  15015826153,  15275,
         5,   21680,  10258,  37,  40,  16623419565,  20,  187105,
         29,  61,  2681262561,   9,   2282,   20118624724072,
         23220520713325411614459,  94,  73,  21925220411,
         35,  48,  56,  17992,  16,  17611723822627123623743,
         13512293,  19451,  21284,  11525321114227411883,
         47,  22226224517,  12,  7,   12712854,  255263233224,
         71,  23117725917416824976,  11022038,  17819924,
         66,  19824626581,  14822513823910614145,  267181,
         12111327213714325150,  62,  25817124128,  52,  119,
         25,  26421712021490,  25721,  17322715597,  88,  4,
         77,  16014670,  36,  89,  14020815646,  79,  98,  21814,
         11218319012323544,  163147157275250})));
    REQUIRE(!S->contains(Perm(
        {0,   12314,  40,  1682,   18825,  85,  22,  50,  220179169,
         1,   14816,  36,  18,  10490,  1859,   2292147,   146209,
         67,  87,  21898,  61,  11816535,  16137,  42,  26021,  192,
         38,  91,  17311912419019983,  10,  24452,  203217136,
         15417622459,  13132,  21966,  21011263,  28,  221134,
         21171,  11419725619326424284,  26712026320449,
         78,  8,   21629,  23119820,  43,  11111594,  95,  239270,
         31,  26517416611610319,  21225911,  10811714292,
         65,  11372,  93,  10210933,  45,  80,  2571263,   46,  184,
         12220612812916760,  16025469,  17755,  196236139,
         14024911024714414926,  18215,  145150153208151,
         56,  2611561721631941324,   23815826634,  101130,
         10017,  20718315744,  23021557,  13527412,  180181,
         1471711255,   2332506,   22247,  23241,  75,  159248,
         13773,  89,  48,  20027622653,  82,  25212717015227,
         64,  70,  10524624,  17586,  54,  30,  62,  13,  68,  189223,
         58,  24320222722823,  10788,  191186258275138272,
         16296,  24024177,  22551,  245213143195141187271,
         20525313325574,  12123410639,  15526281,  76,  99,
         16479,  26826997,  251237273178235201})));
    REQUIRE(!S->contains(Perm(
        {0,   18587,  26622,  30,  1886,   11182,  10,  100124136,
         21317,  99,  13016731,  26974,  15,  60,  67,  162154221,
         27012913110123,  21011426,  22916163,  196180170,
         1,   18,  16427,  10849,  24818215310316564,  36,  203,
         26014914527332,  18919720610916933,  20968,  95,
         19239,  78,  57,  1348,   55,  15113918434,  242132223,
         20085,  69,  42,  27624491,  24310741,  21586,  125202,
         19315919119,  17517210496,  15015826153,  15275,
         21,  21680,  10258,  37,  40,  16623419565,  20,  187105,
         29,  61,  2681262562,   9,   2285,   20118624724072,
         23220520713325411614459,  94,  73,  2192522044,
         35,  48,  56,  17992,  16,  17611723822627123623743,
         13512293,  19451,  21284,  11525321114227411883,
         47,  22226224523012,  7,   12712854,  255263233224,
         71,  23117725917416824976,  11022038,  17819924,
         66,  19824626581,  14822513823910614145,  267181,
         12111327213714325150,  62,  25817124128,  52,  119,
         25,  26421712021490,  2573,   17322715597,  88,  13,
         77,  16014670,  11,  89,  14020815646,  79,  98,  21814,
         11218319012323544,  163147157275250})));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "024",
                          "perm. Conway group Co3 (alt.) (order 495766656000) ",
                          "[quick][schreier-sims][no-valgrind]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 553;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,   3,   4,   5,   6,   1,   2,   10,  12,  14,  16,  18,  20,  21,
         23,  25,  7,   27,  29,  31,  8,   34,  36,  9,   39,  41,  43,  45,
         47,  11,  50,  52,  54,  56,  13,  59,  61,  63,  64,  66,  67,  15,
         70,  71,  73,  17,  76,  78,  80,  81,  83,  84,  19,  87,  88,  90,
         92,  94,  95,  97,  99,  22,  10210410593,  24,  107109110,
         11226,  11511711912012212428,  12712913011830,
         13213413513732,  13914114333,  14514714915035,
         15215415615515715937,  38,  16240,  165167169121,
         42,  17317417617844,  18018218418546,  186151189,
         18819019248,  49,  19551,  19820020296,  53,  206208,
         20955,  21221421565,  21857,  21958,  13677,  223225,
         60,  22722962,  23223423523623824024124324568,
         22069,  24925025225425625772,  26026226382,  266,
         74,  26775,  11127027227427679,  279281282283285,
         28728829029285,  26886,  29629722230030289,  304,
         17230628630891,  23131231431631731832025898,
         322324325101328100330144331333103336338340,
         106177342344346108348350352353265310355207,
         210357113359114361205363239364116278368301,
         371372373375123376378379126382125384179385,
         387128390392394131142396307399133401403405,
         406217366408255409138248251412140414415197,
         418420170397423424295425146148168246391381,
         380429153430271432434435436158438400440442,
         160269161305444445163446164448450280451386,
         166388319455457171327458460298462175464465,
         466468203343471472473181183201293337326477,
         187478224480482483417191485347487489193221,
         194362491492196493494496233497332199334374,
         501503204504506411507329339211428277213511,
         512419513216515437516427517488226519356345,
         228413230315402490404377521522237453367476,
         433449242244525341474247422518253459528461,
         529383393259261531524467532264534484535475,
         508441273537321398275463370349443351323538,
         539284499311481495289291523395426294470536,
         299505542303447543510421309456452313500416,
         354545520335486533365514530547358360546469,
         502498369454407549389439509550410540544431,
         526551548479552527541}));

    S->add_generator(Perm(
        {0,   2,   1,   4,   3,   7,   8,   9,   11,  13,  15,  17,  19,  5,
         22,  24,  26,  6,   28,  30,  32,  33,  35,  37,  38,  40,  42,  44,
         46,  48,  49,  51,  53,  55,  57,  58,  60,  62,  10,  65,  25,  68,
         69,  54,  72,  74,  75,  77,  79,  12,  82,  31,  85,  86,  43,  89,
         91,  93,  14,  96,  98,  10010110381,  39,  10634,  10816,
         11111311411611818,  12112312512612864,  50,  131,
         45,  13320,  13613821,  14014214467,  14614859,  122,
         15115315523,  127158160152161163164166168170,
         17117227,  17517717984,  18118376,  97,  154187188,
         29,  102191193186194196197199201203204205207,
         95,  21021121392,  21621718290,  22022136,  222224,
         47,  22622823023123311223223723941,  242244246,
         110247248104251253255120258259261117264265,
         147115268269252271273275277278280137279284,
         28652,  289291293135294295129298299301256303,
         30556,  200307309310311313315134312319321270,
         30232361,  32632732915763,  66,  332334335337339,
         28534132034334534726734935129070,  35431771,
         35629735831420836036273,  167344365366367369,
         37010936837422335937778,  38038138319080,  83,
         386388389391393238395375397398400219402404,
         24387,  40737288,  25041035799,  411413384363416,
         41741942142242094,  409414426206218427387105,
         227428225241424431433371176418437429439441,
         346423396443325107430340447445449202350452,
         453260454234456401130139459124461463330306,
         436467469470468119464474173266475333274476,
         272288472479481316141466484477486488399471,
         342490379132478394492495169403498499212500,
         281502348174505487262508318509143510493462,
         149480145514322511276150324287518156263328,
         300483520159390353257519304162457165523178,
         364485524521507408352501526473516482527440,
         214517373530446412184432180533376531229185,
         378240536189215382254435192336406209537361,
         195503198525308438512538529355405455540425,
         535434541245442496494491415532236534544489,
         392235448451546385465331249460458292450444,
         513283515548338282497543296506504550528549,
         547551542545552522539}));

    REQUIRE(S->size() == static_cast<uint64_t>(495766656000));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "025",
                          "perm. Suzuki group (order 448345497600)",
                          "[no-valgrind][quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 1783;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,    926,  1366133616961688610,  14121390374,  17741572,
         158816901127616,  197,  240,  761,  935,  301,  1776107823,
         588,  1388799,  69,   1318839,  438,  517,  151033,   1241611,
         843,  791,  1526162,  1053474,  706,  10121076739,  556,  937,
         296,  1755208,  151,  225,  883,  952,  1405149,  396,  1781949,
         181,  1008152963,   743,  243,  500,  288,  102727,   1579723,
         162211721710117913281377638,  217,  356,  986,  1183519,
         1203377,  241,  294,  14841198717,  630,  311,  481,  125295,
         213,  118,  280,  823,  247,  786,  726,  721,  17501369367,  325,
         334,  238,  573,  427,  1525830,  1278600,  912,  153697,   119,
         828,  122615551550410,  1761148,  522,  928,  1338888,  161,
         797,  107511761769840,  1272869,  1574462,  732,  865,  495,
         1586223,  1590375,  126,  56,   174551,   546,  488,  154,  1108,
         1652443,  105111221732131,  39,   1212609,  192,  333,  1110,
         446,  340,  922,  613,  15141573399,  17751042363,  646,  1339,
         177060,   1262467,  793,  496,  528,  430,  858,  661,  405,  838,
         165,  980,  552,  606,  947,  16,   568,  401,  1468114315891503,
         1044720,  1599123550,   985,  14931378957,  96,   16281089,
         174979,   738,  835,  1634368,  1006145,  160652,   10541242,
         964,  774,  12511661579,  1354341,  1100837,  1610109,  862,
         17,   86,   392,  65,   788,  746,  1545100,  1679735,  11671723,
         523,  163916941605718,  433,  1553815,  1568939,  12891223,
         1061946,  167215351299729,  740,  17521020141811321773,
         887,  329,  429,  702,  98,   15111446619,  898,  518,  801,  369,
         67,   992,  466,  1146960,  318,  87,   156948,   472,  304,  493,
         780,  20,   1116593,  298,  1625944,  307,  545,  1505457,  92,
         10221546768,  14151693543,  293,  625,  492,  142812961292,
         680,  107,  15761542436,  277,  1455744,  1285166,  108,  800,
         1213458,  14411169169,  234,  1356449,  1206113513741248,
         417,  695,  594,  1219395,  16831626159880,   491,  851,  787,
         431,  582,  1671177,  1221758,  917,  106,  221,  287,  11051236,
         1325539,  9,    147,  120085,   1417875,  426,  1346587,  1192,
         813,  802,  14101365550,  1364475,  423,  242,  1692479,  352,
         57,   525,  1580174,  1281199,  110214711189190,  17511190,
         658,  1259124,  411,  129813891582896,  1700348,  1277520,
         731,  982,  1623391,  15781072380,  111,  1085278,  187,  360,
         1077257,  1400967,  328,  101530,   1125979,  1350455,  157,
         11871184168,  694,  654,  343,  1335831,  164310631368442,
         688,  310,  337,  10071396586,  140,  124310911495290,  183,
         1230469,  750,  784,  297,  808,  41,   390,  592,  1344524,  394,
         480,  93,   175713431725961,  1633508,  153,  1040864,  357,
         320,  299,  1011143,  185,  549,  1759155266,   557,  15771268,
         1004642,  11091095487,  620,  510,  1161736,  715,  704,  834,
         971,  31,   285,  83,   419,  1596127,  252,  478,  397,  1250853,
         186,  1113551,  760,  13321779910,  535,  15231469712,  373,
         585,  945,  1607317,  709,  308,  152,  663,  1275497,  388,  530,
         194,  558,  1066969,  46,   501,  553,  1119993,  174011501258,
         873,  1686759,  657,  198,  956,  936,  1720766,  110,  14821649,
         1019859,  1363232,  1018621,  361,  659,  1559540,  461,  382,
         24,   902,  15711462476,  303,  350,  1651675,  1403725,  1048,
         115,  1129927,  106813021156195,  15121608164,  6,    35,
         1098171,  1300107915,   966,  1486283,  509,  581,  754,  1090,
         1566319,  113014561039176291,   108414111009730,  1327,
         1501814,  78,   1765640,  1508505,  643,  924,  1287178,  1297,
         144011641506124610011768448,  655,  842,  567,  408,  583,
         1204189,  1031547,  143014671715890,  1731147417561271,
         16301408881,  596,  153013221584930,  324,  681,  11011466,
         792,  129112051117456,  1123915,  948,  14431669447,  349,
         974,  1283900,  173411121705279,  876,  514,  123742,   1653,
         1670544,  11531025538,  13011321513,  166390,   256,  763,
         205,  103,  172471,   891,  598,  102,  905,  773,  269,  634,  420,
         141,  12281666249,  512,  999,  218,  45,   270,  1464166764,
         331,  809,  245,  112816601706470,  143112171279622,  1662,
         14771516365,  566,  531,  18,   1207719,  1028806,  572,  1406,
         314,  1637122212451094728,  229,  775,  866,  102911851249,
         300,  150212801708471,  962,  101,  359,  244,  973,  131137,
         684,  184,  794,  846,  1052132,  820,  26,   335,  286,  385,  824,
         989,  1445765,  1640473,  745,  135817071587384,  637,  259,
         1449173611571675798,  1379844,  99,   803,  143316111380,
         120,  832,  113,  451,  829,  1037515,  219,  1170236,  191,  29,
         136,  919,  656,  36,   822,  940,  795,  11061058913,  863,  358,
         1617527,  1778149816771729188,  577,  1737959,  239,  850,
         490,  142,  776,  1017904,  138,  925,  14531155564,  972,  379,
         703,  995,  970,  14701404674,  103253,   171317281307276,
         130,  1427667,  724,  1261893,  13331544415,  1414284,  1452,
         698,  997,  589,  1370868,  727,  1632146514441081534,  1227,
         116,  849,  1121690,  1551366,  1103841,  13201730170,  1210,
         644,  870,  1,    602,  128,  1485679,  164811621655934,  19,
         570,  47,   1305261,  845,  109317441293306,  541,  265,  196,
         691,  59,   1303139254,   152211381416569,  212,  1402861,
         292,  485,  785,  1188228,  1458617,  435,  1527555,  878,  516,
         874,  789,  696,  1255156414831533440,  193,  1581421,  1460,
         1082209,  81,   16641211804,  14321005289,  560,  1673877,
         1615901,  1254737,  1375652,  10641196504,  991,  222,  459,
         61,   633,  1438494,  43,   14341014437,  1602867,  580,  576,
         272,  1743312,  12571086711,  120268,   764,  777,  1083662,
         882,  1238103416811036833,  1647628,  489,  1140176,  1420,
         204,  120116091385599,  17631348158,  796,  40,   226,  1540,
         15151627848,  12291631264,  1087453,  10021317554,  1638,
         603,  137112731656425,  17031247133,  44,   432,  22,   615,
         1563909,  984,  1030631,  428,  102410621126215,  623,  464,
         1507941,  772,  507,  14391480612,  1738235,  682,  402,  918,
         1104370,  847,  1680155,  506,  167,  1111700,  529,  13131240,
         302,  687,  1233559,  1163914,  159,  689,  1148439,  108814,
         747,  601,  626,  1195274,  13421435345,  15471312954,  1721,
         104116971193201,  16201319291,  155411241423562,  1450,
         1152710,  1355872,  605,  818,  120916141476511,  932,  1120,
         649,  13141597250,  1391339,  836,  168773,   133411741359,
         134,  1711143675,   11811180118282,   445,  778,  1186444,
         963,  404,  407,  1357383,  1142131511311003138489,   1777,
         376,  1045102684,   660,  686,  344,  762,  13291158923,  988,
         163,  336,  121416031270752,  1674351,  1726364,  770,  263,
         14591437121,  911,  733,  1059468,  1764167811181539207,
         371,  705,  10331447111534,   227,  463,  1442771,  651,  1074,
         347,  779,  526,  230,  94,   1717998,  975,  15181023563,  409,
         1282892,  182,  14221294148716011665503,  15851216671,
         137,  10701636548,  1767418,  114,  753,  782,  400,  1260697,
         1489332,  1409645,  1504262,  1290685,  323,  943,  12641488,
         322,  647,  412,  268,  614,  713,  604,  950,  1337938,  1772886,
         159316411654790,  11371114116511941766106528,   1145,
         920,  714,  677,  17531616372,  1531635,  76,   120813971448,
         532,  894,  1173450,  3,    1304129,  179,  151916421133483,
         477,  1746381,  170110501407441,  145715001401233,  1154,
         342,  1191810,  1175164616501689578,  389,  387,  2,    1538,
         454,  105,  903,  106916951386346,  1000139877,   211,  821,
         827,  176014131383119710471373171225,   413,  8,    1168,
         951,  147815831635460,  133013761520434,  1353958,  597,
         880,  55,   767,  1349673,  1286386,  632,  7,    1382897,  315,
         955,  378,  273,  14191043142112631149169816191685889,
         321,  1497664,  751,  990,  825,  101311341178122510101096,
         648,  338,  1244692,  908,  805,  282,  12391331816,  11511532,
         899,  871,  1558330,  627,  1351965,  1224983,  1490591,  1644,
         741,  907,  683,  665,  200,  537,  879,  403,  17541716669,  1612,
         1160756,  1393173310971537574,  977,  88,   929,  618,  1265,
         12951284146117141704210,  1494465,  15411429855,  1565,
         1352636,  781,  203,  1288309,  650,  1092641,  168232,   281,
         607,  1524172,  1056757,  15171256134013991556953,  536,
         1513112,  38,   968,  162162,   676,  13261451978,  1534267,
         117,  14811367123410551496327,  1629895,  246,  313,  1136,
         16841549123,  916,  499,  258,  1147122,  152115751454584,
         1780165715621080976,  1499624,  1591260,  295,  1748590,
         11,   173,  139,  1557326,  502,  424,  70,   398,  981,  414,  1394,
         678,  1269144,  812,  12,   202,  146,  15671604130816591618,
         521,  1166355,  206,  17191266101612151592255,  224,  542,
         608,  1046237,  826,  147517021159996,  1324852,  15951425,
         1144152872,   422,  1624305,  354,  1057214,  1543672,  1060,
         906,  486,  220,  13951274769,  1067253,  807,  13091341452,
         1463172213601038931,  575,  1361595,  156,  707,  1310933,
         1071156117351594748,  231,  755,  716,  987,  1267734,  742,
         1668693,  708,  362,  266,  994,  1218819,  1782856,  1232248,
         110710351509353,  15481426565,  11715,    136213,   1747,
         393,  316,  254,  13724,    114114241742416,  134716131073,
         1492701,  749,  811,  783,  175874,   11771387884,  1491666,
         1473125317391600571,  11391645251,  722,  484,  12201771,
         885,  857,  921,  668,  160,  1479699,  1658817,  860,  10991718,
         561,  174116991021942,  150,  134516911570216,  104,  406,
         271,  1323147249,   670,  482,  1709498,  1381125,  629,  1049,
         1231639,  13161276653,  135,  180,  17271306275,  10,   175,
         21,   1199854,  533,  156058,   1676}));
    S->add_generator(Perm(
        {0,    28,   33,   42,   49,   51,   17,   59,   14,   70,   73,   81,
         84,   87,   22,   99,   101,  26,   15,   117,  120,  124,  8,    133,
         135,  140,  6,    145,  40,   156,  160,  72,   163,  47,   134,  179,
         3,    186,  188,  192,  1,    57,   36,   4,    210,  213,  137,  2,
         222,  43,   231,  68,   240,  247,  250,  89,   75,   255,  261,  79,
         37,   276,  279,  287,  290,  299,  302,  305,  5,    311,  94,   324,
         97,   98,   333,  331,  340,  342,  347,  7,    62,   108,  359,  361,
         112,  372,  375,  104,  23,   329,  391,  399,  402,  407,  9,    416,
         38,   31,   10,   18,   427,  131,  438,  445,  13,   448,  451,  453,
         11,   462,  465,  468,  12,   304,  481,  486,  377,  150,  498,  500,
         154,  511,  518,  521,  159,  529,  532,  535,  543,  545,  548,  16,
         556,  88,   220,  171,  288,  274,  573,  576,  177,  588,  591,  289,
         597,  184,  609,  616,  415,  623,  19,   632,  608,  638,  20,   647,
         199,  658,  491,  21,   204,  674,  676,  208,  136,  690,  400,  700,
         702,  707,  710,  24,   351,  118,  722,  725,  729,  25,   228,  229,
         430,  745,  748,  752,  27,   759,  60,   182,  96,   774,  596,  779,
         245,  787,  792,  795,  803,  806,  810,  29,   817,  621,  823,  828,
         30,   837,  840,  843,  32,   848,  268,  859,  862,  272,  872,  587,
         882,  141,  449,  612,  34,   785,  285,  896,  422,  708,  280,  904,
         885,  35,   627,  297,  921,  926,  503,  933,  936,  940,  943,  864,
         281,  82,   218,  905,  959,  39,   963,  318,  881,  975,  322,  986,
         506,  991,  238,  41,   1001559,  10101012525,  338,  293,  1029,
         61,   10361038193,  44,   622,  1052105445,   106246,   1065,
         264,  76,   169,  80,   107352,   1042875,  103048,   1083355,
         164,  738,  371,  10931096109911051108105350,   1117382,
         1125605,  386,  1135603,  389,  11431146114710901153397,
         1157717,  571,  11641166117153,   1180561,  102254,   1190,
         414,  1110426,  452,  306,  55,   120456,   1210425,  1218198,
         1221122458,   1228277,  1234436,  12451247719,  1154443,
         421,  515,  851,  883,  12681271797,  63,   505,  215,  1276241,
         1004460,  1281457,  1282670,  203,  352,  455,  138,  129064,
         473,  1301309,  477,  814,  619,  1313485,  1025244,  65,   358,
         1329133366,   798,  133867,   441,  496,  1116671,  861,  107,
         469,  69,   1352437,  857,  1273509,  1047137113721373516,
         138213871144162,  246,  139371,   528,  527,  138413981085,
         1324995,  1086628,  639,  74,   1396541,  723,  982,  912,  1109,
         142414301416139977,   91,   554,  144011681443128678,
         691,  563,  14521215566,  242,  1310570,  1207395,  119,  1464,
         1104804,  553,  624,  83,   546,  583,  14681296586,  12011155,
         574,  147410771476147885,   14821233132786,   558,  1492,
         1148607,  1497917,  15001202614,  1507530,  15121514816,
         15151187625,  821,  90,   1375173,  1519454,  533,  15211123,
         360,  1460878,  1531153492,   1538645,  618,  1150974,  1388,
         93,   1549654,  296,  1552656,  937,  1558600,  1149216,  95,
         148,  665,  773,  1562669,  14961568672,  1537126512661576,
         730,  100,  934,  594,  1581684,  13111072688,  562,  15901469,
         15921445102,  630,  698,  15961481781,  947,  13801601103,
         459,  1222105,  522,  1606405,  106,  13561610369,  111,  1615,
         720,  895,  409,  819,  784,  221,  889,  109,  1256332,  110,  357,
         217,  219,  768,  736,  14271314128,  1098951,  743,  1626756,
         1138251,  1631113,  344,  13281627114,  786,  758,  15041308,
         589,  1013115,  1640765,  898,  993,  116,  860,  999,  1255772,
         564,  1633141711031334617,  1078227,  783,  134013611651,
         1199712,  790,  157216591212133715411170121,  801,  802,
         166514631467119813021261122,  1670123,  1046815,  939,
         1049668,  115814151240125,  575,  11891677126,  836,  1517,
         127,  315,  834,  1434411,  1341362,  1516517,  606,  599,  1381,
         129,  126416891169130,  1690855,  1470298,  901,  1075990,
         641,  994,  132,  1317825,  343,  870,  1694793,  14841693278,
         1088766,  880,  124216991700185,  1546847,  1354408,  1439,
         139,  307,  893,  1397263,  888,  886,  12481448900,  1040664,
         1557497,  1041580,  142,  1707143,  911,  14471114716,  144,
         1711919,  927,  270,  187,  13421102626,  924,  168410941404,
         682,  1582146,  714,  150116741493256,  1718147,  918,  1696,
         12521269653,  308,  149,  488,  949,  539,  800,  12541502955,
         732,  257,  1330151,  735,  581,  152,  267,  16811641153,  1679,
         968,  1035973,  972,  965,  962,  1064112812831284155,  981,
         363,  992,  891,  283,  824,  1005335,  489,  964,  16171232157,
         158,  997,  961,  1423753,  869,  123610061736167,  16921738,
         366,  762,  967,  1632706,  1528161,  1612365,  10191494487,
         102313741733102713001473746,  742,  1034136715511365,
         17491067897,  165,  1425166,  108010451251128810481089,
         11451151844,  16531413495,  168,  174710601032833,  807,
         677,  1142252,  1437170,  1137526,  172,  1364178,  15981654,
         175,  954,  273,  197,  418,  174,  398,  104410811176629,  699,
         176,  13461559388,  631,  1008849,  873,  728,  749,  12291636,
         180,  17231664132215661426709,  181,  1748111516971051,
         183,  11061122846,  1306667,  1339744,  537,  113112381635,
         1002567,  464,  17051140970,  439,  254,  957,  10181113976,
         1715189,  370,  190,  1249303,  582,  191,  15201394796,  381,
         16231613354,  412,  1753958,  12301275194,  123717561175,
         195,  175812721179560,  711,  118115691028196,  1410662,
         740,  703,  601,  15181235275,  114111951420512,  1480348,
         633,  200,  838,  201,  689,  763,  236,  1459504,  1766202,  1524,
         243,  15351213134712161177841,  852,  392,  551,  1709205,
         687,  948,  1385206,  17521495295,  207,  1076724,  1092928,
         907,  1600209,  704,  1057145612431525540,  14611280466,
         577,  211,  17031058212,  1671858,  1629747,  519,  1260513,
         1603265,  403,  914,  214,  1644890,  1639387,  989,  10111303,
         143214011522979,  1498226,  330,  1586980,  1431555,  456,
         1050223,  868,  128713311318224,  1604225,  1444374,  552,
         284,  129411591768129810391550262,  1253867,  1761230,
         1079130715651616102612571395482,  154817751435232,
         1016692,  1223339,  592,  826,  233,  234,  1024132611521070,
         1226930,  1722235,  1683922,  1345953,  310,  248,  524,  1716,
         237,  695,  1556328,  1402239,  721,  771,  1597260,  10551442,
         1390113614411583760,  1350983,  754,  1436916,  12171132,
         673,  1450136317701594102013701369971,  1720508,  1172,
         854,  613,  727,  249,  1378165511601490523,  110012391577,
         420,  929,  139216861455507,  1087253,  1289119115951488,
         15391043379,  686,  1074484,  1751327,  13091706585,  385,
         696,  258,  11121409259,  1726141216731295126716981773,
         14181735799,  1769111917171406902,  376,  145114281642,
         16381561542,  1250731,  1667977,  266,  463,  701,  845,  604,
         117813481186620,  590,  11851483269,  1704431,  1278835,
         271,  770,  142917431391932,  1419336,  367,  1325856,  1376,
         514,  15291725830,  383,  122013551742282,  678,  1465776,
         646,  471,  1422286,  394,  1728950,  884,  433,  446,  291,  1277,
         938,  378,  292,  1646866,  13861593853,  135311731031294,
         161114461605461,  17101297159117721332899,  419,  598,
         634,  1299166114081188769,  300,  1527301,  150514071487,
         14541211423,  174516871542903,  1129996,  876,  909,  1621,
         913,  1554693,  1066952,  813,  312,  404,  894,  1656313,  1258,
         314,  12791545165012631320683,  316,  1291350,  1485906,
         1731317,  644,  1351569,  15441014733,  353,  648,  319,  1009,
         320,  1362718,  842,  1526321,  373,  578,  349,  16821126685,
         323,  1532944,  325,  326,  428,  892,  141111301746410,  960,
         17081165966,  782,  1740447,  429,  435,  334,  108215091734,
         1587751,  337,  538,  805,  1645442,  579,  15841270483,  1120,
         341,  17131292470,  1489879,  1741741,  11821433557,  345,
         942,  346,  865,  390,  863,  458,  1208984,  908,  10611405475,
         12931139131614661563536,  850,  1588356,  734,  956,  1652,
         368,  364,  1192173012441017444,  761,  10631246396,  1567,
         1285550,  16221414697,  478,  1624777,  1658163010071084,
         636,  1068158916881510829,  998,  380,  501,  1111547,  544,
         120511561511572,  1647384,  1343839,  15131479479,  778,
         811,  1543154015231744393,  17771648146216491127492,
         14861097417,  476,  874,  401,  615,  1193413,  871,  11741379,
         1573145716621574490,  1625642,  1508406,  17551620635,
         1214680,  595,  14581669177411341227877,  780,  11841231,
         655,  969,  167510371579925,  1161178116661071568,  602,
         424,  16801200737,  775,  493,  16141602164314991739467,
         432,  1312694,  434,  100311831477593,  1091652,  440,  651,
         1438480,  726,  17791712549,  156417601194450,  1570920,
         142113591503611,  1259818,  1724666,  1685134913681782,
         715,  1506472,  1403474,  643,  1319681,  1225923,  13661571,
         1637494,  15991729739,  831,  822,  147215301765988,  1678,
         144916081321610,  499,  502,  16091547649,  11011672978,
         1304827,  705,  17271315915,  510,  138910591377534,  1780,
         1219520,  1560660,  887,  16681471531,  1274661,  15801695,
         1536170216631163820,  1107119717191767120310001778,
         1121832,  985,  791,  17641133565,  637,  17541206788,  657,
         584,  659,  17621575755,  945,  1585931,  1033126211671021,
         1453910,  176313361305133514001344157816761162640,
         1196935,  650,  161816191383663,  1628808,  17711657757,
         1323675,  13571360679,  1721106915331607101516911701,
         1124812,  713,  1358941,  1737794,  15531056750,  1209764,
         767,  789,  809,  14911776155517141757166011181759946,
         1095987,  17501634124114751732}));

    REQUIRE(S->size() == static_cast<uint64_t>(448345497600));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "026",
                          "perm. Fischer group Fi22 (order 64561751654400)",
                          "[standard][schreier-sims]") {
    auto rg = ReportGuard(REPORT);
    // Slower than GAP
    constexpr size_t N = 3511;
    auto             S = new SchreierSims<N>();
    using Perm         = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,    524,  2,    789,  2130777,  491,  305930962636527,  11,
         822,  301314,   872,  23922504108,  281620,   3295851,  23,
         219615032131228510611382174,  106332,   3057490,  846,
         827,  1494164030252769285842,   1987237,  45,   19623393,
         1038297450,   127252,   3089425,  11091275821,  11212314,
         638,  1900164963,   64,   11321370159068,   2968277571,
         34232393215475,   10703010264279,   21351764463,  83,
         417,  24073424274833771184776,  670,  2072653,  31832690,
         96,   182198,   1427280410282873397,  1196207,  31082619,
         18,   2960110,  111,  24002492245,  2216116,  3015632,  712,
         3451205530362178124,  24183030127,  1453732,  283,  3283,
         273,  2183561,  135,  1936806,  571,  261,  1460669,  142,  1071,
         1431145,  3252785,  11771469327,  11161863308732982215,
         156,  251833891289160,  1967162,  1519164,  3210166,  3135,
         2507169,  323616593403299,  30,   236520823080415,  1790,
         180,  3359302830141876277421511444188,  1633190,  2808,
         132624013308988,  19492261198,  2246200,  2829202,  203,
         204,  421,  3148105,  295814891542211,  814,  116612311334,
         216,  217,  911,  624,  230630551573223,  687,  2649759,  3215,
         2603229,  306,  368,  31952689234,  1245200944,   1777305,
         22603434110132921964114,  20322014918,  249,  474,  1760,
         252,  3119254,  1384304521323022825,  3051139,  1745263,
         32572647266,  1533268,  2849270,  2606866,  132,  13221012,
         18312834694,  279,  29122620689,  130,  30731862286,  848,
         1859289,  290,  291,  32972593294,  20362395339,  1675173,
         31981312334432382660239,  230,  739,  3490530,  952,  1521,
         2880313,  2628905,  35072101318,  16812956193526991491,
         953,  958,  326,  150,  15362723232116712369198621401945,
         21133505556,  297,  13021963160213611386345,  346,  371,
         807,  2842973,  351,  885,  271925611441356,  1984358,  359,
         803,  1403365,  33731424362,  13591508231,  14662382347,
         1566373,  2126375,  299127183035145129201750382,  1554,
         384,  24933040176716921068202115653110393,  31821913,
         1304103,  334011973294251426872836114118282851917,
         1713409,  297327732417611,  1696178,  189084,   19553156,
         1877205,  32401513116254,   426,  427,  289133481232630,
         2979216228172992578,  11313289813,  2397281914722665,
         838,  1108347927443112950,  450,  888,  770,  479,  31812462,
         456,  542,  458,  325330703442313682,   1179122530313127,
         468,  1126783,  471,  2426473,  250,  25602289477,  1150453,
         2006481,  482,  2908484,  1784486,  24452905197134,   6,
         492,  3027494,  33213362709,  116112603438501,  2308503,
         504,  505,  2041324527711813510,  623,  512,  29342825515,
         29312743247311353388521,  2310717,  1,    525,  526,  10,
         1709529,  309,  10133432533,  13463363765,  537,  30162323,
         3081541,  457,  543,  2494292313761761186625082040551,
         1994160931763235338,  886,  318629822625134,  562,  563,
         17071477566,  567,  568,  1147570,  138,  2324245827941406,
         1992577,  436,  579,  2480581,  582,  583,  214634621801587,
         588,  2726225227271230593,  594,  24103415856,  31713456,
         1096755,  313726181817221417352868608,  15491788413,
         228312203376615,  616,  617,  2906747,  3124826,  1010511,
         219,  3023227831391855629,  431,  3293118,  796,  16062052,
         2529233860,   238623021251642,  18233497196634162631,
         157033333190651,  242493,   828,  247815501958658,  3160,
         990,  159528781267793,  18351564667,  3303141,  91,   1423,
         993,  1119275919422350291930461128834,  681,  1358683,
         321833382156224,  2137282,  2758180017722039278,  2481,
         32091861698,  257325572367702,  21992616204519312909,
         1204497,  34272076119,  713,  714,  762,  716,  523,  718,  2864,
         3206721,  722,  891,  293831742056727,  728,  2643730,  1829,
         129,  22111605735,  27853169738,  307,  30092892742,  1787,
         744,  1098746,  619,  32602074301212221909753,  3473601,
         756,  757,  2525226,  32142926715,  13803287536,  1476919,
         768,  889,  452,  26102447773,  2972775,  90,   5,    778,  779,
         1693781,  1325470,  1258147,  2016787,  19443,    11633018,
         2187664,  10452062633,  2528798,  12532372801,  1281360,
         28893422137,  348,  20662213810,  1397931,  439,  212,  1896,
         2706817,  960,  819,  153757,   12,   2870824,  259,  621,  36,
         654,  2584830,  831,  832,  833,  680,  852,  3406837,  444,  839,
         987,  25371341843,  3384268835,   2231287,  1144236422,
         835,  238919223185597,  1183858,  1889860,  339620532844,
         28213097272,  2253212729302205250115,   873,  874,  2702,
         876,  877,  1661237710511978882,  883,  908,  352,  557,  1102,
         451,  769,  3159723,  1879893,  894,  155519211103898,  899,
         15161387162625133301315,  33501187884,  909,  936,  218,
         912,  3021239821241724407,  248,  767,  17162442922,  3410,
         2020274617042093928,  929,  930,  812,  1153168611511138,
         910,  937,  152818653037337833992413944,  122916852818,
         17991324449,  2320310,  324,  954,  309217031878325,  3251,
         818,  961,  962,  1571290022591379967,  291010271408971,
         2035350,  1015190514493113978,  12951425981,  26923044,
         984,  34172133840,  195,  1321660,  18511893672,  11302847,
         996,  16462411315816112585277022753409127320751708,
         14071669622,  1459275,  531,  1014974,  1016101710183177,
         1020142234131246339412011420969,  101,  162331971372,
         34022943103414981568178948,   10393047104110421285,
         1044794,  17002159267810491743880,  1297315732003327,
         2312306210582648342128,   188231,   2102106518581067,
         389,  326376,   143,  11391757208923591076336519532195,
         108010813226266918163098108626142345179232651142,
         1092211524901095600,  1097745,  33662857242,  887,  897,
         1104156229291107445,  55,   155222582422111322842977,
         151,  32791118673,  144558,   2611251928411125469,  2043,
         679,  1129994,  437,  65,   34722371519,  11361689935,  1072,
         2896404,  10912833849,  12472280569,  11481677478,  934,
         1207932,  2299115516741157184620832731498,  424,  790,
         34481165213,  116711681169117011711208181215173420,
         1176148,  2476464,  131923312136857,  89,   12152177907,
         27661189264032163352235315263391104,  399,  22261199,
         2098102520471320708,  1487191211521172253230611328,
         34991213343711853048316821551656613,  2477751,  2434,
         2884465,  279128523330945,  592,  214,  430,  262127333155,
         123616161641282732191898124220291282235,  10231145,
         226233802370641,  1547799,  1437336415092176784,  2326,
         499,  311628503481140225761266663,  3202200329652281,
         51,   1005135056,   16271277131019603072802,  12441283,
         12841043229116391288159,  34933050254312932012979,
         271310521679207132251762340,  2650396,  333413062235,
         3447207312781652301,  1393179713152419276224501180,
         1203989,  274,  1894949,  782,  192,  13991211132919572962,
         20343228215,  285434043466331932911340842,  13422347,
         30062598534,  271231152704127422921916135322872862,
         21892980682,  366,  2536343,  136213633024255934851367,
         2489267966,   13711031141416442182546,  13773100966,
         763,  190629,   3175255,  1385344,  901,  1388138927683132,
         13921313178130051673811,  13981327350326851264361,
         14043114575,  1008970,  1409259514113085302013732387,
         1416141714182166102614211021671,  364,  980,  233499,
         142814291672144,  22471433143427922668125414383502,
         2019355,  14421819187,  1120287914472303976,  2317379,
         2198128,  145414852753145724631011140,  314934581902,
         14643429369,  14671468149,  15561601442,  238815602000,
         766,  565,  2894197014801481302620052809145514861205,
         1488209,  3347323,  2128187137,   14951496330210351499,
         20953213311825,   1504249129591806367,  125633222990,
         1512423,  26801814900,  11741518163,  1574311,  15221995,
         3351289511943082938,  3058177516362815267,  34491535,
         328,  820,  1538283515402918210,  33263487154533431252,
         1887609,  656,  155111101589383,  895,  1470163118521559,
         1474156111051941666,  391,  372,  235110362406648,  963,
         1572222,  1520160826292193336119521596263715822732,
         15841722158615871588155367,   3262165026951594661,
         158018341598274922181471342,  16032957734,  634,  1744,
         1575553,  1610100016122944176516151237258916183304,
         162027723001102916241625902,  12762666203316301557,
         1632189,  18072158153132581702128738,   123816421647,
         13741645997,  1643164862,   159221121311238032802148,
         121934431885171,  1660878,  244628132309195016662781,
         192610092145331,  143013961156298,  1918114929351298,
         1680319,  263826731684946,  933,  23392186113721912787,
         388,  780,  17411695414,  188826841699104619721638956,
         926,  17052617564,  1007528,  285517112266408,  30663099,
         920,  1997327518722984172115851897916,  172517261727,
         1756172932031731273633601892606,  1736173717382945,
         33411694174210501607262,  3288222217483232381,  2729,
         31413128175417551728107317581759251,  547,  13012170,
         81,   16143426387,  3370176934801771692,  177321751530,
         2947238,  217121192304139429281783485,  26631786743,
         610,  1037179,  24671089253317941795179613142555948,
         691,  586,  2921180318041805150716342658306428981811,
         1173509,  151534681084604,  18181443182097,   2233643,
         1824182523432812405,  731,  1830276,  268318331597665,
         270330602234303418402153184225671844184511581847,
         192520251850991,  155818532720628,  219218571066288,
         3095697,  285,  152,  1864939,  548,  18671868275625711493,
         1719226724383450184,  420,  957,  892,  2883192410623126,
         20421658214215481697859,  416,  21631734992,  13231895,
         815,  17231241298861,   2562146319691904975,  13812866,
         2544752,  327728111206395,  278324871352343116762644,
         1920896,  854,  32471881184816682010192830772523706,
         215732732778321,  136,  24443315193919401563675,  2439,
         788,  335,  232532271948196,  16653332157910783408418,
         29331330657,  31111279335646,   341,  244,  1965645,  161,
         196819031479489,  170128562989326619761977881,  2298,
         3331339720281983357,  1985333,  43,   1988198927672107,
         576,  3267552,  152331311717340030881475301725271269,
         31631483480,  20073278236,  1927206112942013247,  3476,
         786,  201720181440924,  390,  256931012255184920262046,
         1982124322902993246,  16291332972,  295,  20372038693,
         550,  506,  188411273459705,  202712023311214432822220,
         635,  862,  2566121,  726,  20573482216923482011795,  2063,
         30333296808,  2067306520692828129992,   1309749,  1006,
         711,  20772078251022062081176,  11592139208527002224,
         25351074231320912381927,  209415002096282612002099,
         2615317,  1064253825522597210619912763220223602111,
         1651336,  2114109321162890338117792645271421222123,
         915,  3140374,  868,  149221294,    26,   257,  986,  213480,
         1182688,  21382084334,  31931886265520491670584,  2147,
         165534742150186,  2914184174,   1218686,  193216351047,
         21602795433,  189126262605141927423076205917631778,
         217221882174177412571186123,  2822256421811375133,
         296921851688792,  21731356219016901856157723571079,
         24,   21971452703,  29812201210922033509870,  20802207,
         340531023191733,  2212809,  605,  155,  115,  246816002219,
         20512936174725512087350611982227222822292639847,
         275518221838130722362797253122392452224124052243,
         22442599199,  14322248224922502863590,  867,  22542024,
         225634111111965,  240,  197,  124822633056294017121873,
         2268259129112271227222732764100323293371626,  2971,
         114612712282612,  111427,   286113543117476,  20301286,
         1351348824883196303833421979115423003084640,  1448,
         17803105220,  3071502,  1664522,  28721056209059,   2654,
         2316145023182319951,  330,  2451539,  572,  194612593063,
         2786227623301181233225791426233524842337637,  1687,
         2340234130791826234410882346134320602349676,  1567,
         235211932354235525632194235810752110337234252363,
         850,  175,  2366701,  2368332,  12501134800,  242323743281,
         2506879,  2378310416532092370,  248523842385639,  1415,
         1473853,  2390269716,   73,   3246296,  3285440,  914,  2399,
         112,  193,  2902246630532242156985,   34572409595,  998,
         3368943,  246425212503412,  125,  13162420242511122373,
         652,  2421472,  247224283325295224603008330012232541,
         243631341874194324402600921,  29221937487,  1662772,
         2454343313182322224024992448293230692457573,  3339,
         24312927455,  145824142832240317912217246924702471,
         2427518,  2474247511781221655,  2479580,  695,  24822670,
         23362383248619152294136810941505113,  385,  544,  2495,
         28872497320724532500871,  3002241617,   30432376168,
         549,  3049207934542512903,  401,  266134912517157,  1123,
         25202415252219303032758,  33552002797,  636,  29852238,
         12091793274720881360841,  210331532540243530291292,
         190825452546254734832549335422232104255325541798,
         2556700,  27841365475,  354,  190123562180271620541843,
         29012022257018702572699,  257425751265316525782333,
         2707258125822602829,  1001258625873143161728462269,
         2592293,  282314102596210513452245244129612583228,
         26042165271,  260726082609771,  11223349261310872100,
         704,  1706603,  107,  281,  1233262234552624560,  21642627,
         314,  15762630647,  26322633323026359,    158116822230,
         1190266778,   729,  191921202646265,  1059225,  13033130,
         28433107231521432656265718082721304,  251526621785,
         2664443,  1628264114361083248328532672168326742978,
         26763248104813691514331332641832169814012686402,
         845,  233,  95,   2691982,  294626941593335323912698322,
         20863395875,  183613492705816,  25803387270927103328,
         134712962121271525652999377,  353,  185426592722329,
         27242725589,  591,  27281751314511601583123427343469,
         1732287134842739331029642167517,  447,  2745925,  2534,
         87,   159933792796310614562760223218693414690,  674,
         27542802131721082274276511881990139040,   1002508,
         1621411,  185,  70,   27762997193427792780166727821914,
         2558736,  23281691278829372790122614352793574,  2161,
         27512237279827993255317327612803100,  280528972807,
         191,  148428101911182716632814153219,   434,  947,  441,
         2820864,  217925942824514,  209712392070201,  28303256,
         24651143277,  1539403,  28373375322028401124349,  2652,
         863,  34862590995,  2848269,  1262406,  1227267113351710,
         1973110041,   28592860228613552251719,  350119072867,
         607,  2963823,  27372311102,  2975287528762877662,  1446,
         312,  28813446188012243221288624962888804,  2117428,
         741,  2893147815251140280618103357964,  256824022996,
         2904488,  618,  2907483,  707,  968,  2270280,  310321523090,
         291629171541677,  380,  18022443545,  29672925761,  2461,
         17821106869,  516,  24551956513,  167822212789724,  3374,
         226534673307103316131739269317762948294932703316,
         2430295329543299320,  1604208,  1506109,  260113312869,
         274112702966292469,   218432342279774,  410,  49,   2874,
         297611152675432,  13572200559,  33831720253029862987,
         189919741511376,  435,  2031299429952903277734392717,
         300016222502328630041395134430072432740,  77,   3011,
         750,  13,   183,  117,  538,  2001791,  32441413913,  258,  625,
         136439,   1482493,  182,  2542126,  466,  252420641839378,
         122,  940,  22963039386,  304130422505983,  256,  678,  1040,
         121625091291260,  305224043054221,  226433,   15297,
         1837121010572327180920681714306730682456460,  2307,
         1280284,  312030752168192932112342177,  540,  15273083,
         230114123086153,  199953,   29153091955,  309331621860,
         8,    865,  1085171513782023220929132379230527522653,
         106,  3164392,  1959448,  977,  14051348126122881502253,
         3074344033063123620,  31251883467,  1753312926511996,
         139131332437167,  462,  602,  3249627,  2125175231422588,
         3144273034643358206,  1461315031543152253931511235,
         419,  1053999,  890,  659,  3161309420043109257731663167,
         1217737,  3390598,  34952801725,  1383554,  101931783345,
         3180454,  394,  94,   3385855,  558,  340731883445650,  2210,
         319221413194232,  22951030300,  31991054320112681730,
         33353205720,  24983208696,  165,  307832121501760,  227,
         11913217684,  124028392885322232233224130010821947,
         1333322926343231174932332970555,  170,  3237303,  3239,
         422,  3241340132433019507,  23941923267731383250959,
         146,  459,  325428002831264,  16373259748,  326115911069,
         268210901975199332683269295032713317193332741718,
         3276191020081117165423752050131,  328423963003764,
         1746438,  34441339243,  631,  400,  21,   2065292,  154,  2955,
         2433904,  1497668,  1619330531222942194,  349627402048,
         331226813314193829513272331813383320495,  15103489,
         332424291543105527113329122819801951649,  13053204,
         33363337685,  2459398,  174022971546302,  317933461490,
         429,  2612906,  15241192269625502526196128993147181,
         17331578496,  535,  12551077109933672412336917682277,
         2361363,  29392838614,  88,   941,  27501249211833822983,
         844,  318433862708520,  158,  31701195339247,   10242701,
         861,  19813398942,  199832421032172,  13362208836,  3187,
         19541004923,  2257341210222757596,  646,  985,  34183419,
         11751060805,  72,   86,   23621766710,  3428146535101917,
         532,  2449241,  343534781214500,  299831213441461,  1657,
         3290318928821308116415341875120,  3452345325112623,
         599,  24081462204434603461585,  34633146346513372941,
         18152735347034711133754,  21493475201534773436446,
         1770126320582548273813662845154422933323308,  2516,
         34921290349431723309644,  349812123500286514391400,
         3504337,  2225316,  350822043430}));

    S->add_generator(Perm(
        {0,    556,  325,  67,   1579391,  26431896243926663145820,
         2475303617352023174134041633363,  3334116324043217,
         230,  225,  33022527111723982936217732332216472,  3428,
         24797,    813,  2321376,  199,  18531621294825101569838,
         2158521,  195,  1768233731181594863,  790,  163128183098,
         712,  21882149254,  2574662,  72,   381,  580,  805,  3380517,
         1640414,  13662998147,  539,  179,  385,  2902181611001951,
         519,  475,  206032643168155134652134537,  314927392029,
         15292494118529752165963,  104913373095248917491428,
         162,  23232701276,  764,  31221459792,  917,  117622982349,
         1298130318702281324429301580701,  2525306822252577,
         12421630681,  10771372770,  1183263,  206320853164724,
         138327403214971,  10292978346,  2347697,  100,  3017612,
         20322529150729561773888,  954,  957,  2091280,  15713496,
         153,  950,  34261706107932293369190,  3381193318811849,
         29352890307623623314283634051032258,  141930972248,
         242718762136598,  272179,   28781355192131911505731,
         2580352,  972,  23943014473,  32862410142328803278348,
         3101924,  21501647196,  10223331418,  779,  245629541394,
         224,  592,  1772149,  471,  3031510,  24361479668,  165,  3431,
         2141341829853459224618302429751,  16481244753,  1230,
         3117379,  28122786847,  109026531265251,  3333274514,
         2539489,  267031341747330541,   3374616,  272012391555,
         123325811878487,  3040333,  450,  467,  1092263916322184,
         327227601657178621181015368,  309,  1364291129662684,
         35,   2449931,  202525202803197,  28102926298711441862,
         809,  2832484,  112826051306465,  982,  219,  157832582901,
         3398139910891894928,  2842268924992830332623951908,
         25631188284329823323198589,   710,  366,  162616963094,
         12962758480,  2516284630,   313211811357406,  14882715,
         179468,   16381374407,  2594207732041590193032432528,
         12512162242631691024166,  1107979,  401,  246634202259,
         894,  181940,   207,  15531644624,  13613282175533752900,
         514,  12342089331528,   3137744,  22182127327715451453,
         2800597,  1543143420812062528,  2775506,  14873373298,
         2537661,  759,  24883127657,  15732957987,  1070193,  2596,
         328,  1132551,  1174703,  1986481,  2864166830562899718,
         21002887245,  174611292609815,  1481647,  118630162920,
         549,  3120325620881471846,  2033221126411599882,  844,
         11611609241916952601428,  27521886317346,   15362202,
         22713065862,  272710821882855,  15282490268666,   520,
         919,  831,  29421663329413931879281528952955370,  990,
         2631570,  500,  311318981651636,  280223341950257,  1760,
         3208113911941759761,  213,  304330352953329110281130,
         188,  2416980,  2546320715,   147029522048201823171057,
         24982433925,  2523672,  1734102324601327267422831386,
         344,  3506171927291702345010073276641,  197415063030,
         585,  1548179519292749334013822505143918652716148,
         999,  329,  497,  245822541381503,  34693152210911091937,
         788,  802,  1263709,  553,  600,  324918132947242215862785,
         22331510165214563355588,  307732122204224026623241,
         457,  1825554,  12721591132527591087212934,   22621291,
         222930132521160018691859821,  3458229,  275616712147,
         13502207183621302869287030841678147225722050659,
         27032583873,  142231872264343210632001772,  541,  606,
         781,  604,  872,  21163339220118803438617,  33951452479,
         125914653254167323561440295112271524155031703111,
         2724903,  109,  3410305428911627969,  857,  18472943654,
         153133271302347323,   373,  220530081135183130441561,
         179724552293994,  2015508,  156623712789136828082557,
         743,  21812894169,  183,  3041783,  817,  31022157906,  2892,
         1119238915763061139,  16843037776,  3146223518722630,
         198171,   322814482984335,  269825341714344933201318,
         2330544,  656,  262019093154287230422968974,  225092,
         20652223290421592006145010371098575,  300333441468,
         305133872772161,  1924118,  272587,   10692567267,  1873,
         3226828,  1041309097,   131322991775260,  2106246,  522,
         316330052669209626903236766,  15111829273823591143,
         1467275,  774,  1277131131712889130529891949318,  3058,
         890,  729,  431,  32511283593,  116520552324198815151681,
         209527071637867,  1756995,  227911201178330917482101,
         230830492011496,  1217829,  2251203021562042441,  2569,
         2076143120922980860,  1400314331313250301,  15221977,
         2289310734562152849,  26042370926,  29651332981,  2179,
         558,  151728591064121,  17932122281715672495464,  117,
         157030253429321,  1964258810762565179626561740762,
         914,  2450235021633248228,  2858945,  650,  694,  2592128,
         912,  1102114212693141607,  2909608,  33282833308878,
         2685123829402175245227082331733,  2501241723912781,
         17922237249333503147707,  251429141834486,  34973492,
         640,  1353176422441213722,  32802228105426631257419,
         18411935249131771762143,  57,   154,  2423254915971261,
         267122653160451,  160131583073320,  456,  268710033466,
         1941395,  1822108634111267953,  138921602369403,  3383,
         929,  20002766311414741855268263,   242086,   962,  868,
         2515161626583481350731123099559,  270,  192,  28293234,
         2937448,  3487177124771712758,  169926342699460,  1140,
         15892480495,  21252916996,  1915986,  527,  30103384172,
         24282632175,  2418269115602912196114302867905,  1343,
         327023132341763,  2069222,  214021872447262,  26162322,
         2917114730151584316219131701106084,   18462387135,
         20443424787,  21172485702,  30481154561,  16551180212,
         27633489704,  932,  609,  1823698,  275724072664728,  2260,
         159819872113302820031942564,  20753480122225,   2268,
         880,  65,   1919145134941266159322883303279329503299,
         2570303,  1953455,  15741346215126242877177019361101,
         157,  20472622176733761653502,  1669247021372028947,
         27772131271,  35053399483,  30963190182026081606185,
         281,  1541840,  324,  1351443,  17791532173229913001708,
         24,   64,   25021160107222263128988,  423,  289,  32131246,
         878,  664,  30602326177629333237321913791608383,  1067,
         2209687,  9,    314,  433,  1656916,  3423103810021397970,
         186313851828218225081198534,  360,  332217002276799,
         23293275208727901339349816432114151,  2052555,  1503,
         10561916216624781088246923013316241,  531,  367,  3401,
         12061,    992,  292911932782232,  130,  8,    2519347155,
         2650132421902778271420411293634,  2688273435081861,
         1493327,  161210312451344031,   653,  584,  167616863115,
         2355645,  2309345515641731231112802801296218381322,
         1983870,  21783400264,  2067778,  504,  651,  209,  3441793,
         1352976,  34162161140331191965871,  1310615,  3437769,
         342,  24212963688,  791,  1934128831092411261420901218,
         752,  174,  1131275533431091171,  1697719,  318330921535,
         242516771408422,  27043150678,  35032277297031421094,
         1946832,  646,  17452668295834453361294,  346812941226,
         1641138,  234014831066294915251808515,  103,  425,  627,
         876,  143727713349104,  22523488775,  24323,    17911463,
         237325452886959,  147774,   14942120101631031464305,
         689,  3495438,  639,  105123382841907,  2788234,  14862078,
         208648,   133,  18093246296,  3224748,  227,  738,  1979392,
         112636,   31892376396,  1093195731331708265134462811,
         818,  2071833,  705,  198,  2804319344,   3439676,  200,  2339,
         34641683543,  663,  22211380509,  18063403622,  105,  540,
         121126592600120820542526548,  26833342159532812927,
         966,  341,  2552936,  30211295691,  1052250,  20141384814,
         144732162016898,  30793257213332901857119012471944,
         28391672269230123341442,  1720602,  305511523351429,
         2976239,  337033971162357,  25712835536,  524,  693,  960,
         3195338529951014816,  237528062465563,  795,  10042903,
         319,  2093315,  566,  777,  274812,   453,  1396463,  16821975,
         180717291134690,  15011750454,  290,  2312187717802342,
         842,  15393345187,  2486985,  13491001328518013451317,
         281934132762190518923346340714893067276523571670,
         155618182316212421732598851,  2021113823271858416,
         843,  1982786,  260614151520735,  314813013034205,  322,
         240,  952,  739,  32883287869,  323,  1629934,  1421201,  1219,
         22961519194,  1084574,  268,  293,  336322,   277321,   412,
         19762167411,  18853414717,  147823612628884,  1484137,
         28272750331,  207227052504347,  767,  726,  111,  27951245,
         421,  3274342133302587951,  1237206829132981848,  3463,
         711,  2058168569,   339,  15491932341717813070350042,
         117027,   17182481241533132706345,  10341763413,  132,
         204016643394201324621997161431061375108031982754,
         2657677,  2145167,  1401466,  196658,   3105398,  27981938,
         2287330428621177348521381320110427442655389,  1508,
         159,  313012233412241422952884388,  220,  468,  28281062,
         1262191423631694599,  2399338,  2195189517133289435,
         232021051654344830321639171110111509545,  13302518,
         2575823,  16,   399,  1412318029932266340220,   10712589,
         16881758261,  2532565,  2200911,  214434621215885,  3477,
         17222629225733,   1254649,  270219961166658,  458,  1241,
         3156307421892831286114042635184,  2183184217381742,
         335921691207244033772718145,  1457529,  297713441476,
         2307557,  2747137731862697255913922665208,  11112192,
         29,   252,  1435765,  3482808,  230414201728516,  353,  2285,
         23523223335323581201346161,   22132774377,  32,   1123,
         1546294417841596856,  955,  1179225847,   1623243,  623,
         755,  23281124426,  247,  33361615268126602536249,  2906,
         1646267814262405287,  940,  32313179918,  579,  369,  644,
         2132273316601018121228571906675,  20041317152,  1158,
         3222113,  22631040601,  1620382,  300933192234365,  633,
         11,   256,  238,  159230623011199312431200271219471821,
         104328601492291,  177711492735444,  28252568302,  1514,
         146219312123686,  866,  1649223820202325304718711925,
         210219433029618,  3175807,  2112498,  1611923,  13901495,
         228414801371156813631628267732602241100532591248,
         2314364,  25541999202621463501102519711537437,  1911,
         393,  893,  218,  32012578713,  2865430,  136,  140724712056,
         105333062343210,  1959157725501150680,  206616611336,
         205927924,    746,  31231387292,  1499336796,   14603491,
         875,  756,  2918896,  2761326813001899195628762302858,
         253383,   31821753259,  13281417317894,   300221033318,
         1766321819,   578,  106,  1897325319261153251732251710,
         538,  17262472118727802807253124971666167523902142,
         282,  16933486417,  91,   2769278310963378128235041019,
         334,  737,  3215217,  248,  2522110513081169660,  989,  1854,
         114,  796,  1727168014443347307,  13142805243512522104,
         299431842560111528242474281314022199380,  3108967,
         278,  21643202302220071075614,  2799942,  14971733108,
         900,  745,  173731811354249612551017277,  155,  11962667,
         1581968,  26272905149131851991170,  3292311,  32381890,
         2402240362,   2064810,  288815133069427,  354,  362,  2743,
         16453422469,  3075333818372111447,  854,  669,  25351315,
         291998,   937,  20083389283,  899,  90,   3396511,  34431835,
         17362551123628962941120217033444176,  1184891,  146,
         1279106828852434523,  10471662186622062468445,  2875,
         3493142728821572272210732584284,  3296804,  21702646,
         12161199825,  378,  20431044319619782821284029972492,
         586,  2675211,  336,  18391225219618913135834,  22613194,
         264914691690222013765,    1845297,  836,  11551010415,
         23543063629,  39,   2483203,  32031006797,  258521391761,
         192212142097552,  133826171810305714752879240053,
         394,  341912242332322125551256329315442543304,  1157,
         99,   811,  32091625494,  273,  60,   535,  3110123216361455,
         126023781583568,  269,  26801604189,  158519633430789,
         191728742694110325473091316514052300984,  983,  2923,
         27361658798,  596,  17851319682,  25131148335717163391,
         695,  101,  265,  33073510569,  226,  14613317135934061962,
         571,  2924887,  11083245432,  51,   20802297861,  12761348,
         1709124,  1802595,  839,  3392238226032,    330,  12282544,
         1429158,  3232163437,   3064314413701500619,  3227125,
         2907964,  2197284521713078127,  13731958145814662027,
         343,  326128202742235,  2612355,  239245,   2599131,  3038,
         2726201928471026103595,   308717881358224528342126,
         1167725,  26372850255328231973181493,   115,  122,  1538,
         246432621482991,  902,  242,  1164819,  439,  749,  16421840,
         3337337925972463611,  2121620,  10781021300,  24541312,
         859,  18031774153311122654589,  22101603279,  27793499,
         23483027346726523435610,  1192938,  1945110,  85,   2119,
         372,  1083434,  20051730374,  1033207017153200409,  841,
         715,  2232732,  165010451940505,  2396144682,   877,  1912,
         225534422816356,  734,  19482253625,  325513622049306,
         247626112290785,  24432174289722433199993,  22032045,
         440,  26473046920,  347415821864227017431046977,  782,
         30193081901,  3300491,  13472278684,  1268107,  879,  1030,
         3151101343,   683,  25242272113730803509185134751843,
         3382244110272979103934571159317212352446181,  1928,
         1050824,  1156248419602856613,  23843279228212641074,
         302312852615436,  19542107628,  864,  23602208182,  1443,
         2217237918443026845,  123,  408,  219122191171939,  2696,
         212821802945997,  2176126,  2227335423832564671,  1765,
         20573329117520511805852,  358,  10851127685,  2388476,
         274,  1333359,  137822942036874,  12872619254125561331,
         73,   1195337,  199226383454299011101850141,  28982377,
         134,  526,  477,  3476233,  2983313,  20981512151829612303,
         546,  105927843033188327132661178938,   11252558140,
         1292299,  850,  23102386853,  23651984119,  120320021220,
         3167178,  567,  3265136713042873998,  224223351055621,
         800,  248229603335201224572711889,  3425169823443155,
         202,  17981804179035022448309319523153175120842751,
         2079236,  299621081619294612213365102,  199831403086,
         24371341273130891118206,  12842215594,  512,  1281482,
         143327643452747,  2185328319073284253,  116,  20391345,
         700,  935,  21862648897,  256254,   530,  2673221216741182,
         269320373472322013652249206131213197114628812695,
         23812710310018891902296922391534160,  34331707386,
         3348921,  19181008259015521454237,  2626461,  754,  2700,
         2500773,  2863306617241972827,  390,  692,  316114131309,
         112,  485,  2315109734273386149849,   1739136919002809,
         347923971081288,  1410626,  243021681289308314113071,
         801,  173,  12502709948,  909,  274176,   1744348432972593,
         452,  16173311329815632922192312712723216,  881,  587,
         34092837142,  27961800958,  178323851990303917,   806,
         462,  136010202412351,  312,  33083470327312092610721,
         1605910,  251221942753822,  308,  723,  32393390361,  3052,
         23511485177,  2292128670,   244218271521251111912928,
         219326361667170414413352279733581665288312581409,
         665,  2247255,  2467716,  181531261833771,  230581,   1967,
         2621727,  1558933,  1887250629591523648,  23931970560,
         30532746292532633478449,  153030063310837,  2854150,
         100928441757240933211114253816132853143834902986,
         943,  946,  1326341511131416973,  2633179924012256590,
         56,   2623384,  3252492,  75,   2024865,  533,  191023362010,
         12401106642,  1136211533251502160715592972750,  214,
         1725130711413192326,  670,  300010,   168,  25822083583,
         3242375,  387,  34343332164,  24591414162417871557191,
         13422999198011162438261314492503235311722586295,
         29321562478,  768,  930,  17693362400,  1253459,  2269696,
         221,  24612224161022752346343615472230101221351297,
         29742372949,  14421122198932952507310,  228626723408,
         27941504581,  228028661432679,  12751496499,  826,  3138,
         14182768326722912770410,  237420342973203577,   2368,
         32402009652,  156,  638,  2453315716352408120512992967,
         883,  730,  18,   340,  2099794,  243110003364830,  956,  518,
         1274290830592053195512312444631,  31292992180,  397,
         12782730223,  26,   2607151612491901736,  152712101856,
         674,  30721995262550,   19202871673,  337125091824470,
         532,  1659404,  34533460886,  187459,   1875233329151542,
         2855405,  238031662155247313233211490,  337233242154,
         298831392591215325612022550,  253088,   15542274576,
         163,  201730181927286830851692196832692849635,  2645,
         286,  28223393285,  316,  741,  296434831058525,  23453004,
         13,   3188266,  27911151186,  308210651826740,  22361884,
         336014732732961,  31253007223113982413326612732364,
         25761133655,  1388757,  965,  2602215,  742,  240627192318,
         17781526488,  254811891832236728141587892,  2644144,
         17052893605,  3368706,  27281622630,  320612903159573,
         199419691329513,  19043116978,  1903908,  133526791145,
         1717922,  20822445780,  209412291540424,  2676760,  1168,
         1099895,  474,  493,  784,  20741565175232051860975,  944,
         835,  20313271131613561811158824872214632,  33882306,
         29342642330129211868282621722566402,  643,  28381754,
         18886,    1173226710482910591,  3312562,  507,  276752,
         18172222139118933045572,  2776714,  1691637,  27873230,
         2540120,  302429381445542,  21481197332,  812,  2424547,
         1939603,  3124350,  33661436142420381321699,  16892319,
         25423050181229711490109520461061129,  32471679244,
         32102579582,  103610421204157527373104420,  25953235,
         501,  18482143317428511270335617211867140613342640,
         577,  20733176904,  1723313622732848915,  21981602666,
         2931927,  231,  2939371,  2110720,  941,  1782161811212852,
         271713951687204,  3020272,  14252366913,  185280,   803,
         26183447349,  2573446,  1340667}));

    REQUIRE(S->size() == static_cast<uint64_t>(64561751654400));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "027",
                          "perm. Held group (order 4030387200)",
                          "[no-valgrind][quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 2059;
    auto             S  = new SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S->add_generator(Perm(
        {0,    374,  708,  1312103611511366130715711402236,  1438,
         363,  590,  288,  137238,   1886816,  195315821109525,  124,
         24,   121826,   1795499,  1574802,  31,   1040117,  164335,
         1344155916,   180,  1183979,  1819152,  44,   11611500332,
         1131946,  159951,   985,  142854,   55,   401,  16611351272,
         692,  120,  154512211211142366,   318,  15361722119,  790,
         407,  2024146,  2045937,  424,  339,  13952056568,  1111444,
         746,  510,  112320581810550,  116,  103,  1009902,  632,  1799,
         1308191010341706693,  101,  922,  91,   104,  571,  2031714,
         144713851977409,  122014561094212,  90,   33,   192270,
         61,   971,  769,  387,  23,   10601057480,  1628398,  130,  1477,
         132611661974127213241295490,  291,  12161389822,  306,
         552,  130174,   19571401149,  1407766,  43,   153,  1000656,
         638,  157,  158,  943,  677,  232,  162,  1031425,  195,  1403285,
         219,  311,  657,  1289852,  1518587,  1159135011801041923,
         39,   13341735399,  127812731498488,  908,  1770537,  1941,
         595,  1404617,  165,  686,  18451924939,  1112706,  579,  1262,
         749,  789,  775,  843,  1826167519001776115,  213,  966,  896,
         167313311437168,  11391472494,  16402008995,  982,  1086,
         1766800,  565,  231,  161,  853,  1551808,  10,   237,  10431240,
         551,  553,  130510691641811,  246,  2051596,  249,  13491408,
         159313801065451,  476,  19151597259,  11131225262,  457,
         709,  554,  15721846447,  17481300614,  59,   890,  11251507,
         276,  167417851609308,  1635607,  815,  1682167,  427,  287,
         14,   20431843139,  756,  810,  1345179415241587911,  1660,
         1358975,  17711368304,  886,  143,  1008280,  705,  1194169,
         1379410,  1269757,  1037145467,   1501702,  859,  731,  1642,
         813,  175210641557373,  778,  527,  539,  47,   165720271237,
         470,  1870161678,   10231178162410141081345,  14201050,
         106316991035654,  406,  1242487,  145020131526700,  976,
         2041404,  199112,   16341669366,  683,  368,  369,  446,  1820,
         2023328,  1,    824,  1999473,  474,  676,  130617741769509,
         171415891595123,  1979840,  412,  19361554393,  15231731,
         695,  1598129,  183,  400,  56,   18671981361,  1443352,  72,
         1662111,  313,  669,  390,  1659912,  415,  416,  11101101534,
         17621441628,  138377,   164,  1778286,  13571003434,  1683,
         989,  485,  430,  888,  18651011849,  19161478906,  20221013,
         83,   1746370,  268,  153415861962255,  452,  199614101566,
         1458263,  174410291012897,  806,  188319551457466,  1836,
         17471779336,  18371839377,  378,  1116256,  477,  20201266,
         127,  481,  187819371603433,  1824354,  187,  1784138,  1756,
         1627759,  222,  11461189667,  185928,   861,  1975660,  503,
         566,  1068128618341644383,  85,   729,  15831448515,  514,
         1920581,  578,  156910731104522,  925,  165322,   881,  330,
         1804190710211633689,  1758419,  872,  1701190,  1973331,
         592,  181611281088622,  11541855580,  1892110389,   240,
         144,  241,  265,  901,  557,  556,  558,  1963972,  629,  10961198,
         1179230,  504,  153281,   981,  1600105,  1995740,  11181321,
         1475776,  518,  202,  547,  517,  17541230904,  684,  600,  174,
         588,  589,  13,   1188540,  1719987,  192,  248,  1939704,  1209,
         586,  1783764,  603,  13151611606,  282,  190517882029611,
         15401390271,  619,  715,  194,  2036615,  1740621,  544,  623,
         1680625,  845,  1235422,  561,  1544159694,   102013032046,
         14671224156,  894,  13641550101612741736919,  15431718,
         648,  133012531002798,  1157351,  658,  155,  170,  655,  707,
         502,  661,  732,  809,  120813471044497,  1849411,  1181671,
         672,  1340851,  1832379,  160,  857,  774,  179710191909367,
         585,  685,  196,  15111913532,  1369156260,   100,  1429396,
         17931455984,  826,  358,  1869320,  1860598,  309,  201,  659,
         2,    264,  109910911811818,  107,  616,  1153187918471292,
         144515091647948,  18091415726,  18131573511,  1434322,
         662,  959,  1048735,  145117281392739,  573,  153111861267,
         1932192684,   11291985204,  139710551333753,  1688755,
         292,  315,  1137493,  864,  190110301238602,  2050151,  1474,
         1945122,  151216511430773,  679,  206,  577,  1652329,  1614,
         910,  1329782,  1923784,  1033786,  1906788,  205,  71,   791,
         114210841986795,  834,  1233652,  1751229,  118230,   1440,
         924,  1460462,  945,  235,  663,  293,  245,  812,  324,  1670283,
         18,   1650713,  1948991,  821,  142,  1414375,  1246699,  1763,
         828,  829,  973,  920,  1169854,  796,  933,  836,  124518951270,
         389,  16641463207,  1689626,  929,  19601537438,  1538674,
         172,  233,  833,  855,  1122678,  1772321,  1254500,  17231298,
         760,  173020301519998,  124918171823535,  873,  14902009,
         882,  934,  132017421409526,  876,  133919651265305,  1418,
         435,  1155273,  18121684893,  639,  1726215,  461,  935,  1281,
         1177555,  93,   903,  584,  1782441,  1854188,  1231780,  298,
         414,  145320521844144611271332645,  831,  1681102,  179,
         804,  523,  18631842928,  846,  157010592001835,  877,  898,
         198076,   1958199,  125710901356159,  1929807,  49,   2034,
         723,  1287950,  13591902204716771071160719041092733,
         14891934988,  2016964,  1089214,  967,  113819191163121,
         560,  830,  1781301,  359,  977,  169641,   1602569,  226,  2042,
         698,  52,   1175594,  962,  432,  2033820,  992,  1825994,  225,
         13601737868,  1115154,  1581651,  429,  1004100510611535,
         307,  92,   2014437,  460,  443,  343,  1713642,  10171051681,
         633,  530,  1285340,  12512003180614061136459,  762,  163,
         1821785,  98,   350,  4,    316,  1579199232,   178,  1695238,
         666,  183013421297734,  1851347,  1018150613941528751,
         1432126,  1687931,  125,  10061712348,  326,  254,  10661067,
         505,  243,  1172955,  1950520,  119612831631142715751911,
         1250344,  17051818793,  1119227,  1590543,  965,  941,  711,
         958,  1093114,  1261562,  18821120710,  2044418,  1102549,
         521,  174116101263127621,   417,  82,   200,  260,  2057999,
         475,  1717574,  108510981124856,  86,   1121274,  1464917,
         542,  747,  162648,   13671725165618761028758,  968,  220,
         11401792792,  165813431508495,  19841439188718285,
         1775716,  545,  889,  1522653,  1555175,  143645,   1621970,
         19931807133,  17091168832,  16541697107013271502986,
         1176900,  341,  564,  177,  670,  801,  40,   17341604742,  1314,
         591,  496,  1484170717682015310,  122910741790563,  1693,
         17731966204812031493120512061341664,  599,  155864,
         1874135419381215140,  121725,   1750112,  63,   18521223,
         637,  261,  1226159420041195583,  909,  1858797,  1258627,
         1236335,  763,  1239239,  1488353,  12431884837,  825,  1749,
         1391869,  108010241252650,  860,  14001517940,  12341759,
         12601095203,  11071319885,  479,  743,  1492314,  839,  1944,
         135,  185,  643,  127511082005184,  15801363899,  19891075,
         18311022506,  949,  1336171,  15771291719,  13991676137,
         14121047863,  1648270,  145,  1462634,  2035242,  380,  7,
         96,   1309131015643,    18031187604,  1373185017961264,
         878,  575,  15921623136,  1724132,  11731838781,  649,  217,
         918,  752,  181,  1335128817031925883,  673,  120710461144,
         36,   294,  1721665,  1361250,  176,  58,   2010190312131617,
         942,  428,  300,  951,  996,  134813841280640,  19946,    1132,
         303,  690,  1370176715,   131616301503139613771619312,
         253,  15461388423,  1362109,  161818291382141,  613,  1248,
         738,  1416105379,   1376750,  200612931255148,  9,    166,
         193,  18881027150,  251,  880,  454,  141112961959823,  725,
         13931868887,  1608346,  1997142265,   1636142519691077,
         53,   694,  772,  188910561893730,  18721160218,  11,   1148,
         803,  421,  1442405,  1576720,  916,  108,  513,  1615355,  736,
         2000913,  317,  697,  113,  465,  456,  1542805,  14661302842,
         112615201461636,  1612197114701764221,  1961767,  576,
         1708131,  440,  197017601481181414831190204914861496,
         1241960,  874,  1491126812041632184814871857186,  2012,
         46,   319,  11741375153315051052275,  1145721,  1983687,
         770,  19081873154819171256173,  867,  146518851156394,
         296,  1525357,  1527105415682055741,  567,  1504448,  1007,
         68,   848,  850,  1930612,  16461459646,  630,  62,   13811553,
         15151668641,  234,  15521547392,  11581556327,  121037,
         17101987691,  179113111565455,  16861529519,  930,  8,
         266,  728,  29,   107814441290170010381279100120,   512,
         16851585449,  297,  1588385,  108720181322252,  1227386,
         631,  258,  397,  50,   570,  2032980,  484,  118517451606956,
         1419279,  1106605,  14681921779,  1449338,  135513861378,
         2002116220071323342,  17321130492,  128,  205313741076,
         1494531,  364,  281,  1424191217331639223,  244,  323,  34,
         508,  16451541722,  12991757817,  771,  777,  524,  11701942,
         1134333,  1143413,  299,  57,   408,  2038841,  176517291667,
         1549365,  814,  20171672216,  277,  209,  1294954,  17611897,
         624,  921,  284,  431,  892,  158415671058754,  844,  18901739,
         1952119918771042978,  11711727349,  1578536,  20251337,
         1949108299,   1191147611671560197810621015384,  1720,
         19431117647,  593,  1715134669,   862,  13251133895,  1698,
         737,  1666865,  395,  162516381184182,  644,  997,  17431691,
         620,  1105879,  1738458,  1605445,  468,  269,  12471219799,
         325,  2028582,  1755491,  1649533,  125914801678420,  827,
         14711665228,  13711192382,  189,  302,  858,  1200381,  1152,
         211,  1833426,  469,  1780974,  905,  601,  489,  278,  17861802,
         609,  2011119715631141696,  295,  27,   1318680,  179895,
         1808195117871313528,  2039102611651800724,  88,   712,
         891,  727,  14821815541,  870,  108342,   371,  10321954871,
         486,  993,  208,  18271150138710451284675,  1777507,  1881,
         467,  471,  1328472,  19681998927,  290,  915,  197,  267,  718,
         1495668,  1317104912221862907,  546,  185614971232498,
         703,  18751853926,  1927436,  2021402,  1417701,  337,  1871,
         143515141212186111351694482,  717,  189818351097463,
         1244152117,   11491405143116901946548,  14331894838,
         1896167918801982210,  761,  952,  1353957,  608,  787,  529,
         1513682,  97,   10791637688,  1914257,  439,  15161918969,
         516,  1613118,  783,  198,  1338745,  18641928944,  15391990,
         744,  1964961,  1935391,  483,  1214597,  1988191,  16551716,
         1271768,  18911972819,  170410721801169219,   1822464,
         1956147,  938,  1413847,  1473450,  559,  1933884,  12011967,
         18401426147914691947538,  134,  501,  2054110,  1711388,
         936,  403,  189915101147748,  794,  1561194012821931362,
         103911641365572,  453,  14211841376,  1452932,  16201025,
         1228127713981622224,  875,  135217891499356,  10101193,
         963,  167115912019478,  1866442,  372,  73,   17022026334,
         1753610,  866,  106,  1601990,  947,  1304618,  203716631805,
         2040360,  983,  289,  110075,   635,  953,  12021485765,  247,
         914,  16291976153080,   111487}));

    S->add_generator(Perm(
        {0,    502,  1182139034,   201518151118395,  1677291,  1453,
         171117371432681,  1600339,  15561001651,  532,  230,  1171,
         226,  1055109913381553191,  1906643,  698,  189,  436,  727,
         717,  1368697,  156059,   160411761662420,  363,  18001164,
         10471921231,  2044184139,   528,  20191480394,  571,  434,
         20401128258,  425,  111014981740892,  1594215,  1392468,
         20011651929,  106,  855,  849,  194714891961114412551201,
         1165888,  10881833771,  1232850,  1419721,  6,    15132012,
         1380757,  13471409265,  861,  846,  143115981321562,  1140,
         10031660705,  1526346,  863,  1454599,  17061297776,  1373,
         960,  1019158315681247992,  138816731832999,  554,  1658,
         334,  920,  1930175011231825637,  726,  682,  234,  11392023,
         1713984,  983,  1886505,  2057412,  1446177,  20371913827,
         485,  379,  331,  145886,   1037793,  287,  1331191411491849,
         164413261316351,  1620269,  642,  222,  1127458,  736,  796,
         1228192220251442135412241163348,  433,  113818541335,
         56,   197,  712,  466,  401,  604,  972,  17161124867,  810,  221,
         277,  1021445,  688,  364,  908,  375,  198512111734790,  145,
         560,  61,   877,  868,  512,  426,  661,  17725,    1299883,  678,
         18011156158019451426308,  349,  2032405,  1680327,  1812,
         989,  695,  1960210,  1393144,  151,  175689,   1805782,  1397,
         283,  211,  16021809438,  161,  501,  1100465,  19,   940,  223,
         887,  1076365,  722,  15324,    748,  15071052212,  60,   1018,
         889,  1046359,  525,  18641314173,  309,  55,   510,  64,   2006,
         201,  136216752000153397,   2033930,  12541757116,  792,
         1577624,  980,  641,  1523170,  966,  655,  20141208911,  324,
         1479123416931529164210201488988,  1610185096,   1586,
         679,  1381129,  662,  171713001767977,  864,  648,  1764787,
         866,  20521994167,  1951187888,   1531437,  1481660,  1719,
         151010481796315,  2003766,  1436117969,   987,  1206675,
         328,  107815921785193610961011928,  917,  199911741685,
         1573558,  175,  875,  107,  19621636486,  805,  164612731525,
         128514631896559,  372,  94,   12741227900,  8,    785,  914,
         761,  101,  1167480,  1315244,  768,  1226279,  22,   1325169,
         625,  352,  12931996517,  853,  191616811933103915891474,
         10731383946,  602,  707,  140619091345730,  452,  1279778,
         14951026114618901016718,  1322652,  36,   90,   209,  1195,
         101518211484811,  936,  1771941,  186,  1923174819671198,
         124610851569408,  1998909,  166418552028589,  673,  1090,
         281,  2020497,  622,  527,  35,   148,  341,  1983842,  12181672,
         820,  10071305193114491537174914551976310,  14022050,
         48,   567,  720,  1363152020,   124814861473136,  696,  594,
         274,  154852,   13011584163,  373,  329,  640,  1708239,  1133,
         10131829128110001710382,  10751501692,  138414251289,
         303,  804,  200910891797108119421625131018391181896,
         1408700,  38,   511,  389,  20421744121211511786353,  733,
         390,  180898,   13891576181616671822350,  1064667,  576,
         15271837107712781282157411701670120515211676852,
         195614401542177615631465813,  561,  317,  202766,   1623,
         784,  1445474,  17521969503,  355,  122,  803,  278,  1701153,
         1851105699,   1698422,  1260374,  522,  13341342388,  423,
         838,  1250266,  13081618204314931095653,  13191550775,
         1443612,  268,  540,  548,  417,  1391461,  70,   15,   666,  552,
         737,  1491955,  16122035131210,   121018941230879,  854,
         115049,   13691413959,  1014159620561547125112091173,
         13671652570,  860,  133714621826263,  333,  823,  1038683,
         1404839,  1333523,  658,  1223816,  781,  15581692947,  257,
         1030577,  791,  1120956,  93,   740,  81,   1104993,  12361044,
         1824126,  225,  756,  2022919,  62,   1153859,  699,  13301633,
         1819459,  1059290,  1606524,  456,  14001736157,  165,  1572,
         397,  102,  63,   618,  1485755,  1973672,  347,  1524245,  1060,
         1712197415641997454,  155,  220,  71,   1554716,  13231733,
         788,  11961901159,  1769489,  20301460416,  168,  1810406,
         181,  537,  1634654,  899,  76,   14481653467,  976,  2045635,
         969,  15121788742,  115,  297,  890,  227,  694,  160519071948,
         1370472,  124,  162616401927392,  1101957,  19171611809,
         25,   16941497619,  134,  858,  1351442,  147811341517750,
         569,  738,  15611420647,  18661054710,  924,  996,  270,  1249,
         149637,   111184,   286,  13061437342,  164118041058381,
         256,  362,  295,  1929817,  106317941022546,  325,  10431217,
         17071459553,  668,  252,  194,  1519638,  693,  19771803610,
         418,  851,  304,  14502016605,  1723165779,   680,  753,  547,
         1659137,  188,  154515881467153015511650739,  1169847,
         14241984255,  1121616,  17281162774,  232,  1847318,  28,
         514,  183,  958,  1029118,  615,  17452047476,  103,  3,    1503,
         419,  12591132247,  288,  332,  156617201500366,  336,  903,
         57,   1755492,  1097905,  926,  13571375184,  107910571966,
         188011431401541,  120018301957451,  873,  731,  15621107,
         687,  764,  429,  1570259,  806,  1193253,  1353250,  961,  415,
         981,  789,  10281470140,  54,   747,  243,  1619758,  12071899,
         17021970124212401214487,  1341170019351597441,  1950,
         176,  484,  130,  321,  1040550,  267,  1069199,  13361082970,
         166,  198287,   106114382031824,  1539586,  991,  11221838,
         1350168719411688837,  587,  197810511853322,  818,  1035,
         583,  1202447,  16431607262,  874,  1621282,  1964219,  725,
         865,  1760224,  1879100211061725109,  1466962,  10911870,
         1565927,  398,  1843160913131943421,  754,  192495,   709,
         190014611405393,  462,  1514734,  504,  152,  296,  12761682,
         711,  147685,   1256202,  1502592,  12311070708,  187711,
         18231614403,  2024685,  1304198,  822,  591,  565,  614,  233,
         965,  12031535719,  200,  1714728,  285,  11751991114,  1791,
         500,  1421520,  963,  14271585613,  10651656100915162054,
         1593190316301355178920482018131,  190,  67,   407,  542,
         187,  14341509893,  116611861852148316391902273,  80,
         154410671988400,  229,  14171187367,  1204323,  596,  1032,
         314,  767,  1915402,  1131534,  10661050154,  356,  280,  477,
         845,  293,  1045198611451552922,  23,   1845404,  912,  1284,
         11421889119,  1414536,  43,   202617541487656,  765,  645,
         158783,   1012455,  187512,   178112901868144111771678,
         431,  124518731946915,  292,  1993471,  1086948,  593,  1940,
         1428646,  1908556,  1158358,  198924,   11841631112,  690,
         1715533,  572,  579,  217,  411,  312,  248,  13391980490,  1937,
         783,  17351008812,  530,  428,  1239598,  836,  913,  629,  1773,
         11131356630,  160,  1221254,  13651429597,  945,  18851189,
         178,  300,  535,  872,  531,  378,  1328659,  155916321378639,
         15811679870,  272,  18181663176382,   677,  862,  20391192,
         178712331747470,  933,  582,  235,  469,  631,  1792147,  1366,
         17391435724,  706,  891,  311,  1802368,  780,  299,  1456228,
         109815901115751,  19551778482,  319,  109311021859240,
         246,  830,  954,  154115281469932,  18061258515,  918,  1511,
         1920800,  330,  669,  825,  1540876,  338,  201058,   1836275,
         148213981965384,  424,  607,  125,  772,  383,  115913851887,
         1746294,  901,  513,  1318623,  242,  986,  921,  103315751452,
         1844674,  544,  1266179313,   1237519,  12711954169731,
         968,  551,  203,  1758498,  448,  1215199519521858117216,
         446,  495,  1332313,  19491418354,  11481298601,  518,  1665,
         2005564,  17771883130311031348934,  743,  807,  13071817,
         545,  162414771092166920361023139,  938,  2007177444,
         937,  13241027200812911415169013822041626,  449,  361,
         127,  1848834,  316,  1302732,  1761188146,   664,  1157573,
         41,   357,  74,   1084670,  18401119994,  18571329971,  770,
         1112621,  1416649,  884,  206,  11681534172116961683113,
         575,  14641807943,  606,  671,  453,  1287463,  773,  414,  50,
         2004978,  12411691302,  16992,    702,  172465,   1925305,
         214,  475,  1616998,  7,    137442,   345,  1349386,  746,  1882,
         1422124418351705665,  2013636,  526,  493,  284,  17031129,
         134620341006326,  14,   432,  144430,   439,  139412291617,
         478,  435,  19181990953,  1191967,  1645271,  13601268142,
         931,  427,  713,  779,  121,  387,  491,  840,  1674189572,   1267,
         16151340574,  1654139691,   112610721518298,  494,  1010,
         1379608,  1579202145,   982,  627,  808,  118312631031885,
         9,    413,  343,  995,  162217381668762,  2046488,  952,  676,
         10531876205,  1295164,  581,  814,  794,  430,  1846172,  1934,
         644,  18721981180,  1904174,  105,  997,  1555218,  1105213,
         869,  1262744,  1938769,  499,  19751972376,  156714331430,
         132,  1504121313711125172612611549185,  16661376595,
         19261197320,  942,  241,  14711557301,  2011115510711280,
         895,  529,  1506251,  1898684,  907,  543,  146817901919657,
         516,  538,  10491704609,  2017620,  15781765763,  14122029,
         752,  1689973,  110,  714,  11351784555,  443,  1130949,  1628,
         557,  1582410,  444,  1439123,  14111387549,  906,  799,  729,
         111,  1490134313581062701,  162,  802,  1036177018651709,
         1732196815951505974,  1813715,  704,  205115221447385,
         192,  632,  13091762165532,   833,  856,  1005910,  12961601,
         1108832,  14101017916,  1094193918711613237,  16481536,
         27,   236,  617,  13951219650,  164911411472440,  798,  1891,
         143,  1892306,  1782749,  1407261,  857,  1992939,  745,  1959,
         68,   141,  1451203826,   117,  1722129475,   19321499369,
         723,  1779578,  168417681423521,  15911216114715151958,
         563,  20531238134420021635207,  1252878,  118818611161,
         377,  1494371,  146,  13171731691,  1831628,  216,  370,  1508,
         826,  1116689,  149,  13611953138,  17801199307,  1753760,
         104,  20491190611,  40,   1320276,  483,  1194135,  18621185,
         18881775133,  703,  460,  871,  12701403585,  391,  1538509,
         47,   1842539,  634,  457,  979,  935,  951,  238,  1399881,  1235,
         479,  835,  797,  496,  843,  16611257821,  844,  150,  11171359,
         925,  600,  1546179513641828663,  51,   116029,   10341327,
         120,  18601742603,  163777,   162716861311178319871971,
         18931004815,  186312531286204,  115253,   127292,   21,
         191112921743335,  11781603337,  1243786,  801,  633,  506,
         1869108016711629777,  741,  686,  882,  171,  580,  208,  950,
         1867126516381729179,  841,  886,  1912588,  1264902,  18,
         1730409,  19281543848,  1799396,  1599735,  481,  128873,
         17662055104212251277107413861352182,  450,  18741372,
         10681154193,  904,  590,  1751894,  18971759819,  128,  923,
         795,  1,    990,  975,  10411608985,  20581083964,  196,  1180,
         1137102419101283195,  1025260,  566,  17271979898,  1475,
         1136360,  15711275264,  340,  508,  1820190578,   19631798,
         18341884399,  1492829,  1109944,  100,  897,  249,  1856289,
         1647108733,   12221811156,  1695380,  18271220828,  17,
         108,  1114473,  568,  1944158,  17411269831,  584,  507,  880,
         344,  1377464,  171814571814759}));

    REQUIRE(S->size() == static_cast<uint64_t>(4030387200));
    delete S;
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "028",
                          "perm. group C2 x C2 x C2 (order 8)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 8;
    using Perm          = libsemigroups::Perm<0, size_t>;
    auto S              = SchreierSims<N, size_t, Perm>();

    S.add_generator(Perm({10234567}));
    S.add_generator(Perm({01324567}));
    S.add_generator(Perm({01234576}));

    REQUIRE(S.size() == 8);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "029",
                          "perm. group C2 x C2 x C2 x C2 (order 16)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 8;
    using Perm          = Perm<>;
    auto S              = SchreierSims<N, Perm::value_type, Perm>();

    S.add_generator(Perm({10234567}));
    S.add_generator(Perm({01324567}));
    S.add_generator(Perm({01235467}));
    S.add_generator(Perm({01234576}));

    REQUIRE(S.size() == 16);

    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(S.generator(2)));
    REQUIRE(S.contains(S.generator(3)));
    REQUIRE(S.contains(Perm({10235467})));
    REQUIRE(S.contains(Perm({01325476})));
    REQUIRE(!S.contains(Perm({67012345})));
    REQUIRE(!S.contains(Perm({41567023})));
    REQUIRE(!S.contains(Perm({64701235})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "030",
                          "perm. group (S5 x S5) : C2 (order 28800)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 10;
    using Perm          = Perm<>;
    auto S              = SchreierSims<N, Perm::value_type, Perm>();

    S.add_generator(Perm({0923456781}));
    S.add_generator(Perm({1234567890}));

    REQUIRE(S.size() == 28800);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "031",
                          "perm. group C3 x D8 x A5 (order 1440)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 12;
    using Perm          = Perm<>;
    auto S              = SchreierSims<N, Perm::value_type, Perm>();

    S.add_generator(Perm({01234567811109}));
    S.add_generator(Perm({01234567981110}));
    S.add_generator(Perm({01234675891011}));
    S.add_generator(Perm({01342567891011}));
    S.add_generator(Perm({02143567891011}));
    S.add_generator(Perm({10243567891011}));

    REQUIRE(S.size() == 1440);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "032",
                          "perm. group GL(4, 3) (order 24261120)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 81;
    auto             S  = SchreierSims<N>();
    using Perm          = std::remove_pointer<decltype(S)>::type::element_type;

    S.add_generator(Perm(
        {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10111213141516,
         1718192021222324252654555657585960,
         6162636465666768697071727374757677,
         7879802728293031323334353637383940,
         41424344454647484950515253}));
    S.add_generator(Perm(
        {0,  6,  3,  1824219,  15125460577278756369,
         6627333045514836423955615873797664,
         70672834314652493743401,  7,  4,  192522,
         1016132935324753503844412,  8,  5,  2026,
         23111714566259748077657168}));

    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(S.generator(1)));

    REQUIRE(S.contains(Perm(
        {0,  65467,  69535,  67482159401954382661,
         42158034137532117327452,  64526,  7150,
         4,  66392358371856442560331779311277,
         29107263471,  70518,  68493,  5741225536,
         2062432478351676301474289})));

    REQUIRE(S.contains(Perm(
        {0,  6,  3,  1824219,  15125460577278756369,
         6627333045514836423955615873797664,
         70672834314652493743401,  7,  4,  192522,
         1016132935324753503844412,  8,  5,  2026,
         23111714566259748077657168})));

    REQUIRE(S.contains(Perm(
        {0,  1326395229785568657561236,  103536,
         4946324258717216203,  5,  151944453174,
         5770678054252,  12284151483438606477,
         9,  228,  7,  1121375033766263697359184,
         1730434753274056667914241})));

    REQUIRE(!S.contains(Perm(
        {0,  1326395229785568657561234,  103536,
         49463242587172167,  3,  5,  151944453174,
         5770678054251,  12284151483438606477,
         9,  638,  221121375033766253697359186,
         1730434720274056667914242})));

    REQUIRE(!S.contains(Perm(
        {0,  295535614,  583,  322079247621501847,
         736712419,  386444701513396836651071,
         164227562,  6222336,  3059802551634877,
         457419265278497523727,  464066145311,
         37174369541,  288,  346031575})));
    REQUIRE(!S.contains(Perm(
        {0,  1326395229785568657561234,  103536,
         4946324258717216633,  5,  151944453174,
         5770678054251,  12284151483438606477,
         9,  208,  53112137503376627,  697359186,
         1730434722274056667914242})));
    REQUIRE(S.size() == 24261120);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "033",
                          "perm. group PSL(3, 7) (order 1876896)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    constexpr size_t N  = 57;
    using Perm          = Perm<>;
    auto S              = new SchreierSims<N, Perm::value_type, Perm>();

    S->add_generator(
        Perm({1,  8,  15222936435012192633404754,
              104552172431381435424956212811,
              5318253239460,  5,  4,  3,  2,  7,  6,  1327,
              34414855209,  374451162330}));
    S->add_generator(
        Perm({0,  1,  3,  4,  5,  6,  7,  2,  8,  149,  10111213,
              434944454647485056515253545515,
              211617181920222823242526272935,
              303132333436423738394041}));

    REQUIRE(S->contains(S->generator(0)));
    REQUIRE(S->contains(S->generator(1)));
    REQUIRE(S->size() == 1876896);

    REQUIRE(S->contains(
        Perm({53510,  545256505537358,  275,  1945,
              1,  3925324611181643414,  12312844,
              2,  33382122133026171436487,  9,  20,
              3,  4724422923104915346,  40})));

    REQUIRE(S->contains(
        Perm({124047192654331,  2,  251555454230,
              4850233518383,  245,  344651362156,
              446,  172939271631534,  2841433220,
              49227,  37528,  14109,  130,  11})));

    REQUIRE(S->contains(
        Perm({375,  45275319358,  36394140380,  42,
              24331814556,  4346155631263,  1312,
              522220497,  3234284750112,  172148,
              1025294,  54519,  3044161,  23})));

    REQUIRE(!S->contains(
        Perm({371,  19358,  45273,  36382,  42394140,
              29554,  433318144653241315563112,
              495,  3252222034110,  172847502126,
              7,  5448102551166,  239,  3044})));

    REQUIRE(!S->contains(
        Perm({8,  1214110,  139,  1040163,  56322,  48,
              473121394,  552319267,  2737453529,
              6,  34445242185428461,  2030383341,
              51174925535,  433624221550})));

    REQUIRE(!S->contains(
        Perm({51374,  1644309,  236,  461221362634,
              8,  29492541331745131,  5340182827,
              15325,  381447245652542,  55501931,
              2248427,  11353,  201039430})));
    delete S;
  }

  // The following are comment out since the "action" struct requires the
  // compiler intrinsic lz_cnt, which we don't currently want to rely on. This
  // is a POC, and works when lz_cnt is available and actually counts leading
  // 0s.

  //     LIBSEMIGROUPS_TEST_CASE("SchreierSims", "034", "BMat8 cyclic group
  //     order 2",
  //               "[quick][schreier-sims]") {
  //       SchreierSims<8, size_t, BMat8> S;
  //       S.add_generator(BMat8({{0, 1, 0, 0, 0, 0, 0, 0},
  //                              {1, 0, 0, 0, 0, 0, 0, 0},
  //                              {0, 0, 1, 0, 0, 0, 0, 0},
  //                              {0, 0, 0, 1, 0, 0, 0, 0},
  //                              {0, 0, 0, 0, 1, 0, 0, 0},
  //                              {0, 0, 0, 0, 0, 1, 0, 0},
  //                              {0, 0, 0, 0, 0, 0, 1, 0},
  //                              {0, 0, 0, 0, 0, 0, 0, 1}}));
  //       REQUIRE(S.size() == 2);
  //     }
  //
  //     LIBSEMIGROUPS_TEST_CASE("SchreierSims", "035", "BMat8 symmetric group
  //     8",
  //               "[quick][schreier-sims]") {
  //       SchreierSims<8, size_t, BMat8> S;
  //       S.add_generator(BMat8({{0, 1, 0, 0, 0, 0, 0, 0},
  //                              {1, 0, 0, 0, 0, 0, 0, 0},
  //                              {0, 0, 1, 0, 0, 0, 0, 0},
  //                              {0, 0, 0, 1, 0, 0, 0, 0},
  //                              {0, 0, 0, 0, 1, 0, 0, 0},
  //                              {0, 0, 0, 0, 0, 1, 0, 0},
  //                              {0, 0, 0, 0, 0, 0, 1, 0},
  //                              {0, 0, 0, 0, 0, 0, 0, 1}}));
  //       S.add_generator(BMat8({{0, 1, 0, 0, 0, 0, 0, 0},
  //                              {0, 0, 1, 0, 0, 0, 0, 0},
  //                              {0, 0, 0, 1, 0, 0, 0, 0},
  //                              {0, 0, 0, 0, 1, 0, 0, 0},
  //                              {0, 0, 0, 0, 0, 1, 0, 0},
  //                              {0, 0, 0, 0, 0, 0, 1, 0},
  //                              {0, 0, 0, 0, 0, 0, 0, 1},
  //                              {1, 0, 0, 0, 0, 0, 0, 0}}));
  //       REQUIRE(S.size() == 40320);
  //     }
  //
  //
  //     LIBSEMIGROUPS_TEST_CASE("SchreierSims", "036", "BMat8 dihedral group
  //     D_16",
  //               "[quick][schreier-sims]") {
  //       SchreierSims<8, size_t, BMat8> S;
  //       S.add_generator(BMat8({{1, 0, 0, 0, 0, 0, 0, 0},
  //                              {0, 0, 0, 0, 0, 0, 0, 1},
  //                              {0, 0, 0, 0, 0, 0, 1, 0},
  //                              {0, 0, 0, 0, 0, 1, 0, 0},
  //                              {0, 0, 0, 0, 1, 0, 0, 0},
  //                              {0, 0, 0, 1, 0, 0, 0, 0},
  //                              {0, 0, 1, 0, 0, 0, 0, 0},
  //                              {0, 1, 0, 0, 0, 0, 0, 0}}));
  //       S.add_generator(BMat8({{0, 1, 0, 0, 0, 0, 0, 0},
  //                              {0, 0, 1, 0, 0, 0, 0, 0},
  //                              {0, 0, 0, 1, 0, 0, 0, 0},
  //                              {0, 0, 0, 0, 1, 0, 0, 0},
  //                              {0, 0, 0, 0, 0, 1, 0, 0},
  //                              {0, 0, 0, 0, 0, 0, 1, 0},
  //                              {0, 0, 0, 0, 0, 0, 0, 1},
  //                              {1, 0, 0, 0, 0, 0, 0, 0}}));
  //       REQUIRE(S.size() == 16);
  //     }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "037",
                          "symmetric perm. group (degree 5)",
                          "[quick][schreier-sims]") {
    auto rg    = ReportGuard(REPORT);
    using Perm = Perm<>;
    SchreierSims<5, Perm::value_type, Perm> S;
    S.add_generator(Perm({12340}));
    S.add_generator(Perm({10234}));
    REQUIRE(S.size() == static_cast<uint64_t>(120));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "038",
                          "alternating perm. group (degree 17)",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<17> S;
    S.clear();
    using Perm = SchreierSims<17>::element_type;
    REQUIRE(S.size() == 1);
    S.add_generator(
        Perm({123456789101112131415160}));
    S.add_generator(
        Perm({012345678910111213151614}));
    REQUIRE(S.size() == static_cast<uint64_t>(177843714048000));
    REQUIRE(S.base(0) == 0);
    REQUIRE(S.contains(
        Perm({123456789101112131415160})));
    REQUIRE(!S.contains(
        Perm({102345678910111213141516})));
    REQUIRE(S.contains(
        Perm({103245678910111213141516})));

    S.clear();
    REQUIRE(S.size() == 1);
    S.add_generator(
        Perm({123456789101112131415160}));
    S.add_generator(
        Perm({012345678910111213151614}));

    S.clear();
    REQUIRE_THROWS_AS(S.base(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.add_base_point(17), LibsemigroupsException);
    S.add_base_point(14);
    S.add_base_point(15);
    S.add_generator(
        Perm({123456789101112131415160}));
    S.add_base_point(1);
    S.add_base_point(3);
    S.add_generator(
        Perm({012345678910111213151614}));
    REQUIRE(S.base_size() == 4);
    REQUIRE(S.size() == static_cast<uint64_t>(177843714048000));
    REQUIRE(S.base(0) == 14);
    REQUIRE(S.base(1) == 15);
    REQUIRE(S.base(2) == 1);
    REQUIRE(S.base(3) == 3);
    REQUIRE(S.base_size() == 15);
    REQUIRE_THROWS_AS(S.add_base_point(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.base(15), LibsemigroupsException);
    REQUIRE(S.contains(
        Perm({123456789101112131415160})));
    REQUIRE(!S.contains(
        Perm({102345678910111213141516})));
    REQUIRE(S.contains(
        Perm({103245678910111213141516})));
    REQUIRE_THROWS_AS(S.add_base_point(1), LibsemigroupsException);

    S.clear();
    S.add_generator(
        Perm({123456789101112131415160}));
    REQUIRE(S.size() == 17);
    S.add_generator(
        Perm({012345678910111213151614}));
    REQUIRE(S.size() == static_cast<uint64_t>(177843714048000));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "039",
                          "exceptions",
                          "[quick][schreier-sims]") {
    auto rg    = ReportGuard(REPORT);
    using Perm = Perm<>;
    SchreierSims<5, Perm::value_type, Perm> S;
    S.add_generator(Perm({12340}));
    S.add_generator(Perm({10234}));
    REQUIRE(S.size() == static_cast<uint64_t>(120));
    REQUIRE_THROWS_AS(S.add_generator(Perm({012})), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.add_generator(Perm({230146})),
                      LibsemigroupsException);

    REQUIRE_THROWS_AS(S.generator(10), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.generator(2), LibsemigroupsException);
    REQUIRE_NOTHROW(S.generator(0));
    REQUIRE_NOTHROW(S.generator(1));

    REQUIRE_THROWS_AS(S.sift(Perm({230146})), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.sift(Perm({201})), LibsemigroupsException);
    REQUIRE_NOTHROW(S.sift(S.generator(1)));

    REQUIRE(S.contains(S.generator(1)));
    REQUIRE(S.contains(S.generator(0)));
    REQUIRE(S.contains(Perm({03142})));
    REQUIRE(!S.contains(Perm({230146})));
    REQUIRE(!S.contains(Perm({201})));
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "040",
                          "exceptions",
                          "[quick][schreier-sims]") {
    auto rg    = ReportGuard(REPORT);
    using Perm = Perm<>;
    SchreierSims<5, Perm::value_type, Perm> S;
    S.add_generator(Perm({12340}));
    S.add_generator(Perm({10234}));
    REQUIRE_THROWS_AS(S.add_base_point(0), LibsemigroupsException);
    for (size_t i = 1; i < 5; ++i) {
      REQUIRE_NOTHROW(S.add_base_point(i));
    }
    REQUIRE_THROWS_AS(S.add_base_point(5), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.add_base_point(100), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "041",
                          "trivial group",
                          "[quick][schreier-sims]") {
    auto            rg = ReportGuard(REPORT);
    SchreierSims<5> S;
    using Perm = typename decltype(S)::element_type;
    S.add_generator(Perm({12340}));
    S.add_generator(Perm({10234}));
    REQUIRE_THROWS_AS(S.add_base_point(0), LibsemigroupsException);
    for (size_t i = 1; i < 5; ++i) {
      REQUIRE_NOTHROW(S.add_base_point(i));
    }
    REQUIRE_THROWS_AS(S.add_base_point(6), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "042",
                          "A17 bug",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<17> S, T;
    using Perm = SchreierSims<17>::element_type;
    S.add_generator(
        Perm({012416567891011121314153}));
    S.add_generator(
        Perm({012351667891011121314154}));
    S.add_generator(
        Perm({012346167891011121314155}));
    S.add_generator(
        Perm({012345716891011121314156}));
    S.add_generator(
        Perm({012345681691011121314157}));
    S.add_generator(
        Perm({012345679161011121314158}));
    S.add_generator(
        Perm({012345678101611121314159}));
    S.add_generator(
        Perm({012345678911161213141510}));
    S.add_generator(
        Perm({012345678910121613141511}));
    S.add_generator(
        Perm({012345678910111316141512}));
    S.add_generator(
        Perm({012345678910111214161513}));
    S.add_generator(
        Perm({011434567891011121316152}));
    S.add_generator(
        Perm({012345678910111213161415}));
    S.add_generator(
        Perm({015234567891011121314161}));
    S.add_generator(
        Perm({151234567891011121314160}));

    T.add_generator(
        Perm({123456789101112131415160}));
    T.add_generator(
        Perm({012345678910111213151614}));

    for (size_t i = 0; i < S.number_of_generators(); ++i) {
      REQUIRE(T.contains(S.generator(i)));
    }
    for (size_t i = 0; i < T.number_of_generators(); ++i) {
      REQUIRE(S.contains(T.generator(i)));
    }

    REQUIRE(T.size() == 177843714048000);
    REQUIRE(S.size() == 177843714048000);
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "043",
                          "orbits_lookup test",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<64> S, T;
    using Perm = typename decltype(S)::element_type;
    S.add_base_point(0);
    S.add_base_point(1);
    S.add_base_point(2);
    S.add_generator(
        Perm({0,  2,  5957161843413638312952541513,
              8,  105149242635334446232160627,  5,
              323427254850119,  4,  6,  636120224745,
              4042191756583,  1,  1214555328303937}));
    S.add_generator(
        Perm({0,  4051271,  4150262,  4249253,  434824,
              4,  4455315,  4554306,  4653297,  475228,
              16563511175734101858339,  1959328,
              20603915216138142262371323633612}));
    S.add_generator(
        Perm({1,  0,  3,  2,  5,  4,  7,  6,  9,  8,  111013121514,
              17161918212023222524272629283130,
              33323534373639384140434245444746,
              49485150535255545756595861606362}));
    S.run();

    detail::Array2<bool64> orbits_lookup_test;
    orbits_lookup_test[0]
        = {truetruetruetruetruetruetruetruetruetruetrue,
           truetruetruetruetruetruetruetruetruetruetrue,
           truetruetruetruetruetruetruetruetruetruetrue,
           truetruetruetruetruetruetruetruetruetruetrue,
           truetruetruetruetruetruetruetruetruetruetrue,
           truetruetruetruetruetruetruetruetrue};
    orbits_lookup_test[1]
        = {falsetruetruetruetruetruetruetruetruetruetrue,
           true,  truetruetruetruetruetruetruetruetruetrue,
           true,  truetruetruetruetruetruetruetruetruetrue,
           true,  truetruetruetruetruetruetruetruetruetrue,
           true,  truetruetruetruetruetruetruetruetruetrue,
           true,  truetruetruetruetruetruetruetrue};
    orbits_lookup_test[2]
        = {falsefalsetrue,  falsefalsefalsefalsefalsefalsefalse,
           falsetrue,  falsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsetrue,  falsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsetrue,  falsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsetrue,  falsefalsefalse,
           true,  falsefalsefalse};
    REQUIRE_THROWS_AS(S.orbits_lookup(30), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.orbits_lookup(40), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.orbits_lookup(064), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.orbits_lookup(065), LibsemigroupsException);
    for (size_t i = 0; i < 3; ++i) {
      for (size_t j = 0; j < 64; ++j) {
        REQUIRE(S.orbits_lookup(i, j) == orbits_lookup_test[i][j]);
      }
    }

    T.add_base_point(0);
    T.add_base_point(1);
    T.add_base_point(4);
    T.add_generator(
        Perm({0,  305,  27415544502,  287,  2543534648,
              4,  261,  31455140546,  243,  2947494252,
              16142111573960341812239,  59376232,
              2010171561355638228,  191363335836}));
    T.add_generator(
        Perm({0,  104737556124181,  11463654602519,
              3242155,  232956503343144,  22285751,
              8,  2,  3945635316269,  3,  384462521727,
              40347,  133121485841356,  1230204959}));
    T.add_generator(
        Perm({1,  0,  3,  2,  5,  4,  7,  6,  9,  8,  111013121514,
              17161918212023222524272629283130,
              33323534373639384140434245444746,
              49485150535255545756595861606362}));
    T.run();

    orbits_lookup_test[2]
        = {falsefalsefalsefalsetrue,  true,  true,  true,  true,  true,
           true,  true,  falsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalsefalsefalsefalsefalsefalsefalse,
           falsefalsefalsefalse};
    REQUIRE_THROWS_AS(T.orbits_lookup(30), LibsemigroupsException);
    REQUIRE_THROWS_AS(T.orbits_lookup(40), LibsemigroupsException);
    REQUIRE_THROWS_AS(T.orbits_lookup(064), LibsemigroupsException);
    REQUIRE_THROWS_AS(T.orbits_lookup(065), LibsemigroupsException);
    for (size_t i = 0; i < 3; ++i) {
      for (size_t j = 0; j < 64; ++j) {
        REQUIRE(T.orbits_lookup(i, j) == orbits_lookup_test[i][j]);
      }
    }
  }

  LIBSEMIGROUPS_TEST_CASE("SchreierSims",
                          "044",
                          "transversal_element and inversal_element test",
                          "[quick][schreier-sims]") {
    auto             rg = ReportGuard(REPORT);
    SchreierSims<64> S;
    using Perm   = typename decltype(S)::element_type;
    using Action = typename decltype(S)::Action;

    S.add_base_point(0);
    S.add_base_point(1);
    S.add_base_point(2);
    S.add_generator(
        Perm({0,  2,  5957161843413638312952541513,
              8,  105149242635334446232160627,  5,
              323427254850119,  4,  6,  636120224745,
              4042191756583,  1,  1214555328303937}));
    S.add_generator(
        Perm({0,  4051271,  4150262,  4249253,  434824,
              4,  4455315,  4554306,  4653297,  475228,
              16563511175734101858339,  1959328,
              20603915216138142262371323633612}));
    S.add_generator(
        Perm({1,  0,  3,  2,  5,  4,  7,  6,  9,  8,  111013121514,
              17161918212023222524272629283130,
              33323534373639384140434245444746,
              49485150535255545756595861606362}));
    S.run();

    REQUIRE_THROWS_AS(S.transversal_element(30), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.transversal_element(40), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.transversal_element(064), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.transversal_element(065), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.inversal_element(30), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.inversal_element(40), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.inversal_element(064), LibsemigroupsException);
    REQUIRE_THROWS_AS(S.inversal_element(065), LibsemigroupsException);
    for (size_t i = 0; i < 3; ++i) {
      for (size_t j = 0; j < 64; ++j) {
        if (S.orbits_lookup(i, j)) {
          REQUIRE(Action()(S.base(i), S.transversal_element(i, j)) == j);
          REQUIRE(Action()(j, S.inversal_element(i, j)) == S.base(i));
        } else {
          REQUIRE_THROWS_AS(S.transversal_element(i, j),
                            LibsemigroupsException);
          REQUIRE_THROWS_AS(S.inversal_element(i, j), LibsemigroupsException);
        }
      }
    }
  }

}  // namespace libsemigroups

Messung V0.5 in Prozent
C=73 H=90 G=81

¤ Dauer der Verarbeitung: 0.305 Sekunden  (vorverarbeitet am  2026-06-17) ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.






                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik