Code coverage tests

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

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

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

LCOV - code coverage report
Current view: top level - modules - galois.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.10.0 lcov report (development 20459-9710128) Lines: 1640 1712 95.8 %
Date: 2017-04-28 05:33:48 Functions: 69 71 97.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11