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

Generated by: LCOV version 1.13