Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - modules - galois.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 19222-cc5b867) Lines: 1456 1517 96.0 %
Date: 2016-07-28 07:10:28 Functions: 63 65 96.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Copyright (C) 2000  The PARI group.
       2             : 
       3             : This file is part of the PARI/GP package.
       4             : 
       5             : PARI/GP is free software; you can redistribute it and/or modify it under the
       6             : terms of the GNU General Public License as published by the Free Software
       7             : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
       8             : ANY WARRANTY WHATSOEVER.
       9             : 
      10             : Check the License for details. You should have received a copy of it, along
      11             : with the package; see the file 'COPYING'. If not, write to the Free Software
      12             : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      13             : 
      14             : /**************************************************************/
      15             : /*                                                            */
      16             : /*    Galois group for degree between 8 and 11 (included)     */
      17             : /*                                                            */
      18             : /**************************************************************/
      19             : #include "pari.h"
      20             : #include "paripriv.h"
      21             : 
      22             : #define NMAX 11 /* maximum degree */
      23             : 
      24             : typedef GEN PERM;
      25             : typedef PERM *GROUP;
      26             : typedef struct {
      27             :   PERM *a;
      28             :   long nm, nv;
      29             : } resolv; /* resolvent */
      30             : 
      31             : typedef struct {
      32             :   long pr, prmax, N;
      33             :   GEN p, r, coef;
      34             : } buildroot;
      35             : 
      36             : static long isin_G_H(buildroot *BR, long n1, long n2);
      37             : 
      38             : static long *par_vec;
      39             : /* k-1 entries filled so far
      40             :  * m = maximal allowed value, n = sum to reach with remaining elements */
      41             : static void
      42      186305 : do_par(GEN T, long k, long n, long m)
      43             : {
      44             :   long i;
      45      186305 :   if (n <= 0)
      46             :   {
      47       57974 :     GEN t = cgetg(k, t_VECSMALL);
      48       57974 :     for (i=1; i<k; i++) t[i] = par_vec[i];
      49      244279 :     gel(T, ++T[0]) = t; return;
      50             :   }
      51      128331 :   if (n < m) m = n;
      52      128331 :   for (i=1; i<=m; i++) { par_vec[k] = i; do_par(T, k+1, n-i, i); }
      53             : }
      54             : 
      55             : /* compute the partitions of n, as decreasing t_VECSMALLs */
      56             : static GEN
      57        1883 : partitions_galois(long n)
      58             : {
      59             :   pari_sp av;
      60             :   long i, p;
      61             :   GEN T;
      62             : 
      63        1883 :   switch(n) /* optimized for galoismoduloX ... */
      64             :   {
      65         770 :     case 8: p = 22; break;
      66         476 :     case 9: p = 30; break;
      67         637 :     case 10:p = 42; break;
      68             :     default:
      69           0 :       if (n < 0) pari_err_TYPE("partitions_galois", stoi(n));
      70           0 :       av = avma; p = itos( numbpart(stoi(n)) ); avma = av; break;
      71             :   }
      72        1883 :   T = new_chunk(p + 1); T[0] = 0;
      73        1883 :   par_vec = cgetg(n+1, t_VECSMALL); /* not Garbage Collected later */
      74        1883 :   do_par(T,1,n,n);
      75        1883 :   if (DEBUGLEVEL > 7)
      76             :   {
      77           0 :     err_printf("Partitions of %ld (%ld)\n",n, p);
      78           0 :     for (i=1; i<=p; i++) err_printf("i = %ld: %Ps\n",i,gel(T,i));
      79             :   }
      80        1883 :   T[0] = evallg(p + 1) | evaltyp(t_VEC); return T;
      81             : }
      82             : 
      83             : /* affect to the permutation x the N arguments that follow */
      84             : static void
      85        3052 : _aff(long N, PERM x,...)
      86             : {
      87             :   va_list args; long i;
      88        3052 :   va_start(args,x); for (i=1; i<=N; i++) x[i] = va_arg(args,int);
      89        3052 :   va_end(args);
      90        3052 : }
      91             : 
      92             : /* return an array of length |len| from the arguments (for galoismodulo) */
      93             : static GEN
      94       80220 : _gr(long len,...)
      95             : {
      96             :   va_list args;
      97       80220 :   long i, l = labs(len);
      98       80220 :   GEN x = new_chunk(l+1);
      99             : 
     100       80220 :   va_start(args,len); x[0] = len;
     101       80220 :   for (i=1; i<=l; i++) x[i] = va_arg(args,int);
     102       80220 :   va_end(args); return x;
     103             : }
     104             : 
     105             : /* return a VECSMALL of length l from the arguments (for galoismodulo11) */
     106             : static GEN
     107         805 : _typ(long l,...)
     108             : {
     109             :   va_list args;
     110             :   long i;
     111         805 :   GEN x = cgetg(l+1, t_VECSMALL);
     112             : 
     113         805 :   va_start(args,l);
     114         805 :   for (i=1; i<=l; i++) x[i] = va_arg(args,int);
     115         805 :   va_end(args); return x;
     116             : }
     117             : 
     118             : /* create a permutation with the N arguments of the function */
     119             : static PERM
     120        1491 : _cr(long N, long a,...)
     121             : {
     122             :   static long x[NMAX+1];
     123             :   va_list args;
     124             :   long i;
     125             : 
     126        1491 :   va_start(args, a); x[0] = N; x[1] = a;
     127        1491 :   for (i=2; i<=N; i++) x[i] = va_arg(args,int);
     128        1491 :   va_end(args); return x;
     129             : }
     130             : 
     131             : static PERM
     132       11914 : permmul(PERM s1, PERM s2)
     133             : {
     134       11914 :   long i, n1 = s1[0];
     135       11914 :   PERM s3 = (PERM)stack_malloc((n1+1) * sizeof(long));
     136       11914 :   for (i=1; i<=n1; i++) s3[i] = s1[s2[i]];
     137       11914 :   s3[0] = n1; return s3;
     138             : }
     139             : 
     140             : static void
     141           0 : printperm(PERM perm)
     142             : {
     143           0 :   long i, n = perm[0];
     144           0 :   err_printf("(");
     145           0 :   for (i=1; i<=n; i++) err_printf(" %d",perm[i]);
     146           0 :   err_printf(" )\n");
     147           0 : }
     148             : 
     149             : static int
     150      222838 : raye(long *g, long num)
     151             : {
     152      222838 :   long i, nb = labs(g[0]);
     153     1574552 :   for (i=1; i<=nb; i++)
     154     1545880 :     if (g[i] == num) return 0;
     155       28672 :   return 1;
     156             : }
     157             : 
     158             : /* we can never determine the group completely in there */
     159             : static long
     160        1050 : rayergroup11(long EVEN, long num, long *gr)
     161             : {
     162        1050 :   long r = 0;
     163             : 
     164        1050 :   if (EVEN)
     165         658 :     switch(num)
     166             :     {
     167             :       case 2: case 5:
     168          49 :         if (gr[3]) { gr[3]=0; r++; }
     169             :       case 3: case 6: case 7:
     170          91 :         if (gr[2]) { gr[2]=0; r++; }
     171             :       case 4:
     172         378 :         if (gr[1]) { gr[1]=0; r++; }
     173             :     }
     174             :   else
     175         392 :     switch(num)
     176             :     {
     177             :       case 2: case 3:
     178         203 :         if (gr[1]) { gr[1]=0; r++; }
     179             :     }
     180        1050 :   return r;
     181             : }
     182             : 
     183             : static long
     184       21014 : rayergroup(long EVEN, long **GR, long num, long *gr)
     185             : {
     186             :   long i,nbgr,r;
     187             : 
     188       21014 :   if (!GR) return rayergroup11(EVEN,num,gr);
     189       19964 :   nbgr = lg(GR); r = 0 ;
     190       19964 :   if (EVEN)
     191             :   {
     192      374150 :     for (i=1; i<nbgr; i++)
     193      365512 :       if (gr[i] && GR[i][0] < 0 && raye(GR[i],num)) { gr[i]=0; r++; }
     194             :   }
     195             :   else
     196             :   {
     197      496762 :     for (i=1; i<nbgr; i++)
     198      485436 :       if (gr[i] && GR[i][0] > 0 && raye(GR[i],num)) { gr[i]=0; r++; }
     199             :   }
     200       19964 :   return r;
     201             : }
     202             : 
     203             : static long
     204        2002 : galmodp(long EVEN, GEN pol, GEN dpol, GEN TYP, long *gr, long **GR)
     205             : {
     206             :   long i,k,l,n,nbremain;
     207             :   GEN p1, dtyp;
     208             :   forprime_t T;
     209             : 
     210        2002 :   switch(degpol(pol))
     211             :   {
     212         770 :     case  8: nbremain = EVEN? 28: 22; break;
     213         476 :     case  9: nbremain = EVEN? 18: 16; break;
     214         637 :     case 10: nbremain = EVEN? 12: 33; break;
     215         119 :     default: nbremain = EVEN?  5:  3; break; /* case 11 */
     216             :   }
     217             : 
     218        2002 :   u_forprime_init(&T, 2, ULONG_MAX);
     219        2002 :   dtyp = new_chunk(NMAX+1);
     220        2002 :   k = gr[0]; for (i=1; i<k; i++) gr[i]=1;
     221       28609 :   for (k=1; k<15; k++)
     222             :   {
     223       26719 :     ulong p = u_forprime_next(&T);
     224       26719 :     if (!umodiu(dpol,p)) continue; /* p divides dpol */
     225             : 
     226       21042 :     p1 = gel(Flx_degfact(ZX_to_Flx(pol,p),p),1);
     227       21042 :     l = lg(p1);
     228       21042 :     dtyp[0] = evaltyp(t_VECSMALL)|evallg(l);
     229       21042 :     for (i=1; i<l; i++) dtyp[i] = p1[l-i]; /* decreasing order */
     230       21042 :     n = RgV_isin(TYP, dtyp);
     231       21042 :     if (!n) return 1; /* only for N=11 */
     232       21014 :     nbremain -= rayergroup(EVEN,GR,n,gr);
     233       21014 :     if (nbremain==1) return 1;
     234             :   }
     235        1890 :   return 0;
     236             : }
     237             : 
     238             : static void
     239      164468 : preci(GEN o, long p)
     240             : {
     241      164468 :   long i, l = lg(o);
     242     1664211 :   for (i=1; i<l; i++)
     243             :   {
     244     1499743 :     GEN x = gel(o,i);
     245     1499743 :     if (typ(x)==t_COMPLEX) { setprec(gel(x,1),p); setprec(gel(x,2),p); } else setprec(x,p);
     246             :   }
     247      164468 : }
     248             : static void
     249      109055 : fixprec(buildroot *BR)
     250             : {
     251      109055 :   GEN r = BR->r;
     252      109055 :   long i, l = lg(r), p = BR->pr;
     253             : 
     254      109055 :   if (p > BR->prmax) pari_err_BUG("fixprex [precision too large]");
     255      109055 :   for (i = 1; i < l; i++) preci(gel(r,i), p);
     256      109055 : }
     257             : 
     258             : static long
     259       11858 : getpreci(buildroot *BR)
     260             : {
     261       11858 :   GEN x = gmael(BR->r,1,1);
     262       11858 :   return (typ(x)==t_COMPLEX)? realprec(gel(x,1)): realprec(x);
     263             : }
     264             : 
     265             : #define setcard_obj(x,n) ((x)[0] = (PERM)(n))
     266             : #define getcard_obj(x)   ((long)((x)[0]))
     267             : 
     268             : /* allocate a list of m arrays of length n (index 0 is codeword) */
     269             : static PERM *
     270       31549 : alloc_pobj(long n, long m)
     271             : {
     272             :   long i;
     273       31549 :   PERM *g = (PERM*) stack_malloc( (m+1)*sizeof(PERM) + (n+1)*m * sizeof(long) );
     274       31549 :   PERM gpt = (PERM) (g + (m+1));
     275             : 
     276       31549 :   for (i=1; i<=m; i++) { g[i] = gpt; gpt += (n+1); }
     277       31549 :   setcard_obj(g, m); return g;
     278             : }
     279             : 
     280             : static GROUP
     281       23716 : allocgroup(long n, long card)
     282             : {
     283       23716 :   GROUP gr = alloc_pobj(n,card);
     284             :   long i;
     285             : 
     286       23716 :   for (i=1; i<=card; i++) gr[i][0] = n;
     287       23716 :   return gr;
     288             : }
     289             : 
     290             : static pariFILE *
     291       19691 : galopen(const char *pre, long n, long n1, long n2)
     292             : {
     293       19691 :   pari_sp av = avma;
     294       19691 :   char *s = stack_malloc(strlen(pari_datadir) + 3 + 4 * 20 + 1 + 3);
     295             :   pariFILE *f;
     296             : 
     297       19691 :   (void)sprintf(s, "%s/galdata/%s%ld_%ld_%ld", pari_datadir, pre, n, n1, n2);
     298       19691 :   f = pari_fopengz(s);
     299       19691 :   if (!f) pari_err_FILE("galois file",s);
     300       19691 :   avma = av; return f;
     301             : }
     302             : 
     303             : static char
     304    10909766 : bin(char c)
     305             : {
     306    10909766 :   if (c>='0' && c<='9') c -= '0';
     307      919247 :   else if (c>='A' && c<='Z') c -= 'A'-10;
     308           0 :   else if (c>='a' && c<='z') c -= 'a'-36;
     309           0 :   else pari_err_TYPE("bin [not alphanumeric]", stoi(c));
     310    10909766 :   return c;
     311             : }
     312             : 
     313             : #define BUFFS 512
     314             : /* fill in g[i][j] (i<=n, j<=m) with (buffered) data from f->file */
     315             : static void
     316       19691 : read_obj(PERM *g, pariFILE *f, long n, long m)
     317             : {
     318       19691 :   long i, j, k, N = m*n;
     319       19691 :   char *ch = stack_malloc(N);
     320       19691 :   pari_fread_chars(ch, N, f->file);
     321     1221752 :   for (k = 0, i = 1; i <= n; i++)
     322     1202061 :     for (j = 1; j <= m; j++,k++) g[i][j] = bin(ch[k]);
     323       19691 :   pari_fclose(f);
     324       19691 : }
     325             : #undef BUFFS
     326             : 
     327             : /* the first 8 bytes contain size data (possibly padded with \0) */
     328             : static GROUP
     329       11858 : lirecoset(long n1, long n2, long n)
     330             : {
     331             :   GROUP gr;
     332             :   char c, ch[8];
     333             :   long m, cardgr;
     334       11858 :   pariFILE *f = galopen("COS", n, n1, n2);
     335       11858 :   pari_fread_chars(&c, 1, f->file); m=bin(c);
     336       11858 :   pari_fread_chars(&c, 1, f->file);
     337       11858 :   pari_fread_chars(ch, 6, f->file); cardgr=atol(ch);
     338       11858 :   gr=allocgroup(m,cardgr);
     339       11858 :   read_obj(gr, f,cardgr,m); return gr;
     340             : }
     341             : 
     342             : static void
     343        7833 : lireresolv(long n1, long n2, long n, resolv *R)
     344             : {
     345             :   char ch[5];
     346             :   long nm, nv;
     347        7833 :   pariFILE *f = galopen("RES", n, n1, n2);
     348        7833 :   pari_fread_chars(ch,5,f->file); nm = atol(ch);
     349        7833 :   pari_fread_chars(ch,3,f->file); nv = atol(ch);
     350        7833 :   R->a = alloc_pobj(nv,nm);
     351        7833 :   read_obj(R->a, f,nm,nv);
     352        7833 :   R->nm = nm;
     353        7833 :   R->nv = nv;
     354        7833 : }
     355             : 
     356             : static int
     357   125609666 : cmp_re(GEN x, GEN y)
     358             : {
     359   125609666 :   if (typ(x) != t_COMPLEX) return -1;
     360    74485190 :   if (typ(y) != t_COMPLEX) return 1; /* t_REALS are smallest */
     361    72603835 :   return gcmp(gel(x,1), gel(y,1));
     362             : }
     363             : 
     364             : /* multiply the r o bb. Sort first to detect pairs of conjugate */
     365             : static GEN
     366    23606509 : Monomial(GEN r, PERM bb, long nbv)
     367             : {
     368    23606509 :   GEN t, R = cgetg(nbv + 1, t_VEC);
     369    23606509 :   long i, s = 1;
     370             : 
     371   132015972 :   for (i = 1; i <= nbv; i++)
     372             :   {
     373   108409463 :     t = gel(r,bb[i]);
     374   108409463 :     if (typ(t) == t_COMPLEX && signe(gel(t,1)) < 0) { s = -s; t = gneg(t); }
     375   108409463 :     gel(R,i) = t;
     376             :   }
     377    23606509 :   if (nbv > 2)
     378    23060422 :     gen_sort_inplace(R, (void*)&cmp_re, cmp_nodata, NULL);
     379      546087 :   else if (nbv == 2 && typ(gel(R,2)) != t_COMPLEX)
     380       78163 :     swap(gel(R,1), gel(R,2));
     381    23606509 :   t = NULL;
     382   102219421 :   for (i=1; i<=nbv; i++)
     383             :   {
     384    78612912 :     GEN c = gel(R,i);
     385    78612912 :     if (typ(c) == t_COMPLEX && i < nbv)
     386             :     { /* detect conjugates */
     387    29796551 :       GEN n = gel(R,++i);
     388    29796551 :       if (!absr_cmp(gel(n,1), gel(c,1))
     389     9371077 :        && !absr_cmp(gel(n,2), gel(c,2))
     390     9345083 :        && signe(gel(c,2)) != signe(gel(n,2)))
     391     7948397 :         c = addrr(sqrr(gel(c,1)), sqrr(gel(c,2)));
     392             :       else
     393    21848154 :         c = gmul(c,n);
     394             :     }
     395    78612912 :     t = t? gmul(t, c): c;
     396             :   }
     397    23606509 :   if (s < 0) t = gneg(t);
     398    23606509 :   return t;
     399             : }
     400             : 
     401             : /* sum(i = 1, R->nm, Monomial(r, R->a[i], R->nv)). Sort real / imaginary part
     402             :  * separately by increasing absolute values, to increase stability */
     403             : static GEN
     404      624562 : gpolynomial(GEN r, resolv *R)
     405             : {
     406      624562 :   GEN RE = cgetg(R->nm+1, t_VEC), IM = cgetg(R->nm+1, t_VEC), re, im;
     407             :   long i, k;
     408    24231071 :   for (i = k = 1; i <= R->nm; i++)
     409             :   {
     410    23606509 :     GEN m = Monomial(r,R->a[i], R->nv);
     411    23606509 :     if (typ(m) == t_REAL)
     412     5817769 :       gel(RE, i) = m;
     413             :     else {
     414    17788740 :       gel(RE, i)   = gel(m,1);
     415    17788740 :       gel(IM, k++) = gel(m,2);
     416             :     }
     417             :   }
     418      624562 :   setlg(IM, k);
     419      624562 :   RE = vecpermute(RE, gen_indexsort(RE, (void*)&absr_cmp, cmp_nodata));
     420      624562 :   IM = vecpermute(IM, gen_indexsort(IM, (void*)&absr_cmp, cmp_nodata));
     421      624562 :   re = gel(RE,1);
     422      624562 :   for (i = 2; i <= R->nm; i++) re = addrr(re, gel(RE,i));
     423      624562 :   if (k == 1) return re;
     424      541131 :   im = gel(IM,1);
     425      541131 :   for (i = 2; i < k; i++) im = addrr(im, gel(IM,i));
     426      541131 :   return mkcomplex(re, im);
     427             : }
     428             : 
     429             : static void
     430        4396 : zaux1(GEN *z, GEN *r)
     431             : {
     432             :   GEN p2,p1;
     433        4396 :   p2=gsub(r[1], gadd(r[2],r[5]));
     434        4396 :   p2=gmul(p2, gsub(r[2],r[5]));
     435        4396 :   p1=gmul(p2,r[1]);
     436        4396 :   p2=gsub(r[3],gadd(r[2],r[4]));
     437        4396 :   p2=gmul(p2,gsub(r[4],r[2]));
     438        4396 :   p1=gadd(p1,gmul(p2,r[3]));
     439        4396 :   p2=gmul(r[5],gsub(r[4],r[5]));
     440        4396 :   z[1]=gadd(p1,gmul(p2,r[4]));
     441             : 
     442        4396 :   p2=gsub(r[1],gadd(r[3],r[4]));
     443        4396 :   p2=gmul(p2,gsub(r[3],r[4]));
     444        4396 :   p1=gmul(p2,r[1]);
     445        4396 :   p2=gsub(r[5],gadd(r[3],r[2]));
     446        4396 :   p2=gmul(p2,gsub(r[2],r[3]));
     447        4396 :   p1=gadd(p1,gmul(p2,r[5]));
     448        4396 :   p2=gmul(r[4],gsub(r[2],r[4]));
     449        4396 :   z[2]=gadd(p1,gmul(p2,r[2]));
     450        4396 : }
     451             : 
     452             : static void
     453        2198 : zaux(GEN *z, GEN *r)
     454             : {
     455        2198 :   zaux1(z, r); zaux1(z+2, r+5);
     456        2198 : }
     457             : 
     458             : static GEN
     459      563655 : gpoly(GEN rr, long n1, long n2)
     460             : {
     461      563655 :   const long N = lg(rr)-1;
     462      563655 :   GEN p1,p2,z[6], *r = (GEN*)rr; /* syntaxic kludge */
     463             :   long i,j;
     464             : 
     465      563655 :   if (N==8)
     466             :   {
     467        4710 :     if (n1==47 && n2==46)
     468             :     {
     469        2215 :       p1=gsub(r[3],r[4]);
     470        2215 :       for (i=1; i<3; i++) for (j=i+1; j<5; j++) p1 = gmul(p1,gsub(r[i],r[j]));
     471        2215 :       for (i=5; i<8; i++) for (j=i+1; j<9; j++) p1 = gmul(p1,gsub(r[i],r[j]));
     472        2215 :       p2=r[1];
     473        2215 :       for (i=2; i<5; i++) p2=gadd(p2,r[i]);
     474        2215 :       for (i=5; i<9; i++) p2=gsub(p2,r[i]);
     475             :     }
     476             :     else /* n1==44 && n2==40 */
     477             :     {
     478         280 :       for (i=1; i<5; i++) z[i] = gadd(r[2*i-1],r[2*i]);
     479         280 :       p1 = gsub(r[1],r[2]);
     480         280 :       for (i=2; i<5; i++) p1 = gmul(p1,gsub(r[2*i-1],r[2*i]));
     481         280 :       p2=gsub(z[3],z[4]);
     482         280 :       for (i=1; i<3; i++) for (j=i+1; j<5; j++) p2 = gmul(p2,gsub(z[i],z[j]));
     483             :     }
     484        2495 :     return gmul(p1,p2);
     485             :   }
     486             : 
     487      561160 :   if (N==9)
     488             :   {
     489      134043 :     if (n1==31 && n2==29)
     490             :     {
     491         406 :       p1=gsub(r[2],r[3]);
     492         406 :       for (j=2; j<4; j++) p1 = gmul(p1,gsub(r[1],r[j]));
     493         406 :       for (i=4; i<6; i++) for (j=i+1; j<7; j++) p1 = gmul(p1,gsub(r[i],r[j]));
     494         406 :       p2 = gsub(r[8],r[9]);
     495         406 :       for (j=8; j<10; j++) p2 = gmul(p2,gsub(r[7],r[j]));
     496             :     }
     497             :     else /* ((n1==34 && n2==31) || (n1=33 && n2==30)) */
     498             :     {
     499      133231 :       p1=r[1]; for (i=2; i<4; i++) p1=gadd(p1,r[i]);
     500      133231 :       p2=r[4]; for (i=5; i<7; i++) p2=gadd(p2,r[i]);
     501      133231 :       p1=gmul(p1,p2);
     502      133231 :       p2=r[7]; for (i=8; i<10; i++) p2=gadd(p2,r[i]);
     503             :     }
     504      133637 :     return gmul(p1,p2);
     505             :   }
     506             : 
     507      427523 :   if (N==10)
     508             :   {
     509      427523 :     if ((n1==45 && n2==43) || (n1==44 && n2==42))
     510             :     {
     511       77189 :       p1=r[1]; for (i=2; i<6; i++) p1=gadd(p1,r[i]);
     512       77189 :       p2=r[6]; for (i=7; i<11; i++) p2=gadd(p2,r[i]);
     513       77189 :       return gmul(p1,p2);
     514             :     }
     515      350334 :     else if ((n1==45 && n2==39) || (n1==44 && n2==37))
     516             :     {
     517      321182 :       p1 = gadd(r[1],r[2]);
     518      321182 :       for (i=2; i<6; i++) p1 = gmul(p1,gadd(r[2*i-1],r[2*i]));
     519      321182 :       return p1;
     520             :     }
     521       29152 :     else if ((n1==43 && n2==41) || (n1==33 && n2==27))
     522             :     {
     523        1168 :       p1=gsub(r[4],r[5]);
     524        1168 :       for (i=1; i<4; i++) for (j=i+1; j<6; j++) p1=gmul(p1,gsub(r[i],r[j]));
     525        1168 :       p2=gsub(r[9],r[10]);
     526        1168 :       for (i=6; i<9; i++) for (j=i+1; j<11; j++) p2=gmul(p2,gsub(r[i],r[j]));
     527        1168 :       return gmul(p1,p2);
     528             :     }
     529       27984 :     else if ((n1==43 && n2==33) || (n1==42 && n2==28) || (n1==41 && n2==27)
     530       21824 :           || (n1==40 && n2==21))
     531             :     {
     532       12082 :       p2=gadd(r[2],r[5]);
     533       12082 :       p2=gsub(p2,gadd(r[3],r[4]));
     534       12082 :       p1=gmul(p2,r[1]);
     535       12082 :       p2=gsub(r[3],gadd(r[4],r[5]));
     536       12082 :       p1=gadd(p1,gmul(p2,r[2]));
     537       12082 :       p2=gsub(r[4],r[5]);
     538       12082 :       p1=gadd(p1,gmul(p2,r[3]));
     539       12082 :       z[1]=gadd(p1,gmul(r[4],r[5]));
     540             : 
     541       12082 :       p2=gadd(r[7],r[10]);
     542       12082 :       p2=gsub(p2,gadd(r[8],r[9]));
     543       12082 :       p1=gmul(p2,r[6]);
     544       12082 :       p2=gsub(r[8],gadd(r[9],r[10]));
     545       12082 :       p1=gadd(p1,gmul(p2,r[7]));
     546       12082 :       p2=gsub(r[9],r[10]);
     547       12082 :       p1=gadd(p1,gmul(p2,r[8]));
     548       12082 :       z[2]=gadd(p1,gmul(r[9],r[10]));
     549       12082 :       return gadd(gsqr(z[1]), gsqr(z[2]));
     550             :     }
     551       15902 :     else if (n1==41 && n2==40)
     552             :     {
     553        1148 :       p1=gsub(r[4],r[5]);
     554        1148 :       for (i=1; i<4; i++) for (j=i+1; j<6; j++) p1 = gmul(p1,gsub(r[i],r[j]));
     555        1148 :       p2=gsub(r[9],r[10]);
     556        1148 :       for (i=6; i<9; i++) for (j=i+1; j<11; j++) p2 = gmul(p2,gsub(r[i],r[j]));
     557        1148 :       return gadd(p1,p2);
     558             :     }
     559       14754 :     else if ((n1==41 && n2==22) || (n1==40 && n2==11) || (n1==17 && n2==5)
     560        9161 :             || (n1==10 && n2==4) || (n1==9 && n2==3) || (n1==6 && n2==1))
     561             :     {
     562        6678 :       p1=gadd(r[1],r[6]);
     563        6678 :       for (i=2; i<6; i++) p1=gmul(p1,gadd(r[i],r[i+5]));
     564        6678 :       return p1;
     565             :     }
     566        8076 :     else if ((n1==39 && n2==38) || (n1==29 && n2==25))
     567             :     {
     568         515 :       for (i=1; i<6; i++) z[i]=gadd(r[2*i-1],r[2*i]);
     569         515 :       p1=gsub(r[1],r[2]);
     570         515 :       for (i=2; i<6; i++) p1=gmul(p1,gsub(r[2*i-1],r[2*i]));
     571         515 :       p2=gsub(z[4],z[5]);
     572         515 :       for (i=1; i<4; i++) for (j=i+1; j<6; j++) p2=gmul(p2,gsub(z[i],z[j]));
     573         515 :       return gmul(p1,p2);
     574             :     }
     575        7561 :     else if ((n1==39 && n2==36) || (n1==37 && n2==34) || (n1==29 && n2==23)
     576        6776 :           || (n1==24 && n2==15))
     577             :     {
     578         841 :       for (i=1; i<6; i++) z[i]=gadd(r[2*i-1],r[2*i]);
     579         841 :       p1=gsub(z[4],z[5]); p2=gmul(gsub(z[3],z[4]),gsub(z[3],z[5]));
     580         841 :       for (i=1; i<3; i++) for (j=i+1; j<6; j++) p2=gmul(p2,gsub(z[i],z[j]));
     581         841 :       return gmul(p1,p2);
     582             :     }
     583        6720 :     else if ((n1==39 && n2==29) || (n1==38 && n2==25) || (n1==37 && n2==24)
     584        5831 :           || (n1==36 && n2==23) || (n1==34 && n2==15))
     585             :     {
     586        2051 :       for (i=1; i<6; i++) z[i]=gadd(r[2*i-1],r[2*i]);
     587        2051 :       p2=gadd(z[2],z[5]);
     588        2051 :       p2=gsub(p2,gadd(z[3],z[4]));
     589        2051 :       p1=gmul(p2,z[1]);
     590        2051 :       p2=gsub(z[3],gadd(z[4],z[5]));
     591        2051 :       p1=gadd(p1,gmul(p2,z[2]));
     592        2051 :       p2=gsub(z[4],z[5]);
     593        2051 :       p1=gadd(p1,gmul(p2,z[3]));
     594        2051 :       p1=gadd(p1,gmul(z[4],z[5]));
     595        2051 :       return gsqr(p1);
     596             :     }
     597        4669 :     else if ((n1==39 && n2==22) || (n1==38 && n2==12) || (n1==36 && n2==11)
     598        3997 :           || (n1==29 && n2== 5) || (n1==25 && n2== 4) || (n1==23 && n2== 3)
     599        3318 :           || (n1==16 && n2== 2) || (n1==14 && n2== 1))
     600             :     {
     601        1799 :       p1=r[1]; for (i=2; i<6; i++) p1=gadd(p1,r[2*i-1]);
     602        1799 :       p2=r[2]; for (i=2; i<6; i++) p2=gadd(p2,r[2*i]);
     603        1799 :       return gmul(p1,p2);
     604             :     }
     605        2870 :     else if (n1==28 && n2==18)
     606             :     {
     607         168 :       zaux(z, r);
     608         168 :       p1=gmul(z[1],gsub(z[3],z[4]));
     609         168 :       p2=gmul(z[2],gadd(z[3],z[4])); return gadd(p1,p2);
     610             :     }
     611        2702 :     else if (n1==27 && n2==20)
     612             :     {
     613         644 :       zaux(z, r); p1=gmul(z[1],z[3]); p2=gmul(z[2],z[4]);
     614         644 :       p1 = gsub(p1,p2); p2=r[1];
     615         644 :       for (i=2; i<6 ; i++) p2=gadd(p2,r[i]);
     616         644 :       for (   ; i<11; i++) p2=gsub(p2,r[i]);
     617         644 :       return gmul(p1,p2);
     618             :     }
     619        2058 :     else if (n1==27 && n2==19)
     620             :     {
     621         252 :       zaux(z, r); p1=gmul(z[1],z[3]); p2=gmul(z[2],z[4]);
     622         252 :       return gsub(p1,p2);
     623             :     }
     624        1806 :     else if ((n1==27 && n2==17) || (n1==21 && n2==9))
     625             :     {
     626         672 :       zaux(z, r); p1=gmul(z[1],z[3]); p2=gmul(z[2],z[4]);
     627         672 :       return gadd(p1,p2);
     628             :     }
     629        1134 :     else if (n1==23 && n2==16)
     630             :     {
     631         224 :       for (i=1; i<6; i++) z[i]=gadd(r[2*i-1],r[2*i]);
     632         224 :       p1=gsub(z[1],gadd(z[2],z[5])); p1=gmul(p1,gsub(z[2],z[5]));
     633         224 :       p2=gmul(p1,z[1]); p1=gsub(z[3],gadd(z[2],z[4]));
     634         224 :       p1=gmul(  p1,gsub(z[4],z[2])); p2=gadd(p2,gmul(p1,z[3]));
     635         224 :       p1=gmul(z[5],gsub(z[4],z[5])); p2=gadd(p2,gmul(p1,z[4]));
     636         224 :       p1=gsub(r[1],r[2]);
     637         224 :       for (i=2; i<6; i++) p1=gmul(p1,gsub(r[2*i-1],r[2*i]));
     638         224 :       return gmul(p1,p2);
     639             :     }
     640         910 :     else if (n1==22 && n2==12)
     641             :     {
     642          28 :       for (i=1; i<6; i++) z[i]=gadd(r[i],r[i+5]);
     643          28 :       p1=gsub(r[1],r[6]);
     644          28 :       for (i=2; i<6; i++) p1=gmul(p1,gsub(r[i],r[i+5]));
     645          28 :       p2=gsub(z[4],z[5]);
     646          28 :       for (i=1; i<4; i++) for (j=i+1; j<6; j++) p2=gmul(p2,gsub(z[i],z[j]));
     647          28 :       return gmul(p1,p2);
     648             :     }
     649         882 :     else if ((n1==22 && n2==11) || (n1==5 && n2==3))
     650             :     {
     651          84 :       for (i=1; i<6; i++) z[i]=gadd(r[i],r[i+5]);
     652          84 :       p1=gsub(z[4],z[5]); p2=gmul(gsub(z[3],z[4]),gsub(z[3],z[5]));
     653          84 :       for (i=1; i<3; i++) for (j=i+1; j<6; j++) p2=gmul(p2,gsub(z[i],z[j]));
     654          84 :       return gmul(p1,p2);
     655             :     }
     656         798 :     else if ((n1==22 && n2==5) || (n1==12 && n2==4) || (n1==11 && n2==3))
     657             :     {
     658         336 :       for (i=1; i<6; i++) z[i]=gadd(r[i],r[i+5]);
     659         336 :       p2=gadd(z[2],z[5]); p2=gsub(p2,gadd(z[3],z[4])); p1=gmul(p2,z[1]);
     660         336 :       p2=gsub(z[3],gadd(z[4],z[5])); p1=gadd(p1,gmul(p2,z[2]));
     661         336 :       p2=gsub(z[4],z[5]);
     662         336 :       p1=gadd(p1,gmul(p2,z[3])); p1=gadd(p1,gmul(z[4],z[5]));
     663         336 :       return gsqr(p1);
     664             :     }
     665         462 :     else if (n1==21 && n2==10)
     666             :     {
     667         462 :       zaux(z, r); p1=gmul(z[1],z[4]); p2=gmul(z[2],z[3]);
     668         462 :       return gsub(p1,p2);
     669             :     }
     670             :   }
     671           0 :   pari_err_TYPE("gpoly [undefined invariant polynomial]", mkvecsmall2(n1,n2));
     672           0 :   return NULL; /* not reached */
     673             : }
     674             : 
     675             : /* a is a t_VECSMALL representing a polynomial */
     676             : static GEN
     677        1479 : new_pol(long N, GEN r, GEN a)
     678             : {
     679        1479 :   long i, j, l = lg(a);
     680        1479 :   GEN x, z, v = cgetg(N+1, t_VEC);
     681       14228 :   for (i=1; i<=N; i++)
     682             :   {
     683       12749 :     z = gel(r,i); x = gaddsg(a[2], z);
     684       12749 :     for (j = 3; j < l; j++) x = gaddsg(a[j], gmul(z,x));
     685       12749 :     gel(v,i) = x;
     686             :   }
     687        1479 :   return gclone(v);
     688             : }
     689             : 
     690             : /* BR->r[l], BR->coef[l] hold data related to Tschirnausen transform of
     691             :  * degree l - 1 */
     692             : static void
     693        1309 : tschirn(buildroot *BR)
     694             : {
     695        1309 :   long i, k, v = varn(BR->p), l = lg(BR->r);
     696             :   GEN a, h, r;
     697             : 
     698        1309 :   if (l >= BR->N) pari_err_BUG("tschirn");
     699        1309 :   if (DEBUGLEVEL)
     700           0 :     err_printf("\n$$$$$ Tschirnhaus transformation of degree %ld: $$$$$\n",l-1);
     701             : 
     702        1309 :   a = gel(BR->coef,l); /* fill with random polynomial of degree <= l-1 */
     703             :   do
     704             :   {
     705        1337 :     a[1]=0;
     706        1337 :     for (i=2; i < l+2; i++) a[i] = random_bits(3) + 1;
     707        1337 :     h = Flx_to_ZX(Flx_renormalize(a,l+2));
     708        1337 :   } while (degpol(h) <= 0 || !ZX_is_squarefree(h));
     709        1309 :   setvarn(h, v); k = 0;
     710        1309 :   (void)ZXQ_charpoly_sqf(BR->p, h, &k, v);
     711        1309 :   a[2] += k;
     712             : 
     713        1309 :   r = gel(BR->r,1);
     714        1309 :   preci(r, BR->prmax); /* max accuracy original roots */
     715        1309 :   vectrunc_append(BR->r, new_pol(BR->N, r, a));
     716        1309 :   fixprec(BR); /* restore accuracy */
     717        1309 : }
     718             : 
     719             : static GEN
     720         156 : sortroots(GEN newr, GEN oldr)
     721             : {
     722         156 :   long e, e0, i, j, k, l = lg(newr);
     723         156 :   GEN r = cgetg(l, t_VEC), z = cgetg(l, t_VEC), t = const_vecsmall(l-1, 1);
     724         156 :   k = 0; /* gcc -Wall */
     725        1406 :   for (i=1; i<l; i++)
     726             :   {
     727        1250 :     e0 = EXPOBITS;
     728       11270 :     for (j=1; j<l; j++)
     729       10020 :       if (t[j])
     730             :       {
     731        5635 :         e = gexpo(gsub(gel(oldr,i), gel(newr,j)));
     732        5635 :         if (e < e0) { e0 = e; k = j; }
     733             :       }
     734        1250 :     gel(z,i) = gel(newr,k); t[k] = 0;
     735             :   }
     736         156 :   for (i=1; i<l; i++) gel(r,i) = gel(z,i);
     737         156 :   return r;
     738             : }
     739             : 
     740             : static void
     741         156 : delete_roots(buildroot *BR)
     742             : {
     743         156 :   GEN r = BR->r;
     744         156 :   long i, l = lg(r);
     745         156 :   for (i = 1; i < l; i++) gunclone(gel(r,i));
     746         156 :   setlg(r, 1);
     747         156 : }
     748             : 
     749             : /* increase the roots accuracy */
     750             : static void
     751       54042 : moreprec(buildroot *BR)
     752             : {
     753       54042 :   long d = BR->pr - BR->prmax;
     754       54042 :   if (d > 0)
     755             :   { /* recompute roots */
     756         156 :     pari_sp av = avma;
     757         156 :     long l = lg(BR->r);
     758             :     GEN ro;
     759             : 
     760         156 :     if (d < BIGDEFAULTPREC-2) d = BIGDEFAULTPREC-2;
     761         156 :     BR->prmax = maxss(BR->prmax+d, (long)(BR->prmax * 1.2));
     762         156 :     if (DEBUGLEVEL)
     763           0 :       { err_printf("$$$$$ New prec = %ld\n",BR->prmax); err_flush(); }
     764         156 :     ro = sortroots(QX_complex_roots(BR->p,BR->prmax), gel(BR->r,1));
     765         156 :     delete_roots(BR);
     766         156 :     vectrunc_append(BR->r, gclone(ro));
     767         326 :     for (d = 2; d < l; d++)
     768         170 :       vectrunc_append(BR->r, new_pol(BR->N, ro, gel(BR->coef,d)));
     769         156 :     avma = av;
     770             :   }
     771       54042 :   fixprec(BR);
     772       54042 : }
     773             : 
     774             : /* determine "sufficient" extra bit-precision such that we may decide
     775             :  * (heuristic) whether z is an integer. */
     776             : static GEN
     777     1188217 : get_ro(long N, GEN rr, PERM S1, PERM S2, resolv *R)
     778             : {
     779     1188217 :   GEN r = cgetg(N+1, t_VEC);
     780             :   long i;
     781     1188217 :   for (i=1; i<=N; i++) r[i] = rr[ S1[S2[i] ] ];
     782     1188217 :   return R->a? gpolynomial(r, R): gpoly(r,R->nm,R->nv);
     783             : }
     784             : /* typ(z) = t_REAL, return zi = t_INT approximation */
     785             : static long
     786     2060373 : sufprec_r(GEN z)
     787             : {
     788     2060373 :   long p = bit_prec(z);
     789             :   /* bit accuracy of fractional part large enough ? */
     790     2060373 :   return ( p - expo(z) > maxss(3*32, (long)0.2*p) );
     791             : }
     792             : /* typ(z) = t_REAL or t_COMPLEX, return zi = t_INT approximation */
     793             : static long
     794     1079562 : sufprec(GEN z)
     795             : {
     796     1079562 :   if (typ(z) == t_REAL)
     797       98604 :     return sufprec_r(z);
     798             :   else
     799      980958 :     return sufprec_r(gel(z,2)) && sufprec_r(gel(z,1));
     800             : }
     801             : 
     802             : static GEN
     803     1134513 : get_ro_perm(PERM S1, PERM S2, long d, resolv *R, buildroot *BR)
     804             : {
     805             :   GEN ro, roi;
     806             :   long e;
     807             :   for (;;)
     808             :   {
     809     1134513 :     ro = get_ro(BR->N, gel(BR->r, d), S1,S2,R); roi = grndtoi(ro, &e);
     810     1134513 :     if (e < 0)
     811             :     {
     812     1134414 :       if (e < -64 || sufprec(ro)) break;
     813         239 :       e = 0;
     814             :     }
     815         338 :     BR->pr += nbits2extraprec(e + 10);
     816         338 :     moreprec(BR);
     817         338 :   }
     818     1134175 :   if (e > -10 || typ(roi) == t_COMPLEX) return NULL;
     819             :   /* compute with 128 more bits */
     820       53704 :   BR->pr += MEDDEFAULTPREC-2;
     821       53704 :   moreprec(BR);
     822       53704 :   ro = get_ro(BR->N, gel(BR->r, d), S1,S2,R);
     823       53704 :   BR->pr -= MEDDEFAULTPREC-2;
     824       53704 :   fixprec(BR);
     825             :   /* ro closer to roi (32 more bits) ? */
     826       53704 :   return (gexpo(gsub(ro, roi)) < e - 32) ? roi: NULL;
     827             : }
     828             : 
     829             : static void
     830           0 : dbg_rac(long nri,long nbracint,long numi[],GEN racint[],long multi[])
     831             : {
     832             :   long k;
     833           0 :   err_printf("\t# rational integer roots = %ld:",nbracint-nri);
     834           0 :   for (k = nri+1; k <= nbracint; k++) err_printf(" %ld^%ld", numi[k], multi[k]);
     835           0 :   err_printf("\n");
     836           0 :   for (k = nri+1; k <= nbracint; k++) err_printf("\t%2ld: %Ps\n", numi[k], racint[k]);
     837           0 :   err_flush();
     838           0 : }
     839             : 
     840             : #define M 2521
     841             : /* return NULL if not included, the permutation of the roots otherwise */
     842             : static PERM
     843       11858 : check_isin(buildroot *BR, resolv *R, GROUP tau, GROUP ss)
     844             : {
     845             :   long nogr, nocos, init, i, j, k, l, d;
     846       11858 :   pari_sp av1 = avma, av2;
     847             :   long nbgr,nbcos,nbracint,nbrac,lastnbri,lastnbrm;
     848             :   static long numi[M],numj[M],lastnum[M],multi[M],norac[M],lastnor[M];
     849             :   GEN  racint[M], roint;
     850             : 
     851       11858 :   if (getpreci(BR) != BR->pr) fixprec(BR);
     852       11858 :   nbcos = getcard_obj(ss);
     853       11858 :   nbgr  = getcard_obj(tau);
     854       11858 :   lastnbri = lastnbrm = -1; nbracint = nbrac = 0; /* gcc -Wall*/
     855       19845 :   for (nogr=1; nogr<=nbgr; nogr++)
     856             :   {
     857       13944 :     PERM T = tau[nogr];
     858       13944 :     if (DEBUGLEVEL) err_printf("    ----> Group # %ld/%ld:\n",nogr,nbgr);
     859       13944 :     init = 0; d = 1;
     860             :     for (;;)
     861             :     {
     862       18879 :       if (!init)
     863             :       {
     864       13944 :         av2 = avma; nbrac = nbracint = 0;
     865     1105713 :         for (nocos=1; nocos<=nbcos; nocos++, avma = av2)
     866             :         {
     867     1091769 :           roint = get_ro_perm(T, ss[nocos], d, R, BR);
     868     1091769 :           if (!roint) continue;
     869             : 
     870       47180 :           nbrac++;
     871       47180 :           if (nbrac >= M)
     872             :           {
     873           0 :             pari_warn(warner, "more than %ld rational integer roots\n", M);
     874           0 :             avma = av1; goto NEXT;
     875             :           }
     876       50330 :           for (j=1; j<=nbracint; j++)
     877       39858 :             if (equalii(roint,racint[j])) { multi[j]++; break; }
     878       47180 :           if (j > nbracint)
     879             :           {
     880       10472 :             nbracint = j; multi[j] = 1; numi[j] = nocos;
     881       10472 :             racint[j] = gerepileuptoint(av2,roint); av2 = avma;
     882             :           }
     883       47180 :           numj[nbrac] = nocos; norac[nbrac] = j;
     884             :         }
     885       13944 :         if (DEBUGLEVEL) dbg_rac(0,nbracint,numi,racint,multi);
     886       17556 :         for (i=1; i<=nbracint; i++)
     887        8302 :           if (multi[i]==1) return permmul(T, ss[numi[i]]);
     888        9254 :         init = 1;
     889             :       }
     890             :       else
     891             :       {
     892        4935 :         nbrac = nbracint = 0;
     893        8603 :         for (l=1; l<=lastnbri; l++, avma = av1)
     894             :         {
     895        4935 :           long nri = nbracint;
     896        4935 :           av2 = avma;
     897       47355 :           for (k=1; k<=lastnbrm; k++)
     898       42420 :             if (lastnor[k]==l)
     899             :             {
     900       42406 :               nocos = lastnum[k];
     901       42406 :               roint = get_ro_perm(T, ss[nocos], d, R, BR);
     902       42406 :               if (!roint) { avma = av2; continue; }
     903             : 
     904        5264 :               nbrac++;
     905        6286 :               for (j=nri+1; j<=nbracint; j++)
     906        2632 :                 if (equalii(roint,racint[j])) { multi[j]++; break; }
     907        5264 :               if (j > nbracint)
     908             :               {
     909        3654 :                 nbracint = j; multi[j] = 1; numi[j] = nocos;
     910        3654 :                 racint[j] = gerepileuptoint(av2,roint); av2=avma;
     911             :               }
     912        5264 :               numj[nbrac] = nocos; norac[nbrac] = j;
     913             :             }
     914        4935 :           if (DEBUGLEVEL) dbg_rac(nri,nbracint,numi,racint,multi);
     915        6440 :           for (i=nri+1; i<=nbracint; i++)
     916        2772 :             if (multi[i]==1) return permmul(T, ss[numi[i]]);
     917             :         }
     918             :       }
     919       12922 :       avma = av1; if (!nbracint) break;
     920             : 
     921        4935 :       lastnbri = nbracint; lastnbrm = nbrac;
     922        4935 :       for (j=1; j<=nbrac; j++) { lastnum[j] = numj[j]; lastnor[j] = norac[j]; }
     923             : 
     924             : NEXT:
     925        4935 :       if (DEBUGLEVEL) {
     926           0 :         err_printf("        all integer roots are double roots\n");
     927           0 :         err_printf("      Working with polynomial #%ld:\n", d+1);
     928             :       }
     929        4935 :       if (++d >= lg(BR->r)) tschirn(BR);
     930        4935 :     }
     931             :   }
     932        5901 :   return NULL;
     933             : }
     934             : #undef M
     935             : 
     936             : /* DEGREE 8 */
     937             : static long
     938          70 : galoisprim8(long EVEN, buildroot *BR)
     939             : {
     940             :   long rep;
     941             : 
     942          70 :   rep=isin_G_H(BR,50,43);
     943          70 :   if (rep) return EVEN? 37: 43;
     944          42 :   if (!EVEN) return 50;
     945          42 :   rep=isin_G_H(BR,49,48);
     946          42 :   if (!rep) return 49;
     947          42 :   rep=isin_G_H(BR,48,36);
     948          42 :   if (!rep) return 48;
     949          28 :   rep=isin_G_H(BR,36,25);
     950          28 :   return rep? 25: 36;
     951             : }
     952             : 
     953             : static long
     954         336 : galoisimpodd8(buildroot *BR, long nh)
     955             : {
     956             :   long rep;
     957         336 :   if (nh!=47) goto IMPODD_8_6;
     958         280 :   rep=isin_G_H(BR,47,46);
     959         280 :   if (!rep) goto IMPODD_8_5;
     960         105 :   rep=isin_G_H(BR,46,28);
     961         105 :   if (rep) goto IMPODD_8_7; else return 46;
     962             : 
     963             : IMPODD_8_5:
     964         175 :   rep=isin_G_H(BR,47,35);
     965         175 :   if (rep) goto IMPODD_8_9; else return 47;
     966             : 
     967             : IMPODD_8_6:
     968          56 :   rep=isin_G_H(BR,44,40);
     969          56 :   if (rep) goto IMPODD_8_10; else goto IMPODD_8_11;
     970             : 
     971             : IMPODD_8_7:
     972          91 :   rep=isin_G_H(BR,28,21);
     973          91 :   if (rep) return 21; else goto IMPODD_8_33;
     974             : 
     975             : IMPODD_8_9:
     976         161 :   rep=isin_G_H(BR,35,31);
     977         161 :   if (rep) goto IMPODD_8_13; else goto IMPODD_8_14;
     978             : 
     979             : IMPODD_8_10:
     980          28 :   rep=isin_G_H(BR,40,26);
     981          28 :   if (rep) goto IMPODD_8_15; else goto IMPODD_8_16;
     982             : 
     983             : IMPODD_8_11:
     984          28 :   rep=isin_G_H(BR,44,38);
     985          28 :   if (rep) goto IMPODD_8_17; else goto IMPODD_8_18;
     986             : 
     987             : IMPODD_8_12:
     988          63 :   rep=isin_G_H(BR,16,7);
     989          63 :   if (rep) goto IMPODD_8_19; else return 16;
     990             : 
     991             : IMPODD_8_13:
     992          21 :   rep=isin_G_H(BR,31,21);
     993          21 :   return rep? 21: 31;
     994             : 
     995             : IMPODD_8_14:
     996         140 :   rep=isin_G_H(BR,35,30);
     997         140 :   if (rep) goto IMPODD_8_34; else goto IMPODD_8_20;
     998             : 
     999             : IMPODD_8_15:
    1000          98 :   rep=isin_G_H(BR,26,16);
    1001          98 :   if (rep) goto IMPODD_8_12; else goto IMPODD_8_21;
    1002             : 
    1003             : IMPODD_8_16:
    1004          28 :   rep=isin_G_H(BR,40,23);
    1005          28 :   if (rep) goto IMPODD_8_22; else return 40;
    1006             : 
    1007             : IMPODD_8_17:
    1008          14 :   rep=isin_G_H(BR,38,31);
    1009          14 :   if (rep) goto IMPODD_8_13; else return 38;
    1010             : 
    1011             : IMPODD_8_18:
    1012          14 :   rep=isin_G_H(BR,44,35);
    1013          14 :   if (rep) goto IMPODD_8_9; else return 44;
    1014             : 
    1015             : IMPODD_8_19:
    1016          49 :   rep=isin_G_H(BR,7,1);
    1017          49 :   return rep? 1: 7;
    1018             : 
    1019             : IMPODD_8_20:
    1020         126 :   rep=isin_G_H(BR,35,28);
    1021         126 :   if (rep) goto IMPODD_8_7; else goto IMPODD_8_23;
    1022             : 
    1023             : IMPODD_8_21:
    1024          98 :   rep=isin_G_H(BR,26,17);
    1025          98 :   if (rep) goto IMPODD_8_24; else goto IMPODD_8_25;
    1026             : 
    1027             : IMPODD_8_22:
    1028          14 :   rep=isin_G_H(BR,23,8);
    1029          14 :   if (rep) goto IMPODD_8_26; else return 23;
    1030             : 
    1031             : IMPODD_8_23:
    1032         126 :   rep=isin_G_H(BR,35,27);
    1033         126 :   if (rep) goto IMPODD_8_27; else goto IMPODD_8_28;
    1034             : 
    1035             : IMPODD_8_24:
    1036          14 :   rep=isin_G_H(BR,17,7);
    1037          14 :   if (rep) goto IMPODD_8_19; else return 17;
    1038             : 
    1039             : IMPODD_8_25:
    1040          84 :   rep=isin_G_H(BR,26,15);
    1041          84 :   if (rep) goto IMPODD_8_29; else return 26;
    1042             : 
    1043             : IMPODD_8_26:
    1044          21 :   rep=isin_G_H(BR,8,1);
    1045          21 :   return rep? 1: 8;
    1046             : 
    1047             : IMPODD_8_27:
    1048          14 :   rep=isin_G_H(BR,27,16);
    1049          14 :   if (rep) goto IMPODD_8_12; else return 27;
    1050             : 
    1051             : IMPODD_8_28:
    1052         112 :   rep=isin_G_H(BR,35,26);
    1053         112 :   if (rep) goto IMPODD_8_15; else return 35;
    1054             : 
    1055             : IMPODD_8_29:
    1056          70 :   rep=isin_G_H(BR,15,7);
    1057          70 :   if (rep) goto IMPODD_8_19;
    1058          70 :   rep=isin_G_H(BR,15,6);
    1059          70 :   if (!rep) goto IMPODD_8_32;
    1060          14 :   rep=isin_G_H(BR,6,1);
    1061          14 :   return rep? 1: 6;
    1062             : 
    1063             : IMPODD_8_32:
    1064          56 :   rep=isin_G_H(BR,15,8);
    1065          56 :   if (rep) goto IMPODD_8_26; else return 15;
    1066             : 
    1067             : IMPODD_8_33:
    1068          77 :   rep=isin_G_H(BR,28,16);
    1069          77 :   if (rep) goto IMPODD_8_12; else return 28;
    1070             : 
    1071             : IMPODD_8_34:
    1072          14 :   rep=isin_G_H(BR,30,21);
    1073          14 :   return rep? 21: 30;
    1074             : }
    1075             : 
    1076             : static long
    1077         336 : galoisimpeven8(buildroot *BR, long nh)
    1078             : {
    1079             :    long rep;
    1080         336 :    if (nh!=45) goto IMPEVEN_8_6;
    1081         294 :    rep=isin_G_H(BR,45,42);
    1082         294 :    if (!rep) goto IMPEVEN_8_5;
    1083         147 :   rep=isin_G_H(BR,42,34);
    1084         147 :   if (rep) goto IMPEVEN_8_7; else goto IMPEVEN_8_8;
    1085             : 
    1086             : IMPEVEN_8_5:
    1087         147 :   rep=isin_G_H(BR,45,41);
    1088         147 :   if (rep) goto IMPEVEN_8_9; else return 45;
    1089             : 
    1090             : IMPEVEN_8_6:
    1091          42 :   rep=isin_G_H(BR,39,32);
    1092          42 :   if (rep) goto IMPEVEN_8_10; else goto IMPEVEN_8_11;
    1093             : 
    1094             : IMPEVEN_8_7:
    1095         105 :   rep=isin_G_H(BR,34,18);
    1096         105 :   if (rep) goto IMPEVEN_8_21; else goto IMPEVEN_8_45;
    1097             : 
    1098             : IMPEVEN_8_8:
    1099          42 :   rep=isin_G_H(BR,42,33);
    1100          42 :   if (rep) goto IMPEVEN_8_14; else return 42;
    1101             : 
    1102             : IMPEVEN_8_9:
    1103         133 :   rep=isin_G_H(BR,41,34);
    1104         133 :   if (rep) goto IMPEVEN_8_7; else goto IMPEVEN_8_15;
    1105             : 
    1106             : IMPEVEN_8_10:
    1107          28 :   rep=isin_G_H(BR,32,22);
    1108          28 :   if (rep) goto IMPEVEN_8_16; else goto IMPEVEN_8_17;
    1109             : 
    1110             : IMPEVEN_8_11:
    1111          14 :   rep=isin_G_H(BR,39,29);
    1112          14 :   if (rep) goto IMPEVEN_8_18; else goto IMPEVEN_8_19;
    1113             : 
    1114             : IMPEVEN_8_12:
    1115          14 :   rep=isin_G_H(BR,14,4);
    1116          14 :   return rep? 4: 14;
    1117             : 
    1118             : IMPEVEN_8_14:
    1119          28 :   rep=isin_G_H(BR,33,18);
    1120          28 :   if (rep) goto IMPEVEN_8_21; else goto IMPEVEN_8_22;
    1121             : 
    1122             : IMPEVEN_8_15:
    1123         133 :   rep=isin_G_H(BR,41,33);
    1124         133 :   if (rep) goto IMPEVEN_8_14; else goto IMPEVEN_8_23;
    1125             : 
    1126             : IMPEVEN_8_16:
    1127          63 :   rep=isin_G_H(BR,22,11);
    1128          63 :   if (rep) goto IMPEVEN_8_24; else goto IMPEVEN_8_25;
    1129             : 
    1130             : IMPEVEN_8_17:
    1131          28 :   rep=isin_G_H(BR,32,13);
    1132          28 :   if (rep) goto IMPEVEN_8_26; else goto IMPEVEN_8_27;
    1133             : 
    1134             : IMPEVEN_8_18:
    1135         105 :   rep=isin_G_H(BR,29,22);
    1136         105 :   if (rep) goto IMPEVEN_8_16; else goto IMPEVEN_8_28;
    1137             : 
    1138             : IMPEVEN_8_19:
    1139          14 :   rep=isin_G_H(BR,39,24);
    1140          14 :   if (rep) goto IMPEVEN_8_29; else return 39;
    1141             : 
    1142             : IMPEVEN_8_20:
    1143          42 :   rep=isin_G_H(BR,9,4);
    1144          42 :   if (rep) return 4; else goto IMPEVEN_8_30;
    1145             : 
    1146             : IMPEVEN_8_21:
    1147          77 :   rep=isin_G_H(BR,18,10);
    1148          77 :   if (rep) goto IMPEVEN_8_31; else goto IMPEVEN_8_32;
    1149             : 
    1150             : IMPEVEN_8_22:
    1151          28 :   rep=isin_G_H(BR,33,13);
    1152          28 :   if (rep) goto IMPEVEN_8_26; else return 33;
    1153             : 
    1154             : IMPEVEN_8_23:
    1155         133 :   rep=isin_G_H(BR,41,29);
    1156         133 :   if (rep) goto IMPEVEN_8_18; else goto IMPEVEN_8_33;
    1157             : 
    1158             : IMPEVEN_8_24:
    1159          35 :   rep=isin_G_H(BR,11,5);
    1160          35 :   if (rep) return 5; else goto IMPEVEN_8_34;
    1161             : 
    1162             : IMPEVEN_8_25:
    1163          28 :   rep=isin_G_H(BR,22,9);
    1164          28 :   if (rep) goto IMPEVEN_8_20; else return 22;
    1165             : 
    1166             : IMPEVEN_8_26:
    1167          14 :   rep=isin_G_H(BR,13,3);
    1168          14 :   return rep? 3: 13;
    1169             : 
    1170             : IMPEVEN_8_27:
    1171          28 :   rep=isin_G_H(BR,32,12);
    1172          28 :   if (rep) goto IMPEVEN_8_35; else return 32;
    1173             : 
    1174             : IMPEVEN_8_28:
    1175          42 :   rep=isin_G_H(BR,29,20);
    1176          42 :   if (rep) goto IMPEVEN_8_36; else goto IMPEVEN_8_37;
    1177             : 
    1178             : IMPEVEN_8_29:
    1179          14 :   rep=isin_G_H(BR,24,14);
    1180          14 :   if (rep) goto IMPEVEN_8_12; else goto IMPEVEN_8_38;
    1181             : 
    1182             : IMPEVEN_8_30:
    1183          28 :   rep=isin_G_H(BR,9,3);
    1184          28 :   if (rep) return 3; else goto IMPEVEN_8_39;
    1185             : 
    1186             : IMPEVEN_8_31:
    1187          35 :   rep=isin_G_H(BR,10,2);
    1188          35 :   return rep? 2: 10;
    1189             : 
    1190             : IMPEVEN_8_32:
    1191          42 :   rep=isin_G_H(BR,18,9);
    1192          42 :   if (rep) goto IMPEVEN_8_20; else return 18;
    1193             : 
    1194             : IMPEVEN_8_33:
    1195          28 :   rep=isin_G_H(BR,41,24);
    1196          28 :   if (rep) goto IMPEVEN_8_29; else return 41;
    1197             : 
    1198             : IMPEVEN_8_34:
    1199          21 :   rep=isin_G_H(BR,11,4);
    1200          21 :   if (rep) return 4; else goto IMPEVEN_8_44;
    1201             : 
    1202             : IMPEVEN_8_35:
    1203          14 :   rep=isin_G_H(BR,12,5);
    1204          14 :   return rep? 5: 12;
    1205             : 
    1206             : IMPEVEN_8_36:
    1207          14 :   rep=isin_G_H(BR,20,10);
    1208          14 :   if (rep) goto IMPEVEN_8_31; else return 20;
    1209             : 
    1210             : IMPEVEN_8_37:
    1211          28 :   rep=isin_G_H(BR,29,19);
    1212          28 :   if (rep) goto IMPEVEN_8_40; else goto IMPEVEN_8_41;
    1213             : 
    1214             : IMPEVEN_8_38:
    1215          14 :   rep=isin_G_H(BR,24,13);
    1216          14 :   if (rep) goto IMPEVEN_8_26; else goto IMPEVEN_8_42;
    1217             : 
    1218             : IMPEVEN_8_39:
    1219          14 :   rep=isin_G_H(BR,9,2);
    1220          14 :   return rep? 2: 9;
    1221             : 
    1222             : IMPEVEN_8_40:
    1223          14 :   rep=isin_G_H(BR,19,10);
    1224          14 :   if (rep) goto IMPEVEN_8_31; else goto IMPEVEN_8_43;
    1225             : 
    1226             : IMPEVEN_8_41:
    1227          14 :   rep=isin_G_H(BR,29,18);
    1228          14 :   if (rep) goto IMPEVEN_8_21; else return 29;
    1229             : 
    1230             : IMPEVEN_8_42:
    1231          14 :   rep=isin_G_H(BR,24,9);
    1232          14 :   if (rep) goto IMPEVEN_8_20; else return 24;
    1233             : 
    1234             : IMPEVEN_8_43:
    1235          14 :   rep=isin_G_H(BR,19,9);
    1236          14 :   if (rep) goto IMPEVEN_8_20; else return 19;
    1237             : 
    1238             : IMPEVEN_8_44:
    1239          21 :   rep=isin_G_H(BR,11,2);
    1240          21 :   return rep? 2: 11;
    1241             : 
    1242             : IMPEVEN_8_45:
    1243          28 :   rep=isin_G_H(BR,34,14);
    1244          28 :   if (rep) goto IMPEVEN_8_12; else return 34;
    1245             : }
    1246             : 
    1247             : static long
    1248         742 : closure8(long EVEN, buildroot *BR)
    1249             : {
    1250             :   long rep;
    1251             : 
    1252         742 :   if (!EVEN)
    1253             :   {
    1254         350 :     rep=isin_G_H(BR,50,47);
    1255         350 :     if (rep) return galoisimpodd8(BR,47);
    1256          70 :     rep=isin_G_H(BR,50,44);
    1257          70 :     if (rep) return galoisimpodd8(BR,44);
    1258             :   }
    1259             :   else
    1260             :   {
    1261         392 :     rep=isin_G_H(BR,49,45);
    1262         392 :     if (rep) return galoisimpeven8(BR,45);
    1263          98 :     rep=isin_G_H(BR,49,39);
    1264          98 :     if (rep) return galoisimpeven8(BR,39);
    1265             :   }
    1266          70 :   return galoisprim8(EVEN, BR);
    1267             : }
    1268             : 
    1269             : static GROUP
    1270       11858 : initgroup(long n, long nbgr)
    1271             : {
    1272       11858 :   GROUP t = allocgroup(n,nbgr);
    1273       11858 :   PERM ID =  t[1];
    1274             :   long i;
    1275       11858 :   for (i = 1; i <= n; i++) ID[i] = i;
    1276       11858 :   return t;
    1277             : }
    1278             : 
    1279             : static PERM
    1280        5474 : data8(long N, long n1, long n2, GROUP *t)
    1281             : {
    1282        5474 :   switch(n1)
    1283             :   {
    1284          49 :     case 7: if (n2!=1) break;
    1285          49 :       *t=initgroup(N,2);
    1286          49 :       _aff(N, (*t)[2], 1, 2, 3, 4, 6, 5, 8, 7);
    1287          49 :       return (*t)[1];
    1288          84 :     case 9: if (n2!=4) break;
    1289          42 :       *t=initgroup(N,2);
    1290          42 :       _aff(N, (*t)[2], 1, 2, 4, 3, 5, 6, 8, 7);
    1291          42 :       return (*t)[1];
    1292          35 :     case 10: if (n2!=2) break;
    1293          35 :       *t=initgroup(N,2);
    1294          35 :       _aff(N, (*t)[2], 1, 2, 3, 4, 6, 5, 8, 7);
    1295          35 :       return (*t)[1];
    1296             :     case 11:
    1297          77 :       switch(n2)
    1298             :       {
    1299             :         case 2:
    1300          21 :           *t=initgroup(N,2);
    1301          21 :           _aff(N, (*t)[2], 1, 2, 5, 6, 3, 4, 8, 7);
    1302          21 :           return _cr(N, 1, 3, 5, 8, 2, 4, 6, 7);
    1303             :         case 4:
    1304          21 :           *t=initgroup(N,1);
    1305          21 :           return _cr(N, 1, 3, 7, 5, 2, 4, 8, 6);
    1306          35 :       }break;
    1307          14 :     case 14: if (n2!=4) break;
    1308          14 :       *t=initgroup(N,1);
    1309          14 :       return _cr(N, 1, 2, 4, 3, 5, 6, 8, 7);
    1310         196 :     case 15: if (n2!=6 && n2!=8) break;
    1311         126 :       *t=initgroup(N,2);
    1312         126 :       _aff(N, (*t)[2], 1, 2, 3, 4, 6, 5, 8, 7);
    1313         126 :       return (*t)[1];
    1314          63 :     case 16: if (n2!=7) break;
    1315          63 :       *t=initgroup(N,2);
    1316          63 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1317          63 :       return (*t)[1];
    1318             :     case 18:
    1319         119 :       switch(n2)
    1320             :       {
    1321          42 :         case 9: *t=initgroup(N,3);
    1322          42 :           _aff(N, (*t)[2], 1, 5, 3, 7, 2, 6, 4, 8);
    1323          42 :           _aff(N, (*t)[3], 1, 2, 3, 4, 6, 5, 8, 7);
    1324          42 :           return (*t)[1];
    1325          77 :         case 10: *t=initgroup(N,3);
    1326          77 :           _aff(N, (*t)[2], 1, 6, 3, 8, 2, 5, 4, 7);
    1327          77 :           _aff(N, (*t)[3], 1, 5, 3, 7, 2, 6, 4, 8);
    1328          77 :           return (*t)[1];
    1329           0 :       }break;
    1330          28 :     case 19: if (n2!=9) break;
    1331          14 :       *t=initgroup(N,1);
    1332          14 :       return _cr(N, 1, 5, 3, 8, 2, 6, 4, 7);
    1333          14 :     case 20: if (n2!=10) break;
    1334          14 :       *t=initgroup(N,2);
    1335          14 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1336          14 :       return (*t)[1];
    1337             :     case 22:
    1338          91 :       switch(n2)
    1339             :       {
    1340          28 :         case 9: *t=initgroup(N,6);
    1341          28 :           _aff(N, (*t)[2], 1, 2, 7, 8, 3, 4, 6, 5);
    1342          28 :           _aff(N, (*t)[3], 1, 2, 7, 8, 3, 4, 5, 6);
    1343          28 :           _aff(N, (*t)[4], 1, 2, 5, 6, 3, 4, 8, 7);
    1344          28 :           _aff(N, (*t)[5], 1, 2, 5, 6, 3, 4, 7, 8);
    1345          28 :           _aff(N, (*t)[6], 1, 2, 3, 4, 5, 6, 8, 7);
    1346          28 :           return _cr(N, 1, 3, 5, 7, 2, 4, 6, 8);
    1347          63 :         case 11: *t=initgroup(N,6);
    1348          63 :           _aff(N, (*t)[2], 1, 2, 5, 6, 7, 8, 4, 3);
    1349          63 :           _aff(N, (*t)[3], 1, 2, 5, 6, 7, 8, 3, 4);
    1350          63 :           _aff(N, (*t)[4], 1, 2, 3, 4, 7, 8, 6, 5);
    1351          63 :           _aff(N, (*t)[5], 1, 2, 3, 4, 7, 8, 5, 6);
    1352          63 :           _aff(N, (*t)[6], 1, 2, 3, 4, 5, 6, 8, 7);
    1353          63 :           return (*t)[1];
    1354           0 :       }break;
    1355          14 :     case 23: if (n2!=8) break;
    1356          14 :       *t=initgroup(N,1);
    1357          14 :       return _cr(N, 1, 2, 3, 4, 6, 5, 8, 7);
    1358         280 :     case 26: if (n2!=15 && n2!=17) break;
    1359         182 :       *t=initgroup(N,2);
    1360         182 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1361         182 :       return (*t)[1];
    1362         168 :     case 28: if (n2!=21) break;
    1363          91 :       *t=initgroup(N,1);
    1364          91 :       return _cr(N, 1, 2, 3, 4, 7, 8, 5, 6);
    1365         189 :     case 29: if (n2!=18 && n2!=19) break;
    1366          42 :       *t=initgroup(N,2);
    1367          42 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1368          42 :       return (*t)[1];
    1369          14 :     case 30: if (n2!=21) break;
    1370          14 :       *t=initgroup(N,1);
    1371          14 :       return _cr(N, 1, 2, 3, 4, 7, 8, 5, 6);
    1372          21 :     case 31: if (n2!=21) break;
    1373          21 :       *t=initgroup(N,3);
    1374          21 :       _aff(N, (*t)[2], 1, 2, 3, 4, 7, 8, 5, 6);
    1375          21 :       _aff(N, (*t)[3], 1, 2, 5, 6, 7, 8, 3, 4);
    1376          21 :       return (*t)[1];
    1377          84 :     case 32: if (n2!=12 && n2!=13) break;
    1378          56 :       *t=initgroup(N,2);
    1379          56 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1380          56 :       return (*t)[1];
    1381             :     case 33:
    1382          56 :       switch(n2)
    1383             :       {
    1384          28 :         case 13: *t=initgroup(N,1);
    1385          28 :           return _cr(N, 1, 5, 2, 6, 3, 7, 4, 8);
    1386          28 :         case 18: *t=initgroup(N,1);
    1387          28 :           return _cr(N, 1, 2, 5, 6, 3, 4, 7, 8);
    1388           0 :       }break;
    1389             :     case 34:
    1390         133 :       switch(n2)
    1391             :       {
    1392          28 :         case 14: *t=initgroup(N,3);
    1393          28 :           _aff(N, (*t)[2], 1, 2, 3, 4, 5, 8, 6, 7);
    1394          28 :           _aff(N, (*t)[3], 1, 2, 3, 4, 5, 7, 8, 6);
    1395          28 :           return _cr(N, 1, 5, 2, 6, 3, 7, 4, 8);
    1396         105 :         case 18: *t=initgroup(N,1);
    1397         105 :           return _cr(N, 1, 2, 5, 6, 3, 4, 8, 7);
    1398           0 :       }break;
    1399          70 :     case 39: if (n2!=24) break;
    1400          14 :       *t=initgroup(N,2);
    1401          14 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1402          14 :       return (*t)[1];
    1403          56 :     case 40: if (n2!=23) break;
    1404          28 :       *t=initgroup(N,2);
    1405          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1406          28 :       return (*t)[1];
    1407             :     case 41:
    1408         427 :       switch(n2)
    1409             :       {
    1410          28 :         case 24: *t=initgroup(N,1);
    1411          28 :           return _cr(N, 1, 5, 2, 6, 3, 7, 4, 8);
    1412         133 :         case 29: *t=initgroup(N,1);
    1413         133 :           return _cr(N, 1, 2, 5, 6, 3, 4, 7, 8);
    1414         266 :       }break;
    1415         189 :     case 42: if (n2!=34) break;
    1416         147 :       *t=initgroup(N,1);
    1417         147 :       return _cr(N, 1, 2, 3, 4, 5, 6, 8, 7);
    1418         441 :     case 45: if (n2!=41 && n2!=42) break;
    1419         441 :       *t=initgroup(N,2);
    1420         441 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1421         441 :       return (*t)[1];
    1422         105 :     case 46: if (n2!=28) break;
    1423         105 :       *t=initgroup(N,1);
    1424         105 :       return _cr(N, 1, 2, 5, 6, 3, 4, 7, 8);
    1425         455 :     case 47: if (n2!=35) break;
    1426         175 :       *t=initgroup(N,1);
    1427         175 :       return _cr(N, 1, 2, 5, 6, 3, 4, 7, 8);
    1428         532 :     case 49: if (n2!=48) break;
    1429          42 :       *t=initgroup(N,2);
    1430          42 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 7);
    1431          42 :       return (*t)[1];
    1432             :   }
    1433        3143 :   *t=initgroup(N,1); return (*t)[1];
    1434             : }
    1435             : 
    1436             : static long
    1437         770 : galoismodulo8(long EVEN, GEN pol, GEN dpol)
    1438             : {
    1439             :   long res, gr[51];
    1440         770 :   pari_sp av = avma;
    1441         770 :   long **GR = (long**)cgeti(49);
    1442         770 :   GEN TYP = partitions_galois(8);
    1443             : 
    1444             : /* List of possible types in group j: GR[j][0] = #GR[j] if
    1445             :  * the group is odd, - #GR[j] if even */
    1446         770 :   GR[ 1]= _gr(  4, 1,5,15,22);
    1447         770 :   GR[ 2]= _gr( -3, 1,5,15);
    1448         770 :   GR[ 3]= _gr( -2, 1,5);
    1449         770 :   GR[ 4]= _gr( -3, 1,5,15);
    1450         770 :   GR[ 5]= _gr( -3, 1,5,15);
    1451         770 :   GR[ 6]= _gr(  5, 1,4,5,15,22);
    1452         770 :   GR[ 7]= _gr(  5, 1,3,5,15,22);
    1453         770 :   GR[ 8]= _gr(  5, 1,4,5,15,22);
    1454         770 :   GR[ 9]= _gr( -4, 1,3,5,15);
    1455         770 :   GR[10]= _gr( -4, 1,3,5,15);
    1456         770 :   GR[11]= _gr( -4, 1,3,5,15);
    1457         770 :   GR[12]= _gr( -5, 1,5,9,15,20);
    1458         770 :   GR[13]= _gr( -4, 1,5,9,20);
    1459         770 :   GR[14]= _gr( -4, 1,5,9,15);
    1460         770 :   GR[15]= _gr(  6, 1,3,4,5,15,22);
    1461         770 :   GR[16]= _gr(  5, 1,3,5,15,22);
    1462         770 :   GR[17]= _gr(  7, 1,3,5,11,13,15,22);
    1463         770 :   GR[18]= _gr( -4, 1,3,5,15);
    1464         770 :   GR[19]= _gr( -5, 1,3,5,12,15);
    1465         770 :   GR[20]= _gr( -4, 1,3,5,15);
    1466         770 :   GR[21]= _gr(  5, 1,3,5,13,15);
    1467         770 :   GR[22]= _gr( -4, 1,3,5,15);
    1468         770 :   GR[23]= _gr(  7, 1,4,5,9,15,20,22);
    1469         770 :   GR[24]= _gr( -6, 1,3,5,9,15,20);
    1470         770 :   GR[25]= _gr( -3, 1,5,21);
    1471         770 :   GR[26]= _gr(  8, 1,3,4,5,11,13,15,22);
    1472         770 :   GR[27]= _gr(  8, 1,2,3,4,5,13,15,22);
    1473         770 :   GR[28]= _gr(  7, 1,3,5,12,13,15,22);
    1474         770 :   GR[29]= _gr( -5, 1,3,5,12,15);
    1475         770 :   GR[30]= _gr(  7, 1,3,4,5,11,13,15);
    1476         770 :   GR[31]= _gr(  7, 1,2,3,4,5,13,15);
    1477         770 :   GR[32]= _gr( -6, 1,3,5,9,15,20);
    1478         770 :   GR[33]= _gr( -6, 1,3,5,9,15,20);
    1479         770 :   GR[34]= _gr( -5, 1,3,5,9,15);
    1480         770 :   GR[35]= _gr( 10, 1,2,3,4,5,11,12,13,15,22);
    1481         770 :   GR[36]= _gr( -5, 1,5,9,20,21);
    1482         770 :   GR[37]= _gr( -5, 1,5,9,15,21);
    1483         770 :   GR[38]= _gr( 11, 1,2,3,4,5,9,10,13,15,19,20);
    1484         770 :   GR[39]= _gr( -7, 1,3,5,9,12,15,20);
    1485         770 :   GR[40]= _gr( 10, 1,3,4,5,9,11,13,15,20,22);
    1486         770 :   GR[41]= _gr( -7, 1,3,5,9,12,15,20);
    1487         770 :   GR[42]= _gr( -8, 1,3,5,6,8,9,15,20);
    1488         770 :   GR[43]= _gr(  8, 1,4,5,9,15,19,21,22);
    1489         770 :   GR[44]= _gr( 14, 1,2,3,4,5,9,10,11,12,13,15,19,20,22);
    1490         770 :   GR[45]= _gr( -9, 1,3,5,6,8,9,12,15,20);
    1491         770 :   GR[46]= _gr( 10, 1,3,5,6,8,9,12,13,15,22);
    1492         770 :   GR[47]= _gr( 16, 1,2,3,4,5,6,7,8,9,11,12,13,14,15,20,22);
    1493         770 :   GR[48]= _gr( -8, 1,3,5,9,12,15,20,21);
    1494             : 
    1495         770 :   gr[0]=51; res = galmodp(EVEN,pol,dpol,TYP,gr,GR);
    1496         770 :   avma=av; if (!res) return 0;
    1497          28 :   return EVEN? 49: 50;
    1498             : }
    1499             : 
    1500             : /* DEGREE 9 */
    1501             : static long
    1502         126 : galoisprim9(long EVEN, buildroot *BR)
    1503             : {
    1504             :   long rep;
    1505             : 
    1506         126 :   if (!EVEN)
    1507             :   {
    1508          56 :     rep=isin_G_H(BR,34,26);
    1509          56 :     if (!rep) return 34;
    1510          56 :     rep=isin_G_H(BR,26,19);
    1511          56 :     if (!rep) return 26;
    1512          42 :     rep=isin_G_H(BR,19,16);
    1513          42 :     if (rep) return 16;
    1514          28 :     rep=isin_G_H(BR,19,15);
    1515          28 :     return rep? 15: 19;
    1516             :   }
    1517          70 :   rep=isin_G_H(BR,33,32);
    1518          70 :   if (!rep) goto PRIM_9_7;
    1519          28 :   rep=isin_G_H(BR,32,27);
    1520          28 :   return rep? 27: 32;
    1521             : 
    1522             : PRIM_9_7:
    1523          42 :   rep=isin_G_H(BR,33,23);
    1524          42 :   if (!rep) return 33;
    1525          42 :   rep=isin_G_H(BR,23,14);
    1526          42 :   if (!rep) return 23;
    1527          28 :   rep=isin_G_H(BR,14,9);
    1528          28 :   return rep? 9: 14;
    1529             : }
    1530             : 
    1531             : static long
    1532         154 : galoisimpodd9(buildroot *BR)
    1533             : {
    1534             :   long rep;
    1535             : 
    1536         154 :   rep=isin_G_H(BR,31,29);
    1537         154 :   if (!rep) goto IMPODD_9_5;
    1538          49 :   rep=isin_G_H(BR,29,20);
    1539          49 :   if (!rep) return 29;
    1540             : IMPODD_9_3:
    1541          35 :   rep=isin_G_H(BR,20,12);
    1542          35 :   if (!rep) return 20;
    1543             : IMPODD_9_4:
    1544          21 :   rep=isin_G_H(BR,12,4);
    1545          21 :   return rep? 4: 12;
    1546             : 
    1547             : IMPODD_9_5:
    1548         105 :   rep=isin_G_H(BR,31,28);
    1549         105 :   if (!rep) goto IMPODD_9_9;
    1550          49 :   rep=isin_G_H(BR,28,22);
    1551          49 :   if (!rep) return 28;
    1552             : IMPODD_9_7:
    1553          35 :   rep=isin_G_H(BR,22,13);
    1554          35 :   if (!rep) return 22;
    1555             : IMPODD_9_8:
    1556          21 :   rep=isin_G_H(BR,13,4);
    1557          21 :   return rep? 4: 13;
    1558             : 
    1559             : IMPODD_9_9:
    1560          56 :   rep=isin_G_H(BR,31,24);
    1561          56 :   if (!rep) return 31;
    1562          42 :   rep=isin_G_H(BR,24,22);
    1563          42 :   if (rep) goto IMPODD_9_7;
    1564          42 :   rep=isin_G_H(BR,24,20);
    1565          42 :   if (rep) goto IMPODD_9_3;
    1566          42 :   rep=isin_G_H(BR,24,18);
    1567          42 :   if (!rep) return 24;
    1568          28 :   rep=isin_G_H(BR,18,13);
    1569          28 :   if (rep) goto IMPODD_9_8;
    1570          28 :   rep=isin_G_H(BR,18,12);
    1571          28 :   if (rep) goto IMPODD_9_4;
    1572          28 :   rep=isin_G_H(BR,18,8);
    1573          28 :   if (!rep) return 18;
    1574          14 :   rep=isin_G_H(BR,8,4);
    1575          14 :   return rep? 4: 8;
    1576             : }
    1577             : 
    1578             : static long
    1579         168 : galoisimpeven9(buildroot *BR)
    1580             : {
    1581             :   long rep;
    1582             : 
    1583         168 :   rep=isin_G_H(BR,30,25);
    1584         168 :   if (!rep) goto IMPEVEN_9_7;
    1585          84 :   rep=isin_G_H(BR,25,17);
    1586          84 :   if (!rep) return 25;
    1587             : IMPEVEN_9_3:
    1588          70 :   rep=isin_G_H(BR,17,7);
    1589          70 :   if (!rep) goto IMPEVEN_9_5;
    1590             : IMPEVEN_9_4:
    1591          28 :   rep=isin_G_H(BR,7,2);
    1592          28 :   return rep? 2: 7;
    1593             : 
    1594             : IMPEVEN_9_5:
    1595          42 :   rep=isin_G_H(BR,17,6);
    1596          42 :   if (!rep) return 17;
    1597             : IMPEVEN_9_6:
    1598          28 :   rep=isin_G_H(BR,6,1);
    1599          28 :   return rep? 1: 6;
    1600             : 
    1601             : IMPEVEN_9_7:
    1602          84 :   rep=isin_G_H(BR,30,21);
    1603          84 :   if (!rep) return 30;
    1604          70 :   rep=isin_G_H(BR,21,17);
    1605          70 :   if (rep) goto IMPEVEN_9_3;
    1606          70 :   rep=isin_G_H(BR,21,11);
    1607          70 :   if (!rep) goto IMPEVEN_9_13;
    1608          28 :   rep=isin_G_H(BR,11,7);
    1609          28 :   if (rep) goto IMPEVEN_9_4;
    1610          28 :   rep=isin_G_H(BR,11,5);
    1611          28 :   if (!rep) return 11;
    1612          14 :   rep=isin_G_H(BR,5,2);
    1613          14 :   return rep? 2: 5;
    1614             : 
    1615             : IMPEVEN_9_13:
    1616          42 :   rep=isin_G_H(BR,21,10);
    1617          42 :   if (!rep) return 21;
    1618          28 :   rep=isin_G_H(BR,10,6);
    1619          28 :   if (rep) goto IMPEVEN_9_6;
    1620          28 :   rep=isin_G_H(BR,10,3);
    1621          28 :   if (!rep) return 10;
    1622          14 :   rep=isin_G_H(BR,3,1);
    1623          14 :   return rep? 1: 3;
    1624             : }
    1625             : 
    1626             : static long
    1627         448 : closure9(long EVEN, buildroot *BR)
    1628             : {
    1629             :   long rep;
    1630         448 :   if (!EVEN)
    1631             :   {
    1632         210 :     rep=isin_G_H(BR,34,31);
    1633         210 :     if (rep) return galoisimpodd9(BR);
    1634             :   }
    1635             :   else
    1636             :   {
    1637         238 :     rep=isin_G_H(BR,33,30);
    1638         238 :     if (rep) return galoisimpeven9(BR);
    1639             :   }
    1640         126 :   return galoisprim9(EVEN, BR);
    1641             : }
    1642             : 
    1643             : static PERM
    1644        2415 : data9(long N, long n1, long n2, GROUP *t)
    1645             : {
    1646        2415 :   switch(n1)
    1647             :   {
    1648          28 :     case 6: if (n2!=1) break;
    1649          28 :       *t=initgroup(N,3);
    1650          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 9, 7);
    1651          28 :       _aff(N, (*t)[3], 1, 2, 3, 4, 5, 6, 9, 7, 8);
    1652          28 :       return (*t)[1];
    1653          28 :     case 7: if (n2!=2) break;
    1654          28 :       *t=initgroup(N,3);
    1655          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 9, 7);
    1656          28 :       _aff(N, (*t)[3], 1, 2, 3, 4, 5, 6, 9, 7, 8);
    1657          28 :       return (*t)[1];
    1658          14 :     case 8: if (n2!=4) break;
    1659          14 :       *t=initgroup(N,2);
    1660          14 :       _aff(N, (*t)[2], 1, 4, 7, 2, 5, 8, 3, 6, 9);
    1661          14 :       return (*t)[1];
    1662          21 :     case 12: if (n2!=4) break;
    1663          21 :       *t=initgroup(N,3);
    1664          21 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 9, 7);
    1665          21 :       _aff(N, (*t)[3], 1, 2, 3, 4, 5, 6, 9, 7, 8);
    1666          21 :       return (*t)[1];
    1667          21 :     case 13: if (n2!=4) break;
    1668          21 :       *t=initgroup(N,1);
    1669          21 :       return _cr(N, 1, 4, 7, 2, 5, 8, 3, 6, 9);
    1670          28 :     case 14: if (n2!=9) break;
    1671          28 :       *t=initgroup(N,3);
    1672          28 :       _aff(N, (*t)[2], 1, 2, 3, 5, 6, 4, 9, 7, 8);
    1673          28 :       _aff(N, (*t)[3], 1, 2, 3, 6, 4, 5, 8, 9, 7);
    1674          28 :       return (*t)[1];
    1675         112 :     case 17: if (n2!=6) break;
    1676          42 :       *t=initgroup(N,2);
    1677          42 :       _aff(N, (*t)[2], 1, 2, 3, 7, 8, 9, 4, 5, 6);
    1678          42 :       return (*t)[1];
    1679         182 :     case 21: if (n2!=10) break;
    1680          42 :       *t=initgroup(N,2);
    1681          42 :       _aff(N, (*t)[2], 1, 2, 3, 7, 8, 9, 4, 5, 6);
    1682          42 :       return (*t)[1];
    1683         350 :     case 33: if (n2!=32) break;
    1684          70 :       *t=initgroup(N,2);
    1685          70 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 7, 9, 8);
    1686          70 :       return (*t)[1];
    1687             :   }
    1688        2121 :   *t=initgroup(N,1); return (*t)[1];
    1689             : }
    1690             : 
    1691             : static long
    1692         476 : galoismodulo9(long EVEN, GEN pol, GEN dpol)
    1693             : {
    1694             :   long res, gr[35];
    1695         476 :   pari_sp av = avma;
    1696         476 :   long **GR = (long**) cgeti(33);
    1697         476 :   GEN TYP = partitions_galois(9);
    1698             : 
    1699             :   /* 42 TYPES ORDONNES CROISSANT (T[1],...,T[30])*/
    1700             : 
    1701         476 :   GR[ 1]= _gr( -3, 1,12,30);
    1702         476 :   GR[ 2]= _gr( -2, 1,12);
    1703         476 :   GR[ 3]= _gr( -4, 1,5,12,30);
    1704         476 :   GR[ 4]= _gr(  4, 1,4,12,26);
    1705         476 :   GR[ 5]= _gr( -3, 1,5,12);
    1706         476 :   GR[ 6]= _gr( -4, 1,10,12,30);
    1707         476 :   GR[ 7]= _gr( -3, 1,10,12);
    1708         476 :   GR[ 8]= _gr(  5, 1,4,5,12,26);
    1709         476 :   GR[ 9]= _gr( -4, 1,5,12,18);
    1710         476 :   GR[10]= _gr( -6, 1,5,10,12,25,30);
    1711         476 :   GR[11]= _gr( -5, 1,5,10,12,25);
    1712         476 :   GR[12]= _gr(  5, 1,4,10,12,26);
    1713         476 :   GR[13]= _gr(  5, 1,4,10,12,26);
    1714         476 :   GR[14]= _gr( -4, 1,5,12,18);
    1715         476 :   GR[15]= _gr(  5, 1,5,12,18,29);
    1716         476 :   GR[16]= _gr(  6, 1,4,5,12,18,26);
    1717         476 :   GR[17]= _gr( -5, 1,6,10,12,30);
    1718         476 :   GR[18]= _gr(  7, 1,4,5,10,12,25,26);
    1719         476 :   GR[19]= _gr(  7, 1,4,5,12,18,26,29);
    1720         476 :   GR[20]= _gr(  9, 1,4,6,9,10,12,24,26,30);
    1721         476 :   GR[21]= _gr( -7, 1,5,6,10,12,25,30);
    1722         476 :   GR[22]= _gr(  7, 1,4,6,10,12,26,30);
    1723         476 :   GR[23]= _gr( -6, 1,5,10,12,18,25);
    1724         476 :   GR[24]= _gr( 11, 1,4,5,6,9,10,12,24,25,26,30);
    1725         476 :   GR[25]= _gr( -7, 1,3,6,8,10,12,30);
    1726         476 :   GR[26]= _gr(  9, 1,4,5,10,12,18,25,26,29);
    1727         476 :   GR[27]= _gr( -5, 1,5,12,27,30);
    1728         476 :   GR[28]= _gr( 12, 1,2,3,4,6,7,8,10,11,12,26,30);
    1729         476 :   GR[29]= _gr( 12, 1,3,4,6,8,9,10,12,15,24,26,30);
    1730         476 :   GR[30]= _gr(-11, 1,3,5,6,8,10,12,14,17,25,30);
    1731         476 :   GR[31]= _gr( 19, 1,2,3,4,5,6,7,8,9,10,11,12,14,15,17,24,25,26,30);
    1732         476 :   GR[32]= _gr( -7, 1,5,10,12,25,27,30);
    1733             : 
    1734         476 :   gr[0]=35; res = galmodp(EVEN,pol,dpol,TYP,gr,GR);
    1735         476 :   avma=av; if (!res) return 0;
    1736          28 :   return EVEN? 33: 34;
    1737             : }
    1738             : 
    1739             : /* DEGREE 10 */
    1740             : static long
    1741          98 : galoisprim10(long EVEN, buildroot *BR)
    1742             : {
    1743             :   long rep;
    1744          98 :   if (EVEN)
    1745             :   {
    1746          42 :     rep=isin_G_H(BR,44,31);
    1747          42 :     if (!rep) return 44;
    1748          42 :     rep=isin_G_H(BR,31,26);
    1749          42 :     if (!rep) return 31;
    1750          28 :     rep=isin_G_H(BR,26,7);
    1751          28 :     return rep? 7: 26;
    1752             :   }
    1753             :   else
    1754             :   {
    1755          56 :     rep=isin_G_H(BR,45,35);
    1756          56 :     if (!rep) return 45;
    1757          56 :     rep=isin_G_H(BR,35,32);
    1758          56 :     if (!rep) goto PRIM_10_7;
    1759          28 :     rep=isin_G_H(BR,32,13);
    1760          28 :     return rep? 13: 32;
    1761             : 
    1762             :    PRIM_10_7:
    1763          28 :     rep=isin_G_H(BR,35,30);
    1764          28 :     return rep? 30: 35;
    1765             :   }
    1766             : }
    1767             : 
    1768             : static long
    1769         112 : galoisimpeven10(buildroot *BR, long nogr)
    1770             : {
    1771             :   long rep;
    1772         112 :   if (nogr==42)
    1773             :   {
    1774          42 :     rep=isin_G_H(BR,42,28);
    1775          42 :     if (!rep) return 42;
    1776          28 :     rep=isin_G_H(BR,28,18);
    1777          28 :     return rep? 18: 28;
    1778             :   }
    1779             :   else
    1780             :   {
    1781          70 :     rep=isin_G_H(BR,37,34);
    1782          70 :     if (!rep) goto IMPEVEN_10_5;
    1783          42 :     rep=isin_G_H(BR,34,15);
    1784          42 :     if (rep) goto IMPEVEN_10_7; else return 34;
    1785             : 
    1786             :   IMPEVEN_10_5:
    1787          28 :     rep=isin_G_H(BR,37,24);
    1788          28 :     if (!rep) return 37;
    1789          14 :     rep=isin_G_H(BR,24,15);
    1790          14 :     if (!rep) return 24;
    1791             :   IMPEVEN_10_7:
    1792          28 :     rep=isin_G_H(BR,15,8);
    1793          28 :     return rep? 8: 15;
    1794             :   }
    1795             : }
    1796             : 
    1797             : static long
    1798         399 : galoisimpodd10(buildroot *BR, long nogr)
    1799             : {
    1800             :   long rep;
    1801         399 :   if (nogr==43)
    1802             :   {
    1803         287 :     rep=isin_G_H(BR,43,41);
    1804         287 :     if (!rep) goto IMPODD_10_3;
    1805         259 :     rep=isin_G_H(BR,41,40);
    1806         259 :     if (rep) goto IMPODD_10_4; else goto IMPODD_10_5;
    1807             : 
    1808             :    IMPODD_10_3:
    1809          28 :     rep=isin_G_H(BR,43,33);
    1810          28 :     if (rep) goto IMPODD_10_6; else return 43;
    1811             : 
    1812             :    IMPODD_10_4:
    1813         161 :     rep=isin_G_H(BR,40,21);
    1814         161 :     if (rep) goto IMPODD_10_7; else goto IMPODD_10_8;
    1815             : 
    1816             :    IMPODD_10_5:
    1817          98 :     rep=isin_G_H(BR,41,27);
    1818          98 :     if (rep) goto IMPODD_10_9; else goto IMPODD_10_10;
    1819             : 
    1820             :    IMPODD_10_6:
    1821          14 :     rep=isin_G_H(BR,33,27);
    1822          14 :     if (rep) goto IMPODD_10_9; else return 33;
    1823             : 
    1824             :    IMPODD_10_7:
    1825         119 :     rep=isin_G_H(BR,21,10);
    1826         119 :     if (rep) goto IMPODD_10_12; else goto IMPODD_10_13;
    1827             : 
    1828             :    IMPODD_10_8:
    1829          42 :     rep=isin_G_H(BR,40,12);
    1830          42 :     if (rep) goto IMPODD_10_14; else goto IMPODD_10_15;
    1831             : 
    1832             :    IMPODD_10_9:
    1833          70 :     rep=isin_G_H(BR,27,21);
    1834          70 :     if (rep) goto IMPODD_10_7; else goto IMPODD_10_16;
    1835             : 
    1836             :    IMPODD_10_10:
    1837          28 :     rep=isin_G_H(BR,41,22);
    1838          28 :     if (!rep) return 41;
    1839          14 :     rep=isin_G_H(BR,22,12);
    1840          14 :     if (rep) goto IMPODD_10_14; else goto IMPODD_10_18;
    1841             : 
    1842             :    IMPODD_10_12:
    1843          28 :     rep=isin_G_H(BR,10,4);
    1844          28 :     return rep? 4: 10;
    1845             : 
    1846             :    IMPODD_10_13:
    1847          91 :     rep=isin_G_H(BR,21,9);
    1848          91 :     if (rep) goto IMPODD_10_19; else return 21;
    1849             :    IMPODD_10_14:
    1850          14 :     rep=isin_G_H(BR,12,4);
    1851          14 :     return rep? 4: 12;
    1852             : 
    1853             :    IMPODD_10_15:
    1854          28 :     rep=isin_G_H(BR,40,11);
    1855          28 :     if (rep) goto IMPODD_10_20; else return 40;
    1856             :    IMPODD_10_16:
    1857          70 :     rep=isin_G_H(BR,27,20);
    1858          70 :     if (!rep) goto IMPODD_10_21;
    1859          14 :     rep=isin_G_H(BR,20,10);
    1860          14 :     if (rep) goto IMPODD_10_12; return 20;
    1861             : 
    1862             :    IMPODD_10_18:
    1863          14 :     rep=isin_G_H(BR,22,11);
    1864          14 :     if (rep) goto IMPODD_10_20; else goto IMPODD_10_23;
    1865             : 
    1866             :    IMPODD_10_19:
    1867          77 :     rep=isin_G_H(BR,9,6);
    1868          77 :     if (rep) goto IMPODD_10_24; else goto IMPODD_10_25;
    1869             : 
    1870             :    IMPODD_10_20:
    1871          14 :     rep=isin_G_H(BR,11,3);
    1872          14 :     if (rep) goto IMPODD_10_26; else return 11;
    1873             : 
    1874             :    IMPODD_10_21:
    1875          56 :     rep=isin_G_H(BR,27,19);
    1876          56 :     if (rep) goto IMPODD_10_27;
    1877          42 :     rep=isin_G_H(BR,27,17);
    1878          42 :     if (rep) goto IMPODD_10_28; else return 27;
    1879             : 
    1880             :    IMPODD_10_23:
    1881          14 :     rep=isin_G_H(BR,22,5);
    1882          14 :     if (rep) goto IMPODD_10_29; else return 22;
    1883             : 
    1884             :    IMPODD_10_24:
    1885          49 :     rep=isin_G_H(BR,6,2);
    1886          49 :     if (rep) return 2; else goto IMPODD_10_30;
    1887             : 
    1888             :    IMPODD_10_25:
    1889          28 :     rep=isin_G_H(BR,9,3);
    1890          28 :     if (!rep) return 9;
    1891             :    IMPODD_10_26:
    1892          14 :     rep=isin_G_H(BR,3,2);
    1893          14 :     if (rep) return 2; else goto IMPODD_10_31;
    1894             : 
    1895             :    IMPODD_10_27:
    1896          14 :     rep=isin_G_H(BR,19,9);
    1897          14 :     if (rep) goto IMPODD_10_19; else return 19;
    1898             : 
    1899             :    IMPODD_10_28:
    1900          28 :     rep=isin_G_H(BR,17,10);
    1901          28 :     if (rep) goto IMPODD_10_12; else goto IMPODD_10_32;
    1902             : 
    1903             :    IMPODD_10_29:
    1904          14 :     rep=isin_G_H(BR,5,4);
    1905          14 :     if (rep) return 4; else goto IMPODD_10_33;
    1906             : 
    1907             :    IMPODD_10_30:
    1908          35 :     rep=isin_G_H(BR,6,1);
    1909          35 :     return rep? 1: 6;
    1910             : 
    1911             :    IMPODD_10_31:
    1912          14 :     rep=isin_G_H(BR,3,1);
    1913          14 :     return rep? 1: 3;
    1914             : 
    1915             :    IMPODD_10_32:
    1916          28 :     rep=isin_G_H(BR,17,9);
    1917          28 :     if (rep) goto IMPODD_10_19; else goto IMPODD_10_60;
    1918             : 
    1919             :    IMPODD_10_33:
    1920          14 :     rep=isin_G_H(BR,5,3);
    1921          14 :     if (rep) goto IMPODD_10_26; else return 5;
    1922             : 
    1923             :    IMPODD_10_60:
    1924          28 :     rep=isin_G_H(BR,17,5);
    1925          28 :     if (rep) goto IMPODD_10_29; else return 17;
    1926             :   }
    1927             :   else
    1928             :   {
    1929         112 :     rep=isin_G_H(BR,39,38);
    1930         112 :     if (!rep) goto IMPODD_10_36;
    1931          28 :     rep=isin_G_H(BR,38,25);
    1932          28 :     if (rep) goto IMPODD_10_37; else goto IMPODD_10_38;
    1933             : 
    1934             :    IMPODD_10_36:
    1935          84 :     rep=isin_G_H(BR,39,36);
    1936          84 :     if (rep) goto IMPODD_10_39; else goto IMPODD_10_40;
    1937             : 
    1938             :    IMPODD_10_37:
    1939          14 :     rep=isin_G_H(BR,25,4);
    1940          14 :     return rep? 4: 25;
    1941             : 
    1942             :    IMPODD_10_38:
    1943          14 :     rep=isin_G_H(BR,38,12);
    1944          14 :     if (rep) goto IMPODD_10_41; else return 38;
    1945             : 
    1946             :    IMPODD_10_39:
    1947          56 :     rep=isin_G_H(BR,36,23);
    1948          56 :     if (rep) goto IMPODD_10_42; else goto IMPODD_10_43;
    1949             : 
    1950             :    IMPODD_10_40:
    1951          28 :     rep=isin_G_H(BR,39,29);
    1952          28 :     if (rep) goto IMPODD_10_44; else goto IMPODD_10_45;
    1953             : 
    1954             :    IMPODD_10_41:
    1955           0 :     rep=isin_G_H(BR,12,4);
    1956           0 :     return rep? 4: 12;
    1957             : 
    1958             :    IMPODD_10_42:
    1959          42 :     rep=isin_G_H(BR,23,16);
    1960          42 :     if (rep) goto IMPODD_10_46; else goto IMPODD_10_47;
    1961             : 
    1962             :    IMPODD_10_43:
    1963          14 :     rep=isin_G_H(BR,36,11);
    1964          14 :     if (rep) goto IMPODD_10_48; else return 36;
    1965             : 
    1966             :    IMPODD_10_44:
    1967          14 :     rep=isin_G_H(BR,29,25);
    1968          14 :     if (rep) goto IMPODD_10_37; else goto IMPODD_10_49;
    1969             : 
    1970             :    IMPODD_10_45:
    1971          14 :     rep=isin_G_H(BR,39,22);
    1972          14 :     if (rep) goto IMPODD_10_50; else return 39;
    1973             : 
    1974             :    IMPODD_10_46:
    1975          14 :     rep=isin_G_H(BR,16,2);
    1976          14 :     return rep? 2: 16;
    1977             : 
    1978             :    IMPODD_10_47:
    1979          28 :     rep=isin_G_H(BR,23,14);
    1980          28 :     if (rep) goto IMPODD_10_51; else goto IMPODD_10_52;
    1981             : 
    1982             :    IMPODD_10_48:
    1983           0 :     rep=isin_G_H(BR,11,3);
    1984           0 :     if (rep) goto IMPODD_10_53; else return 11;
    1985             : 
    1986             :    IMPODD_10_49:
    1987          14 :     rep=isin_G_H(BR,29,23);
    1988          14 :     if (rep) goto IMPODD_10_42; else goto IMPODD_10_54;
    1989             : 
    1990             :    IMPODD_10_50:
    1991           0 :     rep=isin_G_H(BR,22,12);
    1992           0 :     if (rep) goto IMPODD_10_41; else goto IMPODD_10_55;
    1993             : 
    1994             :    IMPODD_10_51:
    1995          14 :     rep=isin_G_H(BR,14,1);
    1996          14 :     return rep? 1: 14;
    1997             : 
    1998             :    IMPODD_10_52:
    1999          14 :     rep=isin_G_H(BR,23,3);
    2000          14 :     if (!rep) return 23;
    2001             :    IMPODD_10_53:
    2002           0 :     rep=isin_G_H(BR,3,2);
    2003           0 :     if (rep) return 2; else goto IMPODD_10_57;
    2004             : 
    2005             :    IMPODD_10_54:
    2006          14 :     rep=isin_G_H(BR,29,5);
    2007          14 :     if (rep) goto IMPODD_10_58; else return 29;
    2008             : 
    2009             :    IMPODD_10_55:
    2010           0 :     rep=isin_G_H(BR,22,11);
    2011           0 :     if (rep) goto IMPODD_10_48;
    2012           0 :     rep=isin_G_H(BR,22,5);
    2013           0 :     if (rep) goto IMPODD_10_58; else return 22;
    2014             : 
    2015             :    IMPODD_10_57:
    2016           0 :     rep=isin_G_H(BR,3,1);
    2017           0 :     return rep? 1: 3;
    2018             : 
    2019             :    IMPODD_10_58:
    2020           0 :     rep=isin_G_H(BR,5,4);
    2021           0 :     if (rep) return 4;
    2022           0 :     rep=isin_G_H(BR,5,3);
    2023           0 :     if (rep) goto IMPODD_10_53; else return 5;
    2024             :   }
    2025             : }
    2026             : 
    2027             : static long
    2028         609 : closure10(long EVEN, buildroot *BR)
    2029             : {
    2030             :   long rep;
    2031         609 :   if (EVEN)
    2032             :   {
    2033         154 :     rep=isin_G_H(BR,44,42);
    2034         154 :     if (rep) return galoisimpeven10(BR,42);
    2035         112 :     rep=isin_G_H(BR,44,37);
    2036         112 :     if (rep) return galoisimpeven10(BR,37);
    2037             :   }
    2038             :   else
    2039             :   {
    2040         455 :     rep=isin_G_H(BR,45,43);
    2041         455 :     if (rep) return galoisimpodd10(BR,43);
    2042         168 :     rep=isin_G_H(BR,45,39);
    2043         168 :     if (rep) return galoisimpodd10(BR,39);
    2044             :   }
    2045          98 :   return galoisprim10(EVEN, BR);
    2046             : }
    2047             : 
    2048             : static PERM
    2049        3787 : data10(long N, long n1,long n2,GROUP *t)
    2050             : {
    2051        3787 :   switch(n1)
    2052             :   {
    2053          84 :     case 6: if (n2!=2) break;
    2054          49 :       *t=initgroup(N,1);
    2055          49 :       return _cr(N, 1, 2, 3, 4, 5, 6, 10, 9, 8, 7);
    2056         105 :     case 9: if (n2!=3 && n2!=6) break;
    2057         105 :       *t=initgroup(N,2);
    2058         105 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 10, 9, 8, 7);
    2059         105 :       return (*t)[1];
    2060          28 :     case 10: *t=initgroup(N,2);
    2061          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 10, 9, 8, 7);
    2062          28 :       return (*t)[1];
    2063          28 :     case 14: case 16:*t=initgroup(N,1);
    2064          28 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2065          84 :     case 17: if (n2!=5) break;
    2066          28 :       *t=initgroup(N,2);
    2067          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 10, 9, 8, 7);
    2068          28 :       return (*t)[1];
    2069          28 :     case 19: case 20: *t=initgroup(N,2);
    2070          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 10, 7, 9);
    2071          28 :       return (*t)[1];
    2072         210 :     case 21: if (n2!=10) break;
    2073         119 :       *t=initgroup(N,1);
    2074         119 :       return _cr(N, 1, 2, 3, 4, 5, 6, 8, 10, 7, 9);
    2075          84 :     case 23: if (n2!=3) break;
    2076          14 :       *t=initgroup(N,1);
    2077          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2078          14 :     case 25: *t=initgroup(N,1);
    2079          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2080          28 :     case 26: *t=initgroup(N,2);
    2081          28 :       _aff(N, (*t)[2], 1, 2, 4, 9, 6, 8, 10, 3, 7, 5);
    2082          28 :       return _cr(N, 1, 2, 3, 10, 6, 5, 7, 4, 8, 9);
    2083         238 :     case 27: if (n2!=17 && n2!=21) break;
    2084         112 :       *t=initgroup(N,2);
    2085         112 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 10, 7, 9);
    2086         112 :       return (*t)[1];
    2087          28 :     case 28: *t=initgroup(N,2);
    2088          28 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 8, 10, 7, 9);
    2089          28 :       return (*t)[1];
    2090          42 :     case 29: if (n2!=5) break;
    2091          14 :       *t=initgroup(N,1);
    2092          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2093          28 :     case 32: *t=initgroup(N,2);
    2094          28 :       _aff(N, (*t)[2], 1, 2, 4, 9, 6, 8, 10, 3, 7, 5);
    2095          28 :       return _cr(N, 1, 2, 3, 10, 6, 5, 7, 4, 8, 9);
    2096          70 :     case 36: if (n2!=11) break;
    2097          14 :       *t=initgroup(N,1);
    2098          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2099          42 :     case 38: if (n2!=12) break;
    2100          14 :       *t=initgroup(N,1);
    2101          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2102         238 :     case 39: if (n2!=22) break;
    2103          14 :       *t=initgroup(N,1);
    2104          14 :       return _cr(N, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10);
    2105         231 :     case 40: if (n2!=12) break;
    2106          42 :       *t=initgroup(N,1);
    2107          42 :       return _cr(N, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9);
    2108         385 :     case 41: if (n2!=22 && n2!=40) break;
    2109         287 :       *t=initgroup(N,2);
    2110         287 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 7, 8, 10, 9);
    2111         287 :       return (*t)[1];
    2112             :   }
    2113        2793 :   *t=initgroup(N,1); return (*t)[1];
    2114             : }
    2115             : 
    2116             : static long
    2117         637 : galoismodulo10(long EVEN, GEN pol, GEN dpol)
    2118             : {
    2119             :   long res, gr[46];
    2120         637 :   pari_sp av = avma;
    2121         637 :   long **GR = (long**) cgeti(45);
    2122         637 :   GEN TYP = partitions_galois(10);
    2123             : 
    2124         637 :   GR[ 1]= _gr(  4, 1,6,30,42);
    2125         637 :   GR[ 2]= _gr(  3, 1,6,30);
    2126         637 :   GR[ 3]= _gr(  5, 1,5,6,30,42);
    2127         637 :   GR[ 4]= _gr(  4, 1,5,23,30);
    2128         637 :   GR[ 5]= _gr(  7, 1,5,6,22,23,30,42);
    2129         637 :   GR[ 6]= _gr(  5, 1,6,24,30,42);
    2130         637 :   GR[ 7]= _gr( -4, 1,5,14,30);
    2131         637 :   GR[ 8]= _gr( -4, 1,3,5,30);
    2132         637 :   GR[ 9]= _gr(  6, 1,5,6,24,30,42);
    2133         637 :   GR[10]= _gr(  5, 1,5,23,24,30);
    2134         637 :   GR[11]= _gr(  7, 1,5,6,11,30,33,42);
    2135         637 :   GR[12]= _gr(  7, 1,5,6,11,23,30,33);
    2136         637 :   GR[13]= _gr(  7, 1,4,5,14,23,30,34);
    2137         637 :   GR[14]= _gr(  8, 1,2,3,4,5,6,30,42);
    2138         637 :   GR[15]= _gr( -6, 1,3,5,18,22,30);
    2139         637 :   GR[16]= _gr(  7, 1,3,5,6,17,23,30);
    2140         637 :   GR[17]= _gr(  8, 1,5,6,22,23,24,30,42);
    2141         637 :   GR[18]= _gr( -6, 1,5,22,24,30,40);
    2142         637 :   GR[19]= _gr(  7, 1,5,6,22,24,30,42);
    2143         637 :   GR[20]= _gr(  6, 1,5,22,23,24,30);
    2144         637 :   GR[21]= _gr(  9, 1,3,5,6,23,24,26,30,42);
    2145         637 :   GR[22]= _gr( 11, 1,3,5,6,11,13,22,23,30,33,42);
    2146         637 :   GR[23]= _gr( 12, 1,2,3,4,5,6,17,18,22,23,30,42);
    2147         637 :   GR[24]= _gr( -7, 1,3,5,18,22,30,40);
    2148         637 :   GR[25]= _gr(  8, 1,3,5,18,22,23,30,39);
    2149         637 :   GR[26]= _gr( -5, 1,5,14,22,30);
    2150         637 :   GR[27]= _gr( 10, 1,3,5,6,22,23,24,26,30,42);
    2151         637 :   GR[28]= _gr( -8, 1,3,5,22,24,26,30,40);
    2152         637 :   GR[29]= _gr( 14, 1,2,3,4,5,6,17,18,22,23,30,39,40,42);
    2153         637 :   GR[30]= _gr(  8, 1,5,6,14,22,30,39,42);
    2154         637 :   GR[31]= _gr( -6, 1,5,14,22,30,40);
    2155         637 :   GR[32]= _gr(  8, 1,4,5,14,22,23,30,34);
    2156         637 :   GR[33]= _gr( 14, 1,3,5,6,15,17,22,23,24,26,29,30,40,42);
    2157         637 :   GR[34]= _gr( -9, 1,3,5,11,13,18,22,30,32);
    2158         637 :   GR[35]= _gr( 12, 1,4,5,6,14,22,23,30,34,39,40,42);
    2159         637 :   GR[36]= _gr( 18, 1,2,3,4,5,6,11,12,13,17,18,22,23,30,31,32,33,42);
    2160         637 :   GR[37]= _gr(-12, 1,3,5,11,13,16,18,22,30,32,35,40);
    2161         637 :   GR[38]= _gr( 18, 1,3,4,5,6,11,13,15,17,18,21,22,23,30,32,33,35,39);
    2162         637 :   GR[39]= _gr( 24, 1,2,3,4,5,6,11,12,13,15,16,17,18,21,22,23,30,31,32,33,35,39,40,42);
    2163         637 :   GR[40]= _gr( 14, 1,3,5,6,7,9,11,23,24,26,27,30,33,42);
    2164         637 :   GR[41]= _gr( 18, 1,3,5,6,7,9,11,13,16,20,22,23,24,26,27,30,33,42);
    2165         637 :   GR[42]= _gr(-17, 1,3,5,7,9,11,13,16,18,20,22,24,26,27,30,35,40);
    2166         637 :   GR[43]= _gr( 32, 1,2,3,4,5,6,7,8,9,10,11,12,13,15,16,17,18,19,20,22,23,24,25,26,27,28,29,30,33,35,40,42);
    2167         637 :   GR[44]= _gr(-22, 1,3,5,7,9,11,13,14,16,18,20,22,24,26,27,30,32,35,36,38,40,41);
    2168             : 
    2169         637 :   gr[0]=46; res = galmodp(EVEN,pol,dpol,TYP,gr,GR);
    2170         637 :   avma=av; if (!res) return 0;
    2171          28 :   return EVEN? 44: 45;
    2172             : }
    2173             : 
    2174             : /* DEGREE 11 */
    2175             : static long
    2176          91 : closure11(long EVEN, buildroot *BR)
    2177             : {
    2178             :   long rep;
    2179          91 :   if (EVEN)
    2180             :   {
    2181          56 :     rep=isin_G_H(BR,7,6);
    2182          56 :     if (!rep) return 7;
    2183          56 :     rep=isin_G_H(BR,6,5);
    2184          56 :     if (!rep) return 6;
    2185          42 :     rep=isin_G_H(BR,5,3);
    2186          42 :     if (!rep) return 5;
    2187          28 :     rep=isin_G_H(BR,3,1);
    2188          28 :     return rep? 1: 3;
    2189             :   }
    2190             :   else
    2191             :   {
    2192          35 :     GEN h = BR->p, r = compositum(h, h);
    2193          35 :     r = gel(r,lg(r)-1);
    2194          35 :     if (degpol(r) == 22) return 2; /* D11 */
    2195          21 :     h = leafcopy(h); setvarn(h, fetch_var());
    2196          21 :     setvarn(r, 0); r = nffactor(h, r);
    2197             :     /* S11 (P10*P10*P90) or F_110[11] (11 factors of degree 10) */
    2198          21 :     (void)delete_var();
    2199          21 :     return (lgcols(r)-1 == 11)? 4: 8;
    2200             :   }
    2201             : }
    2202             : 
    2203             : static PERM
    2204         182 : data11(long N, long n1, GROUP *t)
    2205             : {
    2206         182 :   switch(n1)
    2207             :   {
    2208          42 :     case 5: *t=initgroup(N,1);
    2209          42 :       return _cr(N, 1, 2, 3, 7, 8, 6, 11, 5, 9, 4, 10);
    2210          56 :     case 6: *t=initgroup(N,1);
    2211          56 :       return _cr(N, 1, 2, 3, 4, 6, 10, 11, 9, 7, 5, 8);
    2212          56 :     case 7: *t=initgroup(N,2);
    2213          56 :       _aff(N, (*t)[2], 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 10);
    2214          56 :       return (*t)[1];
    2215             :   }
    2216          28 :   *t=initgroup(N,1); return (*t)[1];
    2217             : }
    2218             : 
    2219             : static long
    2220         119 : galoismodulo11(long EVEN, GEN pol, GEN dpol)
    2221             : {
    2222         119 :   long res, gr[6] = {0, 1, 1, 1, 1, 1};
    2223         119 :   pari_sp av = avma;
    2224         119 :   GEN TYP = cgetg(EVEN? 9: 6, t_VEC);
    2225             : 
    2226         119 :   gel(TYP,1) = _typ(1, 11);
    2227         119 :   if (EVEN)
    2228             :   {
    2229          70 :     gel(TYP,2) = _typ(3, 8,2,1);
    2230          70 :     gel(TYP,3) = _typ(3, 6,3,2);
    2231          70 :     gel(TYP,4) = _typ(3, 5,5,1);
    2232          70 :     gel(TYP,5) = _typ(5, 4,4,1,1,1);
    2233          70 :     gel(TYP,6) = _typ(5, 3,3,3,1,1);
    2234          70 :     gel(TYP,7) = _typ(7, 2,2,2,2,1,1,1);
    2235          70 :     gel(TYP,8) = _typ(11, 1,1,1,1,1,1,1,1,1,1,1);
    2236             :   }
    2237             :   else
    2238             :   {
    2239          49 :     gel(TYP,2) = _typ(2, 10,1);
    2240          49 :     gel(TYP,3) = _typ(3, 5,5,1);
    2241          49 :     gel(TYP,4) = _typ(6, 2,2,2,2,2,1);
    2242          49 :     gel(TYP,5) = _typ(11, 1,1,1,1,1,1,1,1,1,1,1);
    2243             :   }
    2244         119 :   res = galmodp(EVEN,pol,dpol,TYP,gr,NULL);
    2245         119 :   avma=av; if (!res) return 0;
    2246          28 :   return EVEN? 7: 8;
    2247             : }
    2248             : 
    2249             : static void
    2250       11858 : init_isin(long N, long n1, long n2, GROUP *tau, PERM *s0, resolv *R)
    2251             : {
    2252       11858 :   int fl = 1;
    2253       11858 :   if (DEBUGLEVEL) {
    2254           0 :     err_printf("\n*** Entering isin_%ld_G_H_(%ld,%ld)\n",N,n1,n2); err_flush();
    2255             :   }
    2256       11858 :   switch(N)
    2257             :   {
    2258             :     case 8:
    2259        5474 :       if ((n1==47 && n2==46) || (n1==44 && n2==40)) fl=0;
    2260        5474 :       *s0=data8(N, n1,n2,tau); break;
    2261             :     case 9:
    2262        2415 :       if ((n1==31 && n2==29) || (n1==34 && n2==31) || (n1==33 && n2==30)) fl=0;
    2263        2415 :       *s0=data9(N,n1,n2,tau); break;
    2264             :     case 10:
    2265        3787 :       if ((n1==45 && (n2==43||n2==39))
    2266        3164 :        || (n1==44 && (n2==42||n2==37))
    2267        2898 :        || (n1==43 && (n2==41||n2==33))
    2268        2583 :        || (n1==42 && n2==28)
    2269        2541 :        || (n1==41 && (n2==40||n2==27||n2==22))
    2270        2156 :        || (n1==40 && (n2==21||n2==11))
    2271        1967 :        || (n1==39 && (n2==38||n2==36||n2==29||n2==22))
    2272        1729 :        || (n1==38 && (n2==25||n2==12))
    2273        1687 :        || (n1==37 && (n2==34||n2==24))
    2274        1589 :        || (n1==36 && (n2==23||n2==11))
    2275        1519 :        || (n1==34 && n2==15)
    2276        1477 :        || (n1==33 && n2==27)
    2277        1463 :        || (n1==29 && (n2==25||n2==23||n2==5))
    2278        1421 :        || (n1==28 && n2==18)
    2279        1393 :        || (n1==27 && (n2==20||n2==19||n2==17))
    2280        1225 :        || (n1==25 && n2==4)
    2281        1211 :        || (n1==24 && n2==15)
    2282        1197 :        || (n1==23 && (n2==16||n2==3))
    2283        1141 :        || (n1==22 && (n2==12||n2==11||n2==5))
    2284        1099 :        || (n1==21 && (n2==10||n2==9))
    2285         889 :        || (n1==17 && n2==5)
    2286         861 :        || (n1==16 && n2==2)
    2287         847 :        || (n1==14 && n2==1)
    2288         833 :        || (n1==12 && n2==4)
    2289         819 :        || (n1==11 && n2==3)
    2290         805 :        || (n1==10 && n2==4)
    2291         777 :        || (n1== 9 && n2==3)
    2292         749 :        || (n1== 6 && n2==1)
    2293         714 :        || (n1== 5 && n2==3)) fl = 0;
    2294        3787 :       *s0=data10(N,n1,n2,tau); break;
    2295             :     default: /* case 11: */
    2296         182 :       *s0=data11(N,n1,tau); break;
    2297             :   }
    2298       11858 :   if (fl) lireresolv(n1,n2,N,R); else { R->a = NULL; R->nm = n1; R->nv = n2; }
    2299       11858 : }
    2300             : 
    2301             : static long
    2302       11858 : isin_G_H(buildroot *BR, long n1, long n2)
    2303             : {
    2304       11858 :   pari_sp av = avma;
    2305       11858 :   const long N = BR->N;
    2306             :   PERM s0, ww;
    2307       11858 :   GROUP tau, ss = lirecoset(n1,n2,N);
    2308             :   resolv R;
    2309             : 
    2310       11858 :   init_isin(N,n1,n2, &tau, &s0, &R);
    2311       11858 :   ww = check_isin(BR, &R, tau, ss);
    2312       11858 :   if (ww)
    2313             :   {
    2314        5957 :     GEN z = cgetg(N+1, t_VEC);
    2315        5957 :     long i, j, l = lg(BR->r);
    2316        5957 :     s0 = permmul(ww, s0);
    2317        5957 :     if (DEBUGLEVEL)
    2318             :     {
    2319           0 :       err_printf("\n    Output of isin_%ld_G_H(%ld,%ld): %ld",N,n1,n2,n2);
    2320           0 :       err_printf("\n    Reordering of the roots: "); printperm(s0);
    2321           0 :       err_flush();
    2322             :     }
    2323       14882 :     for (i = 1; i < l; i++)
    2324             :     {
    2325        8925 :       GEN p1 = gel(BR->r,i);
    2326        8925 :       for (j=1; j<=N; j++) gel(z,j) = gel(p1,s0[j]);
    2327        8925 :       for (j=1; j<=N; j++) gel(p1,j) = gel(z,j);
    2328             :     }
    2329        5957 :     avma = av; return n2;
    2330             :   }
    2331        5901 :   if (DEBUGLEVEL)
    2332             :   {
    2333           0 :     err_printf("    Output of isin_%ld_G_H(%ld,%ld): not included.\n",N,n1,n2);
    2334           0 :     err_flush();
    2335             :   }
    2336        5901 :   avma = av; return 0;
    2337             : }
    2338             : 
    2339             : GEN
    2340        2002 : polgaloisnamesbig(long n, long k)
    2341             : {
    2342        2002 :   pari_sp av = avma;
    2343        2002 :   char *s = stack_malloc(strlen(pari_datadir) + 13 + 20 + 3);
    2344             :   pariFILE *f;
    2345             :   GEN V;
    2346             : 
    2347        2002 :   (void)sprintf(s, "%s/galdata/NAM%ld", pari_datadir, n);
    2348        2002 :   f = pari_fopengz(s);
    2349        2002 :   if (!f)
    2350             :   {
    2351           0 :     pari_warn(warner,"Galois names files not available, please upgrade galdata\n[missing %s]",s);
    2352           0 :     avma = av; return strtoGENstr("");
    2353             :   }
    2354        2002 :   V = gp_read_stream(f->file);
    2355        2002 :   if (!V || typ(V)!=t_VEC || k>=lg(V)) pari_err_FILE("galois file %s",s);
    2356        2002 :   pari_fclose(f);
    2357        2002 :   return gerepilecopy(av, gel(V,k));
    2358             : }
    2359             : 
    2360             : /* pol a monic ZX */
    2361             : GEN
    2362        2002 : galoisbig(GEN pol, long prec)
    2363             : {
    2364        2002 :   pari_sp av = avma;
    2365             :   const long *tab;
    2366        2002 :   const long tab8[]={0,
    2367             :     8,8,8,8,8,16,16,16,16,16, 16,24,24,24,32,32,32,32,32,32,
    2368             :     32,32,48,48,56,64,64,64,64,64, 64,96,96,96,128,168,168,192,192,192,
    2369             :     192,288,336,384,576,576,1152,1344,20160,40320};
    2370        2002 :   const long tab9[]={0,
    2371             :     9,9,18,18,18,27,27,36,36,54, 54,54,54,72,72,72,81,108,144,162,
    2372             :     162,162,216,324,324,432,504,648,648,648, 1296,1512,181440,362880};
    2373        2002 :   const long tab10[]={0,
    2374             :     10,10,20,20,40,50,60,80,100,100, 120,120,120,160,160,160,200,200,200,200,
    2375             :     200,240,320,320,320,360,400,400,640,720, 720,720,800,960,1440,
    2376             :     1920,1920,1920,3840,7200,14400,14400,28800,1814400,3628800};
    2377        2002 :   const long tab11[]={0, 11,22,55,110,660,7920,19958400,39916800};
    2378        2002 :   GEN res, dpol = ZX_disc(pol);
    2379        2002 :   long t = 0, N = degpol(pol), EVEN = Z_issquare(dpol);
    2380             : 
    2381        2002 :   if (DEBUGLEVEL)
    2382             :   {
    2383           0 :     err_printf("Galoisbig: polynomial #1 = %Ps\n", pol);
    2384           0 :     err_printf("%s group\n", EVEN? "EVEN": "ODD"); err_flush();
    2385             :   }
    2386        2002 :   switch(N)
    2387             :   {
    2388         770 :     case 8: t = galoismodulo8(EVEN,pol,dpol);  tab=tab8; break;
    2389         476 :     case 9: t = galoismodulo9(EVEN,pol,dpol);  tab=tab9; break;
    2390         637 :     case 10:t = galoismodulo10(EVEN,pol,dpol); tab=tab10; break;
    2391         119 :     case 11:t = galoismodulo11(EVEN,pol,dpol); tab=tab11; break;
    2392           0 :     default: pari_err_IMPL("galois in degree > 11");
    2393           0 :       return NULL; /* not reached */
    2394             :   }
    2395        2002 :   if (!t)
    2396             :   {
    2397             :     buildroot BR;
    2398             :     long i;
    2399        1890 :     GEN r, z = cgetg(N + 1, t_VEC);
    2400       18949 :     for (i = 1; i <= N; i++)
    2401             :     {
    2402       17059 :       GEN v = cgetg(i+2,t_VECSMALL);
    2403       17059 :       gel(z,i) = v; v[1] = 0;
    2404             :     }
    2405        1890 :     BR.coef = z;
    2406        1890 :     BR.p = pol;
    2407        1890 :     BR.pr = prec + nbits2extraprec((long)fujiwara_bound(pol));
    2408        1890 :     BR.prmax = BR.pr + BIGDEFAULTPREC-2;
    2409        1890 :     BR.N = N;
    2410        1890 :     BR.r = vectrunc_init(N+1);
    2411        1890 :     r = gclone ( QX_complex_roots(BR.p, BR.prmax) );
    2412        1890 :     vectrunc_append(BR.r, r); preci(r, BR.pr);
    2413        1890 :     switch(N)
    2414             :     {
    2415         742 :       case  8: t = closure8(EVEN, &BR); break;
    2416         448 :       case  9: t = closure9(EVEN, &BR); break;
    2417         609 :       case 10: t = closure10(EVEN, &BR); break;
    2418          91 :       case 11: t = closure11(EVEN, &BR); break;
    2419             :     }
    2420        1890 :     for (i = 1; i < lg(BR.r); i++) gunclone(gel(BR.r,i));
    2421             :   }
    2422        2002 :   avma = av;
    2423        2002 :   res    = cgetg(5,t_VEC);
    2424        2002 :   gel(res,1) = stoi(tab[t]);
    2425        2002 :   gel(res,2) = stoi(EVEN? 1: -1);
    2426        2002 :   gel(res,3) = stoi(t);
    2427        2002 :   gel(res,4) = polgaloisnamesbig(N,t);
    2428        2002 :   return res;
    2429             : }

Generated by: LCOV version 1.11