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-bordeaux1.fr machine (x86_64 architecture), and agregate them in the final report:

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

LCOV - code coverage report
Current view: top level - modules - galois.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 16827-3d78da8) Lines: 1457 1516 96.1 %
Date: 2014-09-29 Functions: 63 65 96.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 1271 1481 85.8 %

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

Generated by: LCOV version 1.9