Code coverage tests

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

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

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

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

Generated by: LCOV version 1.13