Code coverage tests

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

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

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

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

Generated by: LCOV version 1.11