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 - genus2red.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 16791-0d1274a) Lines: 1266 1397 90.6 %
Date: 2014-09-16 Functions: 53 53 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 556 753 73.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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
      13                 :            : #include "pari.h"
      14                 :            : #include "paripriv.h"
      15                 :            : 
      16                 :            : /********************************************************************/
      17                 :            : /**                                                                **/
      18                 :            : /**                       IGUSA INVARIANTS                         **/
      19                 :            : /**                       (GP2C-generated)                         **/
      20                 :            : /**                                                                **/
      21                 :            : /********************************************************************/
      22                 :            : /*
      23                 :            : j2(a0,a1,a2,a3,a4,a5,a6) = (-120*a0*a6+20*a1*a5-8*a2*a4+3*a3^2) / 4;
      24                 :            : */
      25                 :            : static GEN
      26                 :        940 : igusaj2(GEN a0, GEN a1, GEN a2, GEN a3, GEN a4, GEN a5, GEN a6)
      27                 :            : {
      28                 :        940 :   pari_sp av = avma;
      29                 :        940 :   return gerepileupto(av, gmul2n(gadd(gsub(gadd(gmul(gmulsg(-120, a0), a6), gmul(gmulsg(20, a1), a5)), gmul(gmulsg(8, a2), a4)), gmulsg(3, gsqr(a3))), -2));
      30                 :            : }
      31                 :            : 
      32                 :            : /*
      33                 :            : j4(a0,a1,a2,a3,a4,a5,a6) = (240*(a0*a3*a4*a5+a1*a2*a3*a6)-400*(a0*a2*a5^2+a1^2*a4*a6)-64*(a0*a4^3+a2^3*a6)+16*(a1*a3*a4^2+a2^2*a3*a5)-672*a0*a3^2*a6+240*a1^2*a5^2-112*a1*a2*a4*a5-8*a1*a3^2*a5+16*a2^2*a4^2-16*a2*a3^2*a4+3*a3^4+2640*a0^2*a6^2-880*a0*a1*a5*a6+1312*a0*a2*a4*a6) / 2^7
      34                 :            : */
      35                 :            : static GEN
      36                 :        940 : igusaj4(GEN a0, GEN a1, GEN a2, GEN a3, GEN a4, GEN a5, GEN a6)
      37                 :            : {
      38                 :        940 :   pari_sp av = avma;
      39                 :        940 :   return gerepileupto(av,
      40                 :            : gmul2n(gadd(gsub(gadd(gadd(gsub(gadd(gsub(gsub(gadd(gsub(gadd(gsub(gsub(gmulsg(240,
      41                 :            : gadd(gmul(gmul(gmul(a0, a3), a4), a5), gmul(gmul(gmul(a1, a2), a3), a6))),
      42                 :            : gmulsg(400, gadd(gmul(gmul(a0, a2), gsqr(a5)), gmul(gmul(gsqr(a1), a4), a6)))),
      43                 :            : gmulsg(64, gadd(gmul(a0, gpowgs(a4, 3)), gmul(gpowgs(a2, 3), a6)))), gmulsg(16,
      44                 :            : gadd(gmul(gmul(a1, a3), gsqr(a4)), gmul(gmul(gsqr(a2), a3), a5)))),
      45                 :            : gmul(gmul(gmulsg(672, a0), gsqr(a3)), a6)), gmul(gmulsg(240, gsqr(a1)),
      46                 :            : gsqr(a5))), gmul(gmul(gmul(gmulsg(112, a1), a2), a4), a5)), gmul(gmul(gmulsg(8,
      47                 :            : a1), gsqr(a3)), a5)), gmul(gmulsg(16, gsqr(a2)), gsqr(a4))),
      48                 :            : gmul(gmul(gmulsg(16, a2), gsqr(a3)), a4)), gmulsg(3, gpowgs(a3, 4))),
      49                 :            : gmul(gmulsg(2640, gsqr(a0)), gsqr(a6))), gmul(gmul(gmul(gmulsg(880, a0), a1),
      50                 :            : a5), a6)), gmul(gmul(gmul(gmulsg(1312, a0), a2), a4), a6)), -7));
      51                 :            : }
      52                 :            : 
      53                 :            : /*
      54                 :            : j6(a0,a1,a2,a3,a4,a5,a6) = (1600*(a0^2*a4^2*a5^2+a1^2*a2^2*a6^2)+1600*(a0*a1*a2*a5^3+a1^3*a4*a5*a6)+640*(a0*a1*a3*a4*a5^2+a1^2*a2*a3*a5*a6)-4000*(a0^2*a3*a5^3+a1^3*a3*a6^2)-384*(a0*a1*a4^3*a5+a1*a2^3*a5*a6)-640*(a0*a2^2*a4*a5^2+a1^2*a2*a4^2*a6)+80*(a0*a2*a3^2*a5^2+a1^2*a3^2*a4*a6)+192*(a0*a2*a3*a4^2*a5+a1*a2^2*a3*a4*a6)-48*(a0*a3^3*a4*a5+a1*a2*a3^3*a6)-224*(a1^2*a3*a4^2*a5+a1*a2^2*a3*a5^2)+64*(a1^2*a4^4+a2^4*a5^2)-64*(a1*a2*a3*a4^3+a2^3*a3*a4*a5)+16*(a1*a3^3*a4^2+a2^2*a3^3*a5)-4096*(a0^2*a4^3*a6+a0*a2^3*a6^2)+6400*(a0^2*a2*a5^2*a6+a0*a1^2*a4*a6^2)+10560*(a0^2*a3*a4*a5*a6+a0*a1*a2*a3*a6^2)+2624*(a0*a1*a3*a4^2*a6+a0*a2^2*a3*a5*a6)-4432*a0*a1*a3^2*a5*a6-8*a2*a3^4*a4+a3^6-320*a1^3*a5^3+64*a1^2*a2*a4*a5^2+176*a1^2*a3^2*a5^2+128*a1*a2^2*a4^2*a5+112*a1*a2*a3^2*a4*a5-28*a1*a3^4*a5+16*a2^2*a3^2*a4^2+5120*a0^3*a6^3-2544*a0^2*a3^2*a6^2+312*a0*a3^4*a6-14336*a0^2*a2*a4*a6^2+1024*a0*a2^2*a4^2*a6-2560*a0^2*a1*a5*a6^2-2240*a0*a1^2*a5^2*a6-6528*a0*a1*a2*a4*a5*a6-1568*a0*a2*a3^2*a4*a6) / 2^10
      55                 :            : */
      56                 :            : static GEN
      57                 :        940 : igusaj6(GEN a0, GEN a1, GEN a2, GEN a3, GEN a4, GEN a5, GEN a6)
      58                 :            : {
      59                 :        940 :   pari_sp av = avma;
      60                 :        940 :   return gerepileupto(av,
      61                 :            : gmul2n(gsub(gsub(gsub(gsub(gadd(gsub(gadd(gsub(gadd(gadd(gsub(gadd(gadd(gadd(gadd(gsub(gadd(gsub(gsub(gadd(gadd(gadd(gsub(gadd(gsub(gadd(gsub(gsub(gadd(gadd(gsub(gsub(gsub(gadd(gadd(gmulsg(1600,
      62                 :            : gadd(gmul(gmul(gsqr(a0), gsqr(a4)), gsqr(a5)), gmul(gmul(gsqr(a1), gsqr(a2)),
      63                 :            : gsqr(a6)))), gmulsg(1600, gadd(gmul(gmul(gmul(a0, a1), a2), gpowgs(a5, 3)),
      64                 :            : gmul(gmul(gmul(gpowgs(a1, 3), a4), a5), a6)))), gmulsg(640,
      65                 :            : gadd(gmul(gmul(gmul(gmul(a0, a1), a3), a4), gsqr(a5)),
      66                 :            : gmul(gmul(gmul(gmul(gsqr(a1), a2), a3), a5), a6)))), gmulsg(4000,
      67                 :            : gadd(gmul(gmul(gsqr(a0), a3), gpowgs(a5, 3)), gmul(gmul(gpowgs(a1, 3), a3),
      68                 :            : gsqr(a6))))), gmulsg(384, gadd(gmul(gmul(gmul(a0, a1), gpowgs(a4, 3)), a5),
      69                 :            : gmul(gmul(gmul(a1, gpowgs(a2, 3)), a5), a6)))), gmulsg(640,
      70                 :            : gadd(gmul(gmul(gmul(a0, gsqr(a2)), a4), gsqr(a5)), gmul(gmul(gmul(gsqr(a1),
      71                 :            : a2), gsqr(a4)), a6)))), gmulsg(80, gadd(gmul(gmul(gmul(a0, a2), gsqr(a3)),
      72                 :            : gsqr(a5)), gmul(gmul(gmul(gsqr(a1), gsqr(a3)), a4), a6)))), gmulsg(192,
      73                 :            : gadd(gmul(gmul(gmul(gmul(a0, a2), a3), gsqr(a4)), a5), gmul(gmul(gmul(gmul(a1,
      74                 :            : gsqr(a2)), a3), a4), a6)))), gmulsg(48, gadd(gmul(gmul(gmul(a0, gpowgs(a3, 3)),
      75                 :            : a4), a5), gmul(gmul(gmul(a1, a2), gpowgs(a3, 3)), a6)))), gmulsg(224,
      76                 :            : gadd(gmul(gmul(gmul(gsqr(a1), a3), gsqr(a4)), a5), gmul(gmul(gmul(a1,
      77                 :            : gsqr(a2)), a3), gsqr(a5))))), gmulsg(64, gadd(gmul(gsqr(a1), gpowgs(a4, 4)),
      78                 :            : gmul(gpowgs(a2, 4), gsqr(a5))))), gmulsg(64, gadd(gmul(gmul(gmul(a1, a2), a3),
      79                 :            : gpowgs(a4, 3)), gmul(gmul(gmul(gpowgs(a2, 3), a3), a4), a5)))), gmulsg(16,
      80                 :            : gadd(gmul(gmul(a1, gpowgs(a3, 3)), gsqr(a4)), gmul(gmul(gsqr(a2), gpowgs(a3,
      81                 :            : 3)), a5)))), gmulsg(4096, gadd(gmul(gmul(gsqr(a0), gpowgs(a4, 3)), a6),
      82                 :            : gmul(gmul(a0, gpowgs(a2, 3)), gsqr(a6))))), gmulsg(6400,
      83                 :            : gadd(gmul(gmul(gmul(gsqr(a0), a2), gsqr(a5)), a6), gmul(gmul(gmul(a0,
      84                 :            : gsqr(a1)), a4), gsqr(a6))))), gmulsg(10560, gadd(gmul(gmul(gmul(gmul(gsqr(a0),
      85                 :            : a3), a4), a5), a6), gmul(gmul(gmul(gmul(a0, a1), a2), a3), gsqr(a6))))),
      86                 :            : gmulsg(2624, gadd(gmul(gmul(gmul(gmul(a0, a1), a3), gsqr(a4)), a6),
      87                 :            : gmul(gmul(gmul(gmul(a0, gsqr(a2)), a3), a5), a6)))),
      88                 :            : gmul(gmul(gmul(gmul(gmulsg(4432, a0), a1), gsqr(a3)), a5), a6)),
      89                 :            : gmul(gmul(gmulsg(8, a2), gpowgs(a3, 4)), a4)), gpowgs(a3, 6)), gmul(gmulsg(320,
      90                 :            : gpowgs(a1, 3)), gpowgs(a5, 3))), gmul(gmul(gmul(gmulsg(64, gsqr(a1)), a2), a4),
      91                 :            : gsqr(a5))), gmul(gmul(gmulsg(176, gsqr(a1)), gsqr(a3)), gsqr(a5))),
      92                 :            : gmul(gmul(gmul(gmulsg(128, a1), gsqr(a2)), gsqr(a4)), a5)),
      93                 :            : gmul(gmul(gmul(gmul(gmulsg(112, a1), a2), gsqr(a3)), a4), a5)),
      94                 :            : gmul(gmul(gmulsg(28, a1), gpowgs(a3, 4)), a5)), gmul(gmul(gmulsg(16, gsqr(a2)),
      95                 :            : gsqr(a3)), gsqr(a4))), gmul(gmulsg(5120, gpowgs(a0, 3)), gpowgs(a6, 3))),
      96                 :            : gmul(gmul(gmulsg(2544, gsqr(a0)), gsqr(a3)), gsqr(a6))), gmul(gmul(gmulsg(312,
      97                 :            : a0), gpowgs(a3, 4)), a6)), gmul(gmul(gmul(gmulsg(14336, gsqr(a0)), a2), a4),
      98                 :            : gsqr(a6))), gmul(gmul(gmul(gmulsg(1024, a0), gsqr(a2)), gsqr(a4)), a6)),
      99                 :            : gmul(gmul(gmul(gmulsg(2560, gsqr(a0)), a1), a5), gsqr(a6))),
     100                 :            : gmul(gmul(gmul(gmulsg(2240, a0), gsqr(a1)), gsqr(a5)), a6)),
     101                 :            : gmul(gmul(gmul(gmul(gmul(gmulsg(6528, a0), a1), a2), a4), a5), a6)),
     102                 :            : gmul(gmul(gmul(gmul(gmulsg(1568, a0), a2), gsqr(a3)), a4), a6)), -10));
     103                 :            : }
     104                 :            : 
     105                 :            : /********************************************************************/
     106                 :            : /**                                                                **/
     107                 :            : /**   A REDUCTION ALGORITHM "A LA TATE" FOR CURVES OF GENUS 2      **/
     108                 :            : /**                                                                **/
     109                 :            : /********************************************************************/
     110                 :            : /* Based on genus2reduction-0.3, http://www.math.u-bordeaux1.fr/~liu/G2R/
     111                 :            :  * by Qing Liu <liu@math.u-bordeaux1.fr>
     112                 :            :  * and Henri Cohen <cohen@math.u-bordeaux1.fr>
     113                 :            : 
     114                 :            :  * Qing Liu: Modeles minimaux des courbes de genre deux
     115                 :            :  * J. fuer die Reine und Angew. Math., 453 (1994), 137-164.
     116                 :            :  * http://www.math.u-bordeaux1.fr/~liu/articles/modregE.ps */
     117                 :            : 
     118                 :            : /* some auxiliary polynomials, gp2c-generated */
     119                 :            : 
     120                 :            : /*
     121                 :            : apol2(a0,a1,a2) = -5*a1^2+12*a0*a2;
     122                 :            : */
     123                 :            : static GEN
     124                 :        940 : apol2(GEN a0, GEN a1, GEN a2)
     125                 :            : {
     126                 :        940 :   return gadd(gmulsg(-5, gsqr(a1)), gmul(gmulsg(12, a0), a2));
     127                 :            : }
     128                 :            : 
     129                 :            : /*
     130                 :            : apol3(a0,a1,a2,a3) = 5*a1^3+9*a0*(-2*a1*a2+3*a0*a3);
     131                 :            : */
     132                 :            : static GEN
     133                 :        940 : apol3(GEN a0, GEN a1, GEN a2, GEN a3)
     134                 :            : {
     135                 :        940 :   return gadd(gmulsg(5, gpowgs(a1, 3)), gmul(gmulsg(9, a0), gadd(gmul(gmulsg(-2, a1), a2), gmul(gmulsg(3, a0), a3))));
     136                 :            : }
     137                 :            : 
     138                 :            : /*
     139                 :            : apol5(a0,a1,a2,a3,a4,a5) = a1^5+3*a0*(-2*a1^3*a2+9*a0*a1^2*a3-36*a0^2*a1*a4+108*a0^3*a5);
     140                 :            : */
     141                 :            : static GEN
     142                 :        940 : apol5(GEN a0, GEN a1, GEN a2, GEN a3, GEN a4, GEN a5)
     143                 :            : {
     144                 :        940 :   return gadd(gpowgs(a1, 5), gmul(gmulsg(3, a0), gadd(gsub(gadd(gmul(gmulsg(-2, gpowgs(a1, 3)), a2), gmul(gmul(gmulsg(9, a0), gsqr(a1)), a3)), gmul(gmul(gmulsg(36, gsqr(a0)), a1), a4)), gmul(gmulsg(108, gpowgs(a0, 3)), a5))));
     145                 :            : }
     146                 :            : 
     147                 :            : /*
     148                 :            : bpol2(a0,a1,a2,a3,a4) = 2*a2^2-5*a1*a3+10*a0*a4;
     149                 :            : */
     150                 :            : static GEN
     151                 :        940 : bpol2(GEN a0, GEN a1, GEN a2, GEN a3, GEN a4)
     152                 :            : {
     153                 :        940 :   return gadd(gsub(gmulsg(2, gsqr(a2)), gmul(gmulsg(5, a1), a3)), gmul(gmulsg(10, a0), a4));
     154                 :            : }
     155                 :            : 
     156                 :            : static const long VERYBIG = (1L<<20);
     157                 :            : static long
     158         [ +  + ]:      34810 : myval(GEN x, GEN p) { return signe(x)? Z_pval(x,p): VERYBIG; }
     159                 :            : static long
     160         [ +  + ]:       1910 : my3val(GEN x) { return signe(x)? Z_lval(x,3): VERYBIG; }
     161                 :            : /* largest power of p dividing pol */
     162                 :            : static long
     163                 :       2155 : polval(GEN pol, GEN p)
     164                 :            : {
     165                 :       2155 :   long v, i, lx = lg(pol);
     166         [ -  + ]:       2155 :   if (!signe(pol)) return VERYBIG;
     167                 :       2155 :   v = myval(gel(pol,2),p);
     168         [ +  + ]:      14405 :   for(i = 3;i<lx;i++) v = minss(v, myval(gel(pol,i),p));
     169                 :       2155 :   return v;
     170                 :            : }
     171                 :            : /* b in Z[i], return v_3(b) */
     172                 :            : static long
     173                 :        955 : myval_zi(GEN b) { return minss(my3val(real_i(b)), my3val(imag_i(b))); }
     174                 :            : /* b in Z[i, Y]/(Y^2-3), return v_Y(b) */
     175                 :            : static long
     176                 :        425 : myval_zi2(GEN b)
     177                 :            : {
     178                 :            :   long v0, v1;
     179                 :        425 :   b = lift(b);
     180                 :        425 :   v0 = myval_zi(RgX_coeff(b,0));
     181                 :        425 :   v1 = myval_zi(RgX_coeff(b,1));
     182                 :        425 :   return minss(2*v0, 2*v1+1);
     183                 :            : }
     184                 :            : 
     185                 :            : /* min(a,b,c) */
     186                 :            : static long
     187                 :       1090 : min3(long a, long b, long c)
     188                 :            : {
     189                 :       1090 :   long m = a;
     190         [ +  + ]:       1090 :   if (b < m) m = b;
     191         [ +  + ]:       1090 :   if (c < m) m = c;
     192                 :       1090 :   return m;
     193                 :            : }
     194                 :            : /* min(a,b,c) */
     195                 :            : static GEN
     196                 :        405 : gmin3(GEN a, GEN b, GEN c)
     197                 :            : {
     198                 :        405 :   GEN m = a;
     199         [ +  + ]:        405 :   if (gcmp(b, m) < 0) m = b;
     200         [ +  + ]:        405 :   if (gcmp(c, m) < 0) m = c;
     201                 :        405 :   return m;
     202                 :            : }
     203                 :            : 
     204                 :            : /* a/b */
     205                 :            : static GEN
     206         [ +  + ]:      12535 : frac2s(long a, long b) { return b == 1? stoi(a): gdivgs(stoi(a), b); }
     207                 :            : 
     208                 :            : /* Vector of p-adic factors (over Q_p) to accuracy r of pol. */
     209                 :            : static GEN
     210                 :         85 : padicfactors(GEN pol, GEN p, long r) { return gel(factorpadic(pol,p,r),1); }
     211                 :            : 
     212                 :            : /* x(1/t)*t^6, deg x <= 6 */
     213                 :            : static GEN
     214                 :        200 : RgX_recip6(GEN x)
     215                 :            : {
     216                 :        200 :   long lx = lg(x), i, j;
     217                 :        200 :   GEN y = cgetg(9, t_POL);
     218                 :        200 :   y[1] = x[1];
     219         [ +  + ]:       1500 :   for (i=8,j=2; j < lx; i--,j++) gel(y,i) = gel(x,j);
     220         [ +  + ]:        300 :   for (       ; j <  9; i--,j++) gel(y,i) = gen_0;
     221                 :        200 :   return normalizepol_lg(y, 9);
     222                 :            : }
     223                 :            : /* extract coefficients of a polynomial a0 X^6 + ... + a6, of degree <= 6 */
     224                 :            : static void
     225                 :       4475 : RgX_to_6(GEN q, GEN *a0, GEN *a1, GEN *a2, GEN *a3, GEN *a4, GEN *a5, GEN *a6)
     226                 :            : {
     227                 :       4475 :   *a0 = gen_0;
     228                 :       4475 :   *a1 = gen_0;
     229                 :       4475 :   *a2 = gen_0;
     230                 :       4475 :   *a3 = gen_0;
     231                 :       4475 :   *a4 = gen_0;
     232                 :       4475 :   *a5 = gen_0;
     233                 :       4475 :   *a6 = gen_0;
     234   [ +  +  -  -  :       4475 :   switch(degpol(q))
             -  -  -  - ]
     235                 :            :   {
     236                 :       3070 :     case 6: *a0 = gel(q,8); /*fall through*/
     237                 :       4475 :     case 5: *a1 = gel(q,7); /*fall through*/
     238                 :       4475 :     case 4: *a2 = gel(q,6); /*fall through*/
     239                 :       4475 :     case 3: *a3 = gel(q,5); /*fall through*/
     240                 :       4475 :     case 2: *a4 = gel(q,4); /*fall through*/
     241                 :       4475 :     case 1: *a5 = gel(q,3); /*fall through*/
     242                 :       4475 :     case 0: *a6 = gel(q,2); /*fall through*/
     243                 :            :   }
     244                 :       4475 : }
     245                 :            : 
     246                 :            : /* return a factor of maximal multiplicity (maxord) of the FpX Q, deg Q < 7.
     247                 :            :  * In the special case maxord = 3 or maxord = 2 and p <= 5, make sure
     248                 :            :  * the factor is irreducible */
     249                 :            : static GEN
     250                 :        485 : factmz(GEN Q, GEN p, long *maxord)
     251                 :            : {
     252                 :        485 :   GEN D, z = Q;
     253                 :        485 :   long m = 0;
     254         [ +  + ]:        485 :   if (cmpiu(p,5) <= 0)
     255                 :            :   {
     256         [ +  + ]:        355 :     if (FpX_is_squarefree(Q, p)) m = 1;
     257                 :            :     else
     258                 :            :     {
     259                 :        260 :       GEN F = FpX_factor(Q,p), P = gel(F,1), E = gel(F,2);
     260                 :        260 :       long i, l = 1;
     261         [ +  + ]:        710 :       for(i = 1;i<lg(E);i++)
     262                 :            :       {
     263                 :        450 :         long e = E[i];
     264         [ +  + ]:        450 :         if (e >= m) { m = e; l = i; }
     265                 :            :       }
     266                 :        260 :       z = gel(P,l);
     267                 :            :     }
     268                 :        355 :     *maxord = m; return z;
     269                 :            :   }
     270                 :        130 :   D = Q;
     271                 :            :   for(;;)
     272                 :            :   {
     273                 :            :     GEN T;
     274                 :        235 :     m++;
     275                 :        235 :     D = FpX_deriv(D, p);
     276                 :        235 :     T = FpX_gcd(z, D, p);
     277         [ +  + ]:        235 :     if (degpol(T) == 0) break;
     278                 :        105 :     z = T;
     279                 :        105 :   }
     280 [ +  + ][ +  + ]:        130 :   if (m >= 3 && degpol(z) == 2)
     281                 :            :   {
     282                 :          5 :     GEN F = FpX_factor(z,p);
     283                 :          5 :     z = gcoeff(F,1,1);
     284                 :            :   }
     285                 :        485 :   *maxord = m; return z;
     286                 :            : }
     287                 :            : 
     288                 :            : /* deg(H mod p) = 3, return v_p( disc(correspondig p-adic factor) ) */
     289                 :            : static long
     290                 :         10 : discpart(GEN H, GEN p, long prec)
     291                 :            : {
     292                 :            :   GEN list, prod, dis;
     293                 :            :   long i, j;
     294                 :            : 
     295         [ -  + ]:         10 :   if (degpol(FpX_red(H,p)) != 3)
     296                 :          0 :     pari_err_BUG("discpart [must not reach]");
     297                 :         10 :   list = padicfactors(H,p,prec);
     298                 :         10 :   prod = pol_1(varn(H));
     299         [ +  + ]:         40 :   for(i = 1; i < lg(list); i++)
     300                 :            :   {
     301                 :         30 :     GEN t = gel(list,i);
     302         [ +  + ]:         60 :     for(j = 3; j < lg(t); j++) /* include if non-constant mod p */
     303         [ +  + ]:         50 :       if (!valp(gel(t,j))) { prod = RgX_mul(prod,t); break; }
     304                 :            :   }
     305         [ -  + ]:         10 :   if (degpol(prod) != 3) pari_err_BUG("discpart [prod degree]");
     306                 :         10 :   dis = RgX_disc(prod);
     307         [ -  + ]:         10 :   return gequal0(dis)? prec+1: valp(dis);
     308                 :            : }
     309                 :            : 
     310                 :            : 
     311                 :            : /* B = b0 X^6 + ... + b6 a ZX, 0 <= j <= 3.
     312                 :            :  * Return theta_j(H) := min { v_p(b_i) / (i - j), lambda < i <= 6 } >= 0.
     313                 :            :  * N.B. 60 theta \in Z */
     314                 :            : static GEN
     315                 :       1260 : theta_j(GEN B, GEN p, long j)
     316                 :            : {
     317                 :       1260 :   GEN theta, b0, b1, b2, b3, b4, b5, b6, v = new_chunk(7);
     318                 :            :   long i;
     319                 :            : 
     320                 :       1260 :   RgX_to_6(B, &b0,&b1,&b2,&b3,&b4,&b5,&b6);
     321                 :       1260 :   v[0] = myval(b0,p);
     322                 :       1260 :   v[1] = myval(b1,p);
     323                 :       1260 :   v[2] = myval(b2,p);
     324                 :       1260 :   v[3] = myval(b3,p);
     325                 :       1260 :   v[4] = myval(b4,p);
     326                 :       1260 :   v[5] = myval(b5,p);
     327                 :       1260 :   v[6] = myval(b6,p);
     328                 :       1260 :   theta = stoi(v[1+j]);
     329         [ +  + ]:       4930 :   for(i = 2+j; i <= 6; i++) theta = gmin(theta, frac2s(v[i], i-j));
     330                 :       1260 :   return theta;
     331                 :            : }
     332                 :            : /* compute theta_3 for B in Z[i][X], p = 3 */
     333                 :            : static GEN
     334                 :         20 : theta_3_zi(GEN B)
     335                 :            : {
     336                 :         20 :   long v2 = myval_zi(RgX_coeff(B,2));
     337                 :         20 :   long v1 = myval_zi(RgX_coeff(B,1));
     338                 :         20 :   long v0 = myval_zi(RgX_coeff(B,0));
     339                 :         20 :   return frac2s(min3(6*v2, 3*v1, 2*v0), 6);
     340                 :            : }
     341                 :            : /* compute theta_3 for B in (Z[i,Y]/(Y^2-3))[X], p = 3 */
     342                 :            : static GEN
     343                 :         55 : theta_3_zi2(GEN B)
     344                 :            : {
     345                 :         55 :   long v2 = myval_zi2(RgX_coeff(B,2));
     346                 :         55 :   long v1 = myval_zi2(RgX_coeff(B,1));
     347                 :         55 :   long v0 = myval_zi2(RgX_coeff(B,0));
     348                 :         55 :   return frac2s(min3(6*v2, 3*v1, 2*v0), 6);
     349                 :            : }
     350                 :            : 
     351                 :            : /* T an FpX of degree 1, return its root */
     352                 :            : static GEN
     353                 :        125 : deg1root(GEN T, GEN p)
     354                 :            : {
     355                 :        125 :   GEN a = gel(T,2), b = gel(T,3);
     356                 :        125 :   return Fp_neg(Fp_div(a, b, p), p);
     357                 :            : }
     358                 :            : /* H = minimal minimal over Z_p, p > 2.
     359                 :            :  * alpha = 0,1
     360                 :            :  * quad = 1 if root of order 3 in F_p^2 \ F_p, 0 otherwise
     361                 :            :  * 0 <= lambda <= 3, t_INT
     362                 :            :  * theta = theta(H, p), rational
     363                 :            :  * beta >= 0, t_INT */
     364                 :            : static GEN
     365                 :       1140 : polymini(GEN pol, GEN p)
     366                 :            : {
     367                 :            :   GEN a0, a1, a2, a3, a4, a5, a6;
     368                 :            :   GEN H, Hp, rac, theta, polf, pro, quad;
     369                 :            :   long alpha, lambda, maxord, beta;
     370                 :            : 
     371                 :       1140 :   alpha = polval(pol,p);
     372                 :       1140 :   H = RgX_Rg_div(pol, powiu(p,alpha));
     373                 :       1140 :   RgX_to_6(H, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
     374 [ +  + ][ +  + ]:       1140 :   if (dvdii(a0,p) && dvdii(a1,p) && dvdii(a2,p) && dvdii(a3,p))
         [ +  + ][ +  + ]
     375                 :            :   {
     376                 :         40 :     H = RgX_recip6(H);
     377                 :         40 :     RgX_to_6(H, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
     378                 :            :   }
     379                 :       1140 :   alpha = alpha&1;
     380                 :       1140 :   beta = 0;
     381                 :       1140 :   lambda = 0;
     382         [ +  + ]:       1140 :   if (!dvdii(a1,p)) lambda = 1;
     383         [ +  + ]:       1140 :   if (!dvdii(a2,p)) lambda = 2;
     384         [ +  + ]:       1140 :   if (!dvdii(a3,p)) lambda = 3;
     385                 :       1140 :   quad = gen_0;
     386                 :            : 
     387                 :            :   for(;;)
     388                 :            :   {
     389                 :       1260 :     theta = theta_j(H,p,lambda);
     390         [ +  + ]:       1260 :     if (gcmp(theta,gen_1)>= 0)
     391                 :            :     {
     392                 :        660 :       long ent = itos(gfloor(theta));
     393                 :        660 :       GEN pent = powiu(p,ent);
     394                 :        660 :       H = RgX_Rg_div(RgX_unscale(H,pent), powiu(pent,6-lambda));
     395                 :        660 :       alpha = (alpha+lambda*ent)&1;
     396                 :        660 :       beta += ent;
     397                 :        660 :       theta = gsubgs(theta,ent);
     398                 :            :     }
     399                 :       1260 :     Hp = FpX_red(H, p);
     400         [ +  + ]:       1260 :     if (!gequal0(theta)) break;
     401                 :            : 
     402                 :        480 :     rac = factmz(Hp,p, &maxord);
     403         [ +  + ]:        480 :     if (maxord <= 2)
     404                 :            :     {
     405         [ +  + ]:        345 :       if (degpol(Hp) <= 3) break;
     406                 :         50 :       goto end;
     407                 :            :     }
     408                 :            :     else
     409                 :            :     { /* maxord >= 3 */
     410         [ +  + ]:        135 :       if (degpol(rac) == 2) { quad = gen_1; goto end; }
     411                 :        120 :       rac = deg1root(rac, p);
     412                 :        120 :       H = RgX_translate(H, rac);
     413                 :        120 :       lambda = 6-maxord;
     414                 :            :     }
     415                 :        120 :   }
     416                 :            : 
     417         [ +  + ]:       1075 :   if (lambda <= 2)
     418                 :            :   {
     419   [ +  +  +  + ]:        860 :     if (myval(RgX_coeff(H,2),p) > 1-alpha &&
     420         [ +  + ]:        720 :         myval(RgX_coeff(H,1),p) > 2-alpha &&
     421                 :        325 :         myval(RgX_coeff(H,0),p) > 3-alpha)
     422                 :            :     {
     423                 :         35 :       pol = RgX_unscale(H, p);
     424         [ +  + ]:         35 :       if (alpha) pol = RgX_Rg_mul(pol, p);
     425                 :         35 :       return polymini(pol, p);
     426                 :            :     }
     427                 :            :   }
     428 [ +  - ][ +  + ]:        610 :   else if (lambda == 3 && alpha == 1)
     429                 :            :   {
     430         [ +  + ]:        250 :     if (degpol(Hp) == 3)
     431                 :            :     {
     432   [ +  +  +  - ]:        445 :       if (myval(RgX_coeff(H,6),p) >= 3 &&
     433                 :        220 :           myval(RgX_coeff(H,5),p) >= 2)
     434                 :            :       {
     435                 :        220 :         H = RgX_rescale(H, p); /* H(x/p)p^(deg H) */
     436                 :        220 :         H = RgX_Rg_div(H, powiu(p, degpol(H)-3)); /* H(x/p)p^3 */
     437                 :        220 :         theta = gadd(theta,gen_1);
     438                 :        220 :         alpha = 0;
     439                 :        220 :         beta--;
     440                 :            :       }
     441                 :            :     }
     442 [ +  + ][ +  - ]:         25 :     else if (degpol(Hp) == 6 && !gequal0(theta))
     443                 :            :     {
     444                 :          5 :       rac = factmz(RgX_mulXn(Hp, -3), p, &maxord);
     445         [ +  - ]:          5 :       if (maxord == 3)
     446                 :            :       {
     447                 :          5 :         rac = deg1root(rac, p);
     448                 :          5 :         pro = RgX_translate(RgX_unscale(H,p), rac); /* H(rac + px) */
     449         [ -  + ]:          5 :         if (polval(pro,p)>= 3)
     450                 :            :         {
     451                 :          0 :           H = RgX_Rg_div(pro, powiu(p,3));
     452                 :          0 :           alpha = 0;
     453                 :          0 :           beta--;
     454                 :          0 :           theta = theta_j(H,p,3);
     455                 :            :         }
     456                 :            :       }
     457                 :            :     }
     458                 :            :   }
     459                 :            : end:
     460                 :       1105 :   polf = cgetg(7, t_VEC);
     461                 :       1105 :   gel(polf,1) = H;
     462                 :       1105 :   gel(polf,2) = stoi(lambda);
     463                 :       1105 :   gel(polf,3) = theta;
     464                 :       1105 :   gel(polf,4) = stoi(alpha);
     465                 :       1105 :   gel(polf,5) = quad;
     466                 :       1105 :   gel(polf,6) = stoi(beta);
     467                 :       1140 :   return polf;
     468                 :            : }
     469                 :            : 
     470                 :            : /* a in Q[i], return a^3 mod 3 */
     471                 :            : static GEN
     472                 :         10 : zi_pow3mod(GEN a)
     473                 :            : {
     474                 :            :   GEN x, y;
     475         [ +  + ]:         10 :   if (typ(a) != t_COMPLEX) return gmodgs(a,3);
     476                 :          5 :   x = gmodgs(gel(a,1), 3);
     477                 :          5 :   y = gmodgs(gel(a,2), 3);
     478                 :         10 :   return mkcomplex(x, negi(y));
     479                 :            : }
     480                 :            : static GEN
     481                 :         15 : polymini_zi(GEN pol) /* polynome minimal dans Z[i] */
     482                 :            : {
     483                 :            :   GEN p, polh, rac, theta;
     484                 :            :   GEN a0, a1, a2, a3, a4, a5, a6;
     485                 :            :   long alpha,beta;
     486                 :            : 
     487                 :         15 :   p = stoi(3);
     488                 :         15 :   alpha = polval(pol,p) & 1;
     489         [ -  + ]:         15 :   polh = alpha? RgX_Rg_div(pol, p): pol;
     490                 :         15 :   beta = 0;
     491                 :         15 :   rac = mkcomplex(Fp_div(RgX_coeff(polh,3), RgX_coeff(polh,6), p), gen_1);
     492                 :            :   for(;;)
     493                 :            :   {
     494                 :         20 :     polh = RgX_translate(polh, rac);
     495                 :         20 :     theta = theta_3_zi(polh);
     496         [ +  + ]:         20 :     if (gcmp(theta,gen_1) >= 0)
     497                 :            :     {
     498                 :         10 :       long ent = itos(gfloor(theta));
     499                 :         10 :       GEN pent = powiu(p,ent);
     500                 :         10 :       polh = RgX_Rg_div(RgX_unscale(polh,pent), powiu(pent,3));
     501                 :         10 :       alpha = (alpha+ent)&1;
     502                 :         10 :       beta += ent;
     503                 :         10 :       theta = gsubgs(theta,ent);
     504                 :            :     }
     505                 :         20 :     RgX_to_6(polh, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
     506 [ +  + ][ +  + ]:         20 :     if (!gequal0(theta) || !myval_zi(a4) || !myval_zi(a5)) break;
                 [ +  - ]
     507                 :          5 :     rac = zi_pow3mod(gdiv(a6, gneg(a3)));
     508                 :          5 :   }
     509 [ +  + ][ +  - ]:         15 :   if (alpha && myval_zi(a0) >= 3 && myval_zi(a1) >= 2 && myval_zi(a2) >= 1)
         [ +  - ][ +  - ]
     510                 :            :   {
     511                 :         10 :     theta = gadd(theta, gen_1);
     512                 :         10 :     beta--;
     513                 :         10 :     alpha = 0;
     514                 :            :   }
     515                 :         15 :   return mkvec3(theta, stoi(alpha), stoi(beta));
     516                 :            : }
     517                 :            : 
     518                 :            : /* pol is a ZX, minimal polynomial over Z_3[i,Y]/(Y^2-3) */
     519                 :            : static GEN
     520                 :         55 : polymini_zi2(GEN pol)
     521                 :            : {
     522                 :         55 :   long alpha, beta, v = MAXVARN;
     523                 :            :   GEN a0, a1, a2, a3, a4, a5, a6;
     524                 :         55 :   GEN p, polh, rac, theta, y = pol_x(v);
     525                 :            : 
     526                 :         55 :   p = stoi(3);
     527         [ -  + ]:         55 :   if (polval(pol,p)) pari_err_BUG("polymini_zi2 [polynomial not minimal]");
     528                 :         55 :   y = mkpolmod(y, gsubgs(gsqr(y), 3)); /* mod(y,y^2-3) */
     529                 :         55 :   polh = pol;
     530                 :         55 :   polh = gdivgs(RgX_unscale(polh, y),27); /* H(y*x) / 27 */
     531   [ +  +  -  + ]:        105 :   if (myval_zi2(RgX_coeff(polh,4)) <= 0 ||
     532                 :         55 :       myval_zi2(RgX_coeff(polh,2)) <= 0) return mkcol2(gen_0, gen_0);
     533                 :            : 
     534         [ -  + ]:         50 :   if (myval_zi2(gsub(RgX_coeff(polh,6), RgX_coeff(polh,0))) > 0)
     535                 :          0 :     rac = gen_I();
     536                 :            :   else
     537                 :         50 :     rac = gen_1;
     538                 :         50 :   alpha = 0;
     539                 :         50 :   beta  = 0;
     540                 :            :   for(;;)
     541                 :            :   {
     542                 :         55 :     polh = RgX_translate(polh, rac);
     543                 :         55 :     theta = theta_3_zi2(polh);
     544         [ +  + ]:         55 :     if (gcmp(theta,gen_1) >= 0)
     545                 :            :     {
     546                 :         50 :       long ent = itos(gfloor(theta));
     547                 :         50 :       GEN pent = gpowgs(y, ent);
     548                 :         50 :       polh = RgX_Rg_div(RgX_unscale(polh, pent), gpowgs(pent,3));
     549                 :         50 :       alpha = (alpha+ent)&1;
     550                 :         50 :       beta += ent;
     551                 :         50 :       theta = gsubgs(theta,ent);
     552                 :            :     }
     553                 :         55 :     RgX_to_6(polh, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
     554 [ +  + ][ +  + ]:         55 :     if (!gequal0(theta) || !myval_zi2(a4) || !myval_zi2(a5)) break;
                 [ +  + ]
     555         [ +  - ]:          5 :     a3 = liftpol_shallow(a3); if (typ(a3)==t_POL) a3 = RgX_coeff(a3,0);
     556         [ +  - ]:          5 :     a6 = liftpol_shallow(a6); if (typ(a6)==t_POL) a6 = RgX_coeff(a6,0);
     557                 :          5 :     rac = zi_pow3mod(gdiv(a6,gneg(a3)));
     558                 :          5 :   }
     559         [ +  + ]:         50 :   if (alpha)
     560                 :            :   {
     561 [ +  - ][ +  - ]:         25 :     if (myval_zi2(a0) >= 3 && myval_zi2(a1) >= 2 && myval_zi2(a2) >= 1)
                 [ +  - ]
     562                 :            :     {
     563                 :         25 :       theta = gadd(theta,gen_1);
     564                 :         25 :       beta--;
     565                 :         25 :       alpha = 0;
     566                 :            :     }
     567                 :          0 :     else pari_err_BUG("polymini_zi2 [alpha]");
     568                 :            :   }
     569                 :         55 :   return mkcol2(theta, stoi(beta));
     570                 :            : }
     571                 :            : 
     572                 :            : 
     573                 :            : struct igusa {
     574                 :            :   GEN j2, i4, j4, j6, j8, j10, i12;
     575                 :            :   GEN a0, A2, A3, A5, B2;
     576                 :            : };
     577                 :            : struct igusa_p {
     578                 :            :   long eps, eps2, tt, r1, r2, R, tame;
     579                 :            :   GEN p, stable, val, neron;
     580                 :            :   const char *type;
     581                 :            : };
     582                 :            : 
     583                 :            : static void
     584                 :        950 : stable_reduction(struct igusa *I, struct igusa_p *Ip)
     585                 :            : {
     586                 :            :   static const long deg[9] = { 0,2,4,4,6,8,10,12 };
     587                 :        950 :   GEN j2 = I->j2, i4 = I->i4, j6 = I->j6, j8 = I->j8, j10 = I->j10;
     588                 :        950 :   GEN i12 = I->i12, p = Ip->p, val = Ip->val;
     589                 :            :   GEN J, v, s, Ieps;
     590                 :            :   long r1, r2, r3, r4, i, eps, eps2;
     591                 :            : 
     592                 :        950 :   v = cgetg(8,t_COL);
     593         [ +  + ]:       7600 :   for(i = 1; i <= 7; i++) gel(v,i) = frac2s(val[i], deg[i]);
     594                 :        950 :   s = gel(v,1);
     595         [ +  + ]:       6650 :   for(i = 2; i <= 7; i++)
     596         [ +  + ]:       5700 :     if (gcmp(gel(v,i),s) < 0) s = gel(v,i);
     597      [ +  +  + ]:        950 :   switch(itos_or_0(p))
     598                 :            :   {
     599                 :          5 :     case 2:  eps = 4; eps2 = 5; Ieps = j8; break;
     600                 :        305 :     case 3:  eps = 3; eps2 = 4; Ieps = j6; break;
     601                 :        640 :     default: eps = 1; eps2 = 1; Ieps = gdivgs(j2,12); break;
     602                 :            :   }
     603                 :        950 :   Ip->eps  = eps;
     604                 :        950 :   Ip->eps2 = eps2;
     605                 :            : 
     606                 :        950 :   r1 = 3*eps*val[3];
     607                 :        950 :   r3 = eps*val[6] + val[eps2];
     608                 :        950 :   r2 = eps*val[7];
     609                 :        950 :   r4 = min3(r1, r2, r3);
     610                 :            : 
     611                 :            :   /* s = max(v_p(X) / deg(X)) */
     612                 :        950 :   J = cgetg(1, t_VEC);
     613         [ +  + ]:        950 :   if (gequal(s,gel(v,6)))
     614                 :         90 :     Ip->tt = 1;
     615         [ +  + ]:        860 :   else if (gequal(s,gel(v,7)))
     616                 :            :   {
     617                 :         75 :     J = mkvec( Fp_to_mod(gmod(gdiv(gpowgs(i4,3),i12), p), p) );
     618                 :         75 :     Ip->tt = 2;
     619                 :            :   }
     620         [ +  + ]:        785 :   else if (gequal(s,gel(v,3)))
     621 [ +  + ][ -  + ]:        140 :     Ip->tt = (val[2] == val[3] || 2*val[4] == 3*val[3])? 3: 4;
     622         [ +  + ]:        645 :   else if (r3 == r4)
     623                 :            :   {
     624                 :        375 :     GEN a,b, P, sj, pj, t = gmul(gpowgs(j10,eps),Ieps);
     625                 :        375 :     sj = gaddsg(1728, gdiv(gpowgs(i12,eps), t));
     626                 :        375 :     pj = gdiv(gpowgs(i4,3*eps), t);
     627                 :        375 :     a = gmod(sj, p);
     628                 :        375 :     b = gmod(pj, p);
     629                 :        375 :     P = mkpoln(3, gen_1, Fp_neg(a,p), b, 0); /* X^2 - SX + P: roots j1,j2 */
     630                 :        375 :     J = FpX_roots(P, p);
     631   [ -  +  +  - ]:        375 :     switch(lg(J)-1)
     632                 :            :     {
     633                 :            :       case 0:
     634                 :          0 :         P = FpX_to_mod(P, p);
     635                 :          0 :         a = FpX_to_mod(pol_x(0), p);
     636                 :          0 :         b = FpX_to_mod(deg1pol_shallow(b, gen_m1,0), p);
     637                 :          0 :         J = mkvec2(mkpolmod(a,P), mkpolmod(b,P)); break;
     638                 :            :       case 1:
     639                 :        245 :         a = Fp_to_mod(gel(J,1), p);
     640                 :        245 :         J = mkvec2(a, a); break;
     641                 :            :       case 2:
     642                 :        130 :         settyp(J, t_VEC);
     643                 :        130 :         J = FpV_to_mod(J, p); break;
     644                 :            :     }
     645                 :        375 :     Ip->tt = 5;
     646                 :            :   }
     647         [ +  + ]:        270 :   else if (r2 == r4)
     648                 :            :   {
     649                 :        190 :     J = mkvec( Fp_to_mod(gmod(gdiv(gpowgs(i4,3),i12), p), p) );
     650                 :        190 :     Ip->tt = 6;
     651                 :            :   }
     652                 :            :   else
     653                 :         80 :     Ip->tt = 7; /* r1 == r4 */
     654                 :        950 :   Ip->stable = mkvec2(stoi(Ip->tt), J);
     655                 :        950 : }
     656                 :            : 
     657                 :            : struct red {
     658                 :            :   const char *t, *pages;
     659                 :            :   GEN g;
     660                 :            : };
     661                 :            : 
     662                 :            : /* destroy v */
     663                 :            : static GEN
     664                 :        945 : zv_snf(GEN v)
     665                 :            : {
     666                 :        945 :   long i, l = lg(v);
     667         [ +  + ]:       2080 :   for (i = 1; i < l; i++)
     668                 :            :   {
     669                 :       1135 :     long j, a = v[i];
     670         [ +  + ]:       1615 :     for (j = i+1; j < l; j++)
     671                 :            :     {
     672                 :        480 :       long b = v[j], d = ugcd(a,b);
     673                 :        480 :       v[i] = a = a*(b/d);
     674                 :        480 :       v[j] = d;
     675                 :            :     }
     676                 :            :   }
     677         [ +  + ]:       1000 :   for (i = l-1; i > 0; i--)
     678         [ +  + ]:        805 :     if (v[i] != 1) { setlg(v, i+1); break; }
     679                 :        945 :   return zv_to_ZV(v);
     680                 :            : }
     681                 :            : 
     682                 :            : static GEN
     683                 :        880 : cyclic(long n)
     684         [ +  + ]:        880 : { return (n <= 1)? cgetg(1, t_VECSMALL): mkvecsmall(n); }
     685                 :            : static GEN
     686                 :        230 : dicyclic(long a, long b)
     687                 :            : {
     688                 :            :   long d;
     689         [ -  + ]:        230 :   if (!a) a = 1;
     690         [ -  + ]:        230 :   if (!b) b = 1;
     691         [ +  + ]:        230 :   if (a < b) lswap(a,b);
     692                 :        230 :   d = ugcd(a,b);
     693         [ +  + ]:        230 :   if (d == 1) return cyclic(a*b);
     694                 :        230 :   return mkvecsmall2(a*b/d, d);
     695                 :            : }
     696                 :            : /* Z/2xZ/2, resp Z/4 for n even, resp. odd */
     697                 :            : static GEN
     698         [ +  + ]:        195 : groupH(long n) { return odd(n)? cyclic(4): dicyclic(2,2); }
     699                 :            : 
     700                 :            : static long
     701                 :        140 : get_red(struct red *S, struct igusa_p *Ip, GEN polh, GEN p, long alpha, long r)
     702                 :            : {
     703                 :        140 :   GEN val = Ip->val;
     704                 :            :   long indice;
     705   [ +  +  +  +  :        140 :   switch(r)
             +  +  +  +  
                      - ]
     706                 :            :   {
     707                 :            :     case 0:
     708                 :         25 :       indice = FpX_is_squarefree(FpX_red(polh,p), p)
     709                 :            :                ? 0
     710         [ +  + ]:         25 :                : val[6] - val[7] + val[Ip->eps2]/Ip->eps;
     711                 :         25 :       S->t = stack_sprintf("I{%ld}", indice);
     712                 :         25 :       S->pages = "159-177";
     713                 :         25 :       S->g = cyclic(indice);
     714         [ +  + ]:         25 :       return indice ? indice: 1;
     715                 :            :     case 6:
     716         [ +  + ]:         25 :       if (alpha == 0) /* H(px) /p^3 */
     717                 :         20 :         polh = RgX_Rg_div(RgX_unscale(polh,p), powiu(p,3));
     718                 :         25 :       indice = FpX_is_squarefree(FpX_red(polh,p), p)
     719                 :            :                ? 0
     720         [ +  + ]:         25 :                : val[6] - val[7] + val[Ip->eps2]/Ip->eps;
     721                 :         25 :       S->t = stack_sprintf("I*{%ld}", indice);
     722                 :         25 :       S->pages = "159-177";
     723                 :         25 :       S->g = groupH(indice);
     724                 :         25 :       return indice + 5;
     725                 :            :     case 3:
     726                 :         15 :       S->t = "III";
     727                 :         15 :       S->pages = "161-177";
     728                 :         15 :       S->g = cyclic(2);
     729                 :         15 :       return 2;
     730                 :            :     case 9:
     731                 :         15 :       S->t = "III*";
     732                 :         15 :       S->pages = "162-177";
     733                 :         15 :       S->g = cyclic(2);
     734                 :         15 :       return 8;
     735                 :            :     case 2:
     736                 :         15 :       S->t = "II";
     737                 :         15 :       S->pages = "159-174";
     738                 :         15 :       S->g = cyclic(1);
     739                 :         15 :       return 1;
     740                 :            :     case 8:
     741                 :         20 :       S->t = "IV*";
     742                 :         20 :       S->pages = "160-175";
     743                 :         20 :       S->g = cyclic(3);
     744                 :         20 :       return 7;
     745                 :            :     case 4:
     746                 :         15 :       S->t = "IV";
     747                 :         15 :       S->pages = "160-174";
     748                 :         15 :       S->g = cyclic(3);
     749                 :         15 :       return 3;
     750                 :            :     case 10:
     751                 :         10 :       S->t = "II*";
     752                 :         10 :       S->pages = "160-174";
     753                 :         10 :       S->g = cyclic(1);
     754                 :         10 :       return 9;
     755                 :          0 :     default: pari_err_BUG("get_red [type]");
     756                 :          0 :       S->t = "";
     757                 :          0 :       S->pages = ""; /* gcc -Wall */
     758                 :          0 :       S->g = NULL;
     759                 :        140 :       return -1; /*notreached*/
     760                 :            :   }
     761                 :            : }
     762                 :            : 
     763                 :            : static long labelm3(GEN polh, GEN theta, long alpha, long dismin, struct igusa *I, struct igusa_p *Ip);
     764                 :            : 
     765                 :            : /* Ip->tt = 1 */
     766                 :            : static long
     767                 :         15 : tame_1(struct igusa *I, struct igusa_p *Ip)
     768                 :            : {
     769                 :         15 :   GEN p = Ip->p, val = Ip->val;
     770                 :            :   GEN r, n, pro1, pro2;
     771                 :         15 :   long condp = -1, va0, va5;
     772                 :         15 :   va0 = myval(I->a0,p);
     773                 :         15 :   va5 = myval(I->A5,p);
     774 [ +  + ][ +  - ]:         15 :   if (!gequal0(I->A5) && 20*va0+val[6] > 6*va5)
     775                 :            :   {
     776                 :         10 :     pro1 = frac2s(val[6]-2*va5, 20);
     777                 :         10 :     pro2 = frac2s(5*val[6]-6*va5, 40);
     778                 :            :   }
     779                 :            :   else
     780                 :            :   {
     781                 :          5 :     pro1 = frac2s(10*va0-val[6], 30);
     782                 :          5 :     pro2 = frac2s(5*va0-val[6], 10);
     783                 :            :   }
     784                 :         15 :   n = lcmii(denom(pro1),denom(pro2));
     785                 :         15 :   r = modii(gmul(n,pro1), n);
     786   [ -  +  +  - ]:         15 :   switch(itos(n))
     787                 :            :   {
     788                 :            :     case 1:
     789                 :          0 :       condp = 0;
     790                 :          0 :       Ip->type = "[I{0-0-0}] page 155";
     791                 :          0 :       Ip->neron = cyclic(1); break;
     792                 :            :     case 2:
     793      [ +  +  - ]:         10 :       switch(itos(r))
     794                 :            :       {
     795                 :            :         case 0:
     796                 :          5 :           condp = 4;
     797                 :          5 :           Ip->type = "[I*{0-0-0}] page 155";
     798                 :          5 :           Ip->neron = mkvecsmall4(2,2,2,2); break;
     799                 :            :         case 1:
     800                 :          5 :           condp = 2;
     801                 :          5 :           Ip->type = "[II] page 155";
     802                 :          5 :           Ip->neron = cyclic(1); break;
     803                 :          0 :         default: pari_err_BUG("tame_1 [bug1]");
     804                 :            :       }
     805                 :         10 :       break;
     806                 :            :     case 4:
     807                 :          5 :       condp = 4;
     808                 :          5 :       Ip->type = "[VI] page 156";
     809                 :          5 :       Ip->neron = dicyclic(2,2); break;
     810                 :          0 :     default: pari_err_BUG("tame_1 [bug8]");
     811                 :            :   }
     812                 :         15 :   return condp;
     813                 :            : }
     814                 :            : 
     815                 :            : static void
     816                 :        145 : tame_234_init(struct igusa *I, struct igusa_p *Ip, long v12,
     817                 :            :                 long *pn, long *pq, long *pr, long *flc)
     818                 :            : {
     819                 :            :   long va0, va5, vb2;
     820                 :        145 :   GEN p = Ip->p, pro1, pro2, n, r, q;
     821                 :        145 :   va0 = myval(I->a0,p);
     822                 :        145 :   va5 = myval(I->A5,p);
     823                 :        145 :   vb2 = myval(I->B2,p);
     824 [ +  + ][ +  - ]:        145 :   if (9*vb2 >= 6*va0+v12 && 36*va5 >= 120*va0+5*v12)
     825                 :            :   {
     826                 :         30 :     pro1 = frac2s(12*va0-v12, 36);
     827                 :         30 :     pro2 = frac2s(6*va0-v12, 12);
     828                 :         30 :     n = lcmii(denom(pro1),denom(pro2));
     829                 :         30 :     r = gmul(n,pro1);
     830                 :         30 :     q = gmul(n,pro2);
     831                 :         30 :     *flc = 1;
     832                 :            :   }
     833 [ +  + ][ +  + ]:        115 :   else if (120*va0+5*v12 > 36*va5 && 60*vb2 >= 12*va5+5*v12)
     834                 :            :   {
     835                 :         35 :     pro1 = frac2s(36*va5-25*v12, 240);
     836                 :         35 :     n = denom(pro1);
     837                 :         35 :     q = gmul(n,pro1);
     838                 :         35 :     r = gmulsg(-2,q);
     839                 :         35 :     *flc = 1;
     840                 :            :   }
     841 [ +  - ][ +  - ]:         80 :   else if (6*va0+v12 > 9*vb2 && 12*va5+5*v12 > 60*vb2)
     842                 :            :   {
     843                 :         80 :     pro1 = frac2s(v12-6*vb2, 12);
     844                 :         80 :     pro2 = frac2s(v12-9*vb2, 12);
     845                 :         80 :     n = lcmii(denom(pro1),denom(pro2));
     846                 :         80 :     r = gmul(n,pro1);
     847                 :         80 :     q = gmul(n,pro2);
     848                 :         80 :     *flc = 2;
     849                 :            :   }
     850                 :            :   else
     851                 :            :   {
     852                 :          0 :     pari_err_BUG("tame234 [bug9]");
     853                 :        145 :     return; /*not reached*/
     854                 :            :   }
     855                 :        145 :   r = gmod(r,n);
     856                 :        145 :   q = gmod(q,n);
     857                 :        145 :   *pn = itos(n);
     858                 :        145 :   *pq = itos(q);
     859                 :        145 :   *pr = itos(r);
     860                 :            : }
     861                 :            : 
     862                 :            : /* Ip->tt = 2 */
     863                 :            : static long
     864                 :         65 : tame_2(struct igusa *I, struct igusa_p *Ip, long v12)
     865                 :            : {
     866                 :         65 :   long condp = -1, d, n, q, r, flc;
     867                 :         65 :   GEN val = Ip->val;
     868                 :         65 :   tame_234_init(I, Ip, v12, &n, &q, &r, &flc);
     869                 :         65 :   d = n * (6*val[6]-5*val[7]) / 6;
     870   [ +  +  +  +  :         65 :   switch(n)
                   +  - ]
     871                 :            :   {
     872                 :          5 :     case 1: condp = 1;
     873                 :          5 :       Ip->type = stack_sprintf("[I{%ld-0-0}] page 170", d);
     874                 :          5 :       Ip->neron = cyclic(d); break;
     875                 :            :     case 2:
     876      [ +  +  - ]:         15 :       switch(r)
     877                 :            :       {
     878                 :          5 :         case 0: condp = 4;
     879                 :          5 :           Ip->type = stack_sprintf("[I*{%ld-0-0}] page 171",d/2);
     880                 :          5 :           Ip->neron = concat(dicyclic(2,2),groupH(d/2)); break;
     881                 :            :         case 1:
     882      [ +  +  - ]:         10 :           switch(q)
     883                 :            :           {
     884                 :          5 :             case 0: condp = 2;
     885                 :          5 :               Ip->type = stack_sprintf("[II*{%ld-0}] page 172",d/2);
     886                 :          5 :               Ip->neron = cyclic(1); break;
     887                 :          5 :             case 1: condp = 3;
     888                 :          5 :               Ip->type = stack_sprintf("[II{%ld-0}] page 171",d/2);
     889                 :          5 :               Ip->neron = cyclic(2*d); break;
     890                 :          0 :             default: pari_err_BUG("tame2 [bug10]");
     891                 :            :           }
     892                 :         10 :           break;
     893                 :          0 :         default: pari_err_BUG("tame2 [bug11]");
     894                 :            :       }
     895                 :         15 :       break;
     896                 :         10 :     case 3: condp = 3;
     897                 :         10 :       Ip->neron = cyclic(d);
     898      [ +  +  - ]:         10 :       switch(r)
     899                 :            :       {
     900                 :            :         case 1:
     901                 :          5 :           Ip->type = stack_sprintf("[IV-II{%ld}] page 175", (d-2)/3);
     902                 :          5 :           break;
     903                 :            :         case 2:
     904                 :          5 :           Ip->type = stack_sprintf("[IV*-II{%ld}] page 175", (d-1)/3);
     905                 :          5 :           break;
     906                 :          0 :         default: pari_err_BUG("tame2 [bug12]");
     907                 :            :       }
     908                 :         10 :       break;
     909                 :            :     case 4:
     910      [ +  +  - ]:         30 :       switch(r)
     911                 :            :       {
     912                 :            :         case 1:
     913      [ +  +  - ]:         15 :           switch(q)
     914                 :            :           {
     915                 :         10 :             case 1: condp = 3;
     916                 :         10 :               Ip->type = stack_sprintf("[III-II{%ld}] page 177",(d-2)/4);
     917                 :         10 :               Ip->neron = cyclic(d/2); break;
     918                 :          5 :             case 3: condp = 4;
     919                 :          5 :               Ip->type = stack_sprintf("[III*-II*{%ld}] page 178",(d-2)/4);
     920                 :          5 :               Ip->neron = cyclic(8); break;
     921                 :          0 :             default: pari_err_BUG("tame2 [bug13]");
     922                 :            :           }
     923                 :         15 :           break;
     924                 :            :         case 3:
     925      [ +  +  - ]:         15 :           switch(q)
     926                 :            :           {
     927                 :          5 :             case 1: condp = 4;
     928                 :          5 :               Ip->type = stack_sprintf("[III-II*{%ld}] page 178",(d-2)/4);
     929                 :          5 :               Ip->neron = cyclic(8); break;
     930                 :         10 :             case 3: condp = 3;
     931                 :         10 :               Ip->type = stack_sprintf("[III*-II{%ld}] page 178",(d-2)/4);
     932                 :         10 :               Ip->neron = cyclic(d/2); break;
     933                 :          0 :             default: pari_err_BUG("tame2 [bug14]");
     934                 :            :           }
     935                 :         15 :           break;
     936                 :          0 :         default: pari_err_BUG("tame2 [bug15]");
     937                 :            :       }
     938                 :         30 :       break;
     939                 :            :     case 6:
     940      [ +  -  - ]:          5 :       switch(r)
     941                 :            :       {
     942                 :          5 :         case 2: condp = 4;
     943                 :          5 :           Ip->type = stack_sprintf("[II*-II*{%ld}] page 176", (d-4)/6);
     944                 :          5 :           Ip->neron = groupH((d+2)/6); break;
     945                 :          0 :         case 4: condp = 4;
     946                 :          0 :           Ip->type = stack_sprintf("[II-II*{%ld}] page 176", (d-2)/6);
     947                 :          0 :           Ip->neron = groupH((d+4)/6); break;
     948                 :            :           break;
     949                 :          0 :         default: pari_err_BUG("tame2 [bug16]");
     950                 :            :       }
     951                 :          5 :       break;
     952                 :          0 :     default: pari_err_BUG("tame2 [bug17]");
     953                 :            :   }
     954                 :         65 :   return condp;
     955                 :            : }
     956                 :            : 
     957                 :            : /* Ip->tt = 3 */
     958                 :            : static long
     959                 :         40 : tame_3(struct igusa *I, struct igusa_p *Ip, long v12)
     960                 :            : {
     961                 :         40 :   long condp = -1, n, q, r, flc;
     962                 :            :   long va5, d1, d2;
     963                 :         40 :   GEN val = Ip->val, e1, e2;
     964                 :         40 :   tame_234_init(I, Ip, v12, &n, &q, &r, &flc);
     965                 :            : 
     966                 :         40 :   va5 = 2*val[6]-5*val[3];
     967                 :         40 :   e1 = gmin(stoi(val[7]-3*val[3]),gmul2n(stoi(va5),-2));
     968                 :         40 :   e2 = gsub(gmul2n(stoi(va5),-1),e1);
     969                 :         40 :   d1 = itos(gmulsg(n,e1));
     970                 :         40 :   d2 = itos(gmulsg(n,e2));
     971   [ +  +  +  - ]:         40 :   switch(n)
     972                 :            :   {
     973                 :         10 :     case 1: condp = 2;
     974                 :         10 :       Ip->type = stack_sprintf("[I{%ld-%ld-0}] page 179", d1,d2);
     975                 :         10 :       Ip->neron = dicyclic(d1,d2); break;
     976                 :            :     case 2:
     977      [ +  +  - ]:         20 :       switch(r)
     978                 :            :       {
     979                 :         10 :         case 0: condp = 4;
     980                 :         10 :           Ip->type = stack_sprintf("[I*{%ld-%ld-0}] page 180", d1/2,d2/2);
     981                 :         10 :           Ip->neron = concat(groupH(d1/2),groupH(d2/2)); break;
     982                 :            :         case 1:
     983      [ +  -  - ]:         10 :           switch(flc)
     984                 :            :           {
     985                 :         10 :             case 1:condp = 3;
     986                 :         10 :               Ip->type = stack_sprintf("[2I{%ld}-0] page 181", d1);
     987                 :         10 :               Ip->neron = cyclic(d1); break;
     988                 :          0 :             case 2: condp = 3;
     989                 :          0 :               Ip->type = stack_sprintf("[II{%ld-%ld}] page 182",d1/2,d2/2);
     990         [ #  # ]:          0 :               if ((d1*d2-4)&7)
     991                 :          0 :                 Ip->neron = cyclic(2*d1);
     992                 :            :               else
     993                 :          0 :                 Ip->neron = dicyclic(d1,2);
     994                 :            :               /* FIXME: "or" same with d1<->d2 */
     995                 :          0 :               break;
     996                 :            :           }
     997                 :         10 :           break;
     998                 :          0 :         default: pari_err_BUG("tame3 [bug20]");
     999                 :            :       }
    1000                 :         20 :       break;
    1001                 :         10 :     case 4: condp = 4;
    1002                 :         10 :       Ip->type = stack_sprintf("[III{%ld}] page 182", d1/2);
    1003                 :         10 :       Ip->neron = groupH(d1/2); break;
    1004                 :          0 :     default: pari_err_BUG("tame3 [bug21]");
    1005                 :            :   }
    1006                 :         40 :   return condp;
    1007                 :            : }
    1008                 :            : 
    1009                 :            : /* Ip->tt = 4 */
    1010                 :            : static long
    1011                 :         40 : tame_4(struct igusa *I, struct igusa_p *Ip, long v12)
    1012                 :            : {
    1013                 :         40 :   long condp = -1, d1, d2, d3, f1, f2, g, h, n, q, r, flc;
    1014                 :         40 :   GEN val = Ip->val, e1, e2, e3, vl, vn, vm;
    1015                 :         40 :   tame_234_init(I, Ip, v12, &n, &q, &r, &flc);
    1016                 :         40 :   vl = stoi(val[6]-5*val[1]);
    1017                 :         40 :   vn = stoi(val[7]-6*val[1]);
    1018                 :         40 :   vm = stoi(val[2]-2*val[1]);
    1019                 :         40 :   e1 = gmin3(gdivgs(vl,3), gmul2n(vn,-1), vm);
    1020                 :         40 :   e2 = gmin(gmul2n(gsub(vl,e1),-1), gsub(vn,e1));
    1021                 :         40 :   e3 = gsub(vl,gadd(e1,e2));
    1022                 :         40 :   d1 = itos(gmulsg(n,e1));
    1023                 :         40 :   d2 = itos(gmulsg(n,e2));
    1024                 :         40 :   d3 = itos(gmulsg(n,e3));
    1025                 :         40 :   g = d1*d2 + d1*d3 + d2*d3;
    1026                 :         40 :   h = cgcd(cgcd(d1,d2),d3);
    1027   [ +  +  -  -  :         40 :   switch(n)
                      - ]
    1028                 :            :   {
    1029                 :          5 :     case 1: condp = 2;
    1030                 :          5 :       Ip->type = stack_sprintf("[I{%ld-%ld-%ld}] page 182",d1,d2,d3);
    1031                 :          5 :       Ip->neron = dicyclic(h,g/h); break;
    1032                 :            :     case 2:
    1033      [ +  +  - ]:         35 :       switch(r)
    1034                 :            :       {
    1035                 :          5 :         case 0: condp = 4;
    1036                 :          5 :           Ip->type = stack_sprintf("[I*{%ld-%ld-%ld}] page 183",d1/2,d2/2,d3/2);
    1037                 :          5 :           Ip->neron = concat(groupH(g/4), groupH(2-((h&2)>>1))); break;
    1038                 :            :         case 1:
    1039 [ -  + ][ #  # ]:         30 :           if      (d1 == d2 || d1 == d3) f2 = d1;
    1040         [ #  # ]:          0 :           else if (d2 == d3) f2 = d2;
    1041                 :            :           else {
    1042                 :          0 :             pari_err_BUG("tame4 [bug23]");
    1043                 :          0 :             return -1; /*not reached*/
    1044                 :            :           }
    1045                 :         30 :           f1 = d1+d2+d3-2*f2;
    1046      [ +  +  - ]:         30 :           switch(q)
    1047                 :            :           {
    1048                 :         10 :             case 0: condp = 3;
    1049                 :         10 :               Ip->type = stack_sprintf("[II*{%ld-%ld}] page 184", f1/2,f2);
    1050                 :         10 :               Ip->neron = cyclic(f2); break;
    1051                 :         20 :             case 1: condp = 3;
    1052                 :         20 :               Ip->type = stack_sprintf("[II{%ld-%ld}] page 183", f1/2,f2);
    1053                 :         20 :               Ip->neron = cyclic(2*f1+f2); break;
    1054                 :          0 :             default: pari_err_BUG("tame4 [bug24]");
    1055                 :            :           }
    1056                 :         30 :           break;
    1057                 :          0 :         default: pari_err_BUG("tame4 [bug25]");
    1058                 :            :       }
    1059                 :         35 :       break;
    1060                 :          0 :     case 3: condp = 4;
    1061                 :          0 :       Ip->type = stack_sprintf("[III{%ld}] page 184",d1);
    1062         [ #  # ]:          0 :       Ip->neron = (d1%3)? cyclic(9): dicyclic(3,3); break;
    1063                 :          0 :     case 6: condp = 4;
    1064                 :          0 :       Ip->type = stack_sprintf("[III*{%ld}] page 184",d1/2);
    1065                 :          0 :       Ip->neron = cyclic(1); break;
    1066                 :          0 :     default: pari_err_BUG("tame4 [bug26]");
    1067                 :            :   }
    1068                 :         40 :   return condp;
    1069                 :            : }
    1070                 :            : 
    1071                 :            : /* p = 3 */
    1072                 :            : static void
    1073                 :         65 : tame_567_init_3(struct igusa_p *Ip, GEN dk,
    1074                 :            :                 long *pd, long *pn, long *pdm, long *pr)
    1075                 :            : {
    1076                 :         65 :   long n = 1 + Ip->r1/6;
    1077                 :         65 :   *pd = itos(gmulgs(dk,n));
    1078                 :         65 :   *pn = n;
    1079                 :         65 :   *pr = -1; /* unused */
    1080                 :         65 :   *pdm = 0;
    1081                 :         65 : }
    1082                 :            : 
    1083                 :            : static void
    1084                 :        430 : tame_567_init(struct igusa *I, struct igusa_p *Ip, GEN dk,
    1085                 :            :               long *pd, long *pn, long *pdm, long *pr)
    1086                 :            : {
    1087                 :            :   long va0, va2, va3, va5, vb2;
    1088                 :            :   long d, v1, v2;
    1089                 :            :   GEN r, n, m;
    1090                 :            :   GEN pro1, dm, rk;
    1091                 :        430 :   GEN p = Ip->p, val = Ip->val;
    1092                 :            :   long v5;
    1093                 :            : 
    1094         [ +  + ]:        430 :   if (equalis(p, 3)) { tame_567_init_3(Ip, dk, pd, pn, pdm, pr); return; }
    1095                 :            :   /* assume p > 3 */
    1096                 :        365 :   va0 = myval(I->a0,p);
    1097                 :        365 :   va2 = myval(I->A2,p);
    1098                 :        365 :   va3 = myval(I->A3,p);
    1099                 :        365 :   va5 = myval(I->A5,p);
    1100                 :        365 :   vb2 = myval(I->B2,p);
    1101                 :        365 :   v5 = myval(subii(mulii(I->A2,I->A3),mulsi(3,I->A5)),p);
    1102                 :        365 :   rk = gadd(frac2s(va0, 2),
    1103                 :            :             gmin3(gmul2n(dk,-1),
    1104                 :        365 :                   frac2s(2*va3-3*va2, 8),
    1105                 :        365 :                   frac2s(2*v5 - 5*va2, 12)));
    1106                 :        365 :   v1 = 2*va3-4*va0-val[1];
    1107                 :        365 :   v2 = 6*va5-20*va0-5*val[1];
    1108                 :            :   /* the definition of n differs according to the parity of val[1] */
    1109         [ +  + ]:        365 :   if (! odd(val[Ip->eps2]))
    1110                 :            :   {
    1111 [ +  + ][ +  - ]:        300 :     if (3*vb2 >= 2*va0+2*val[1] && v1 >= 0 && v2 >= 0
                 [ +  - ]
    1112 [ +  + ][ -  + ]:        175 :                                 && (v1 == 0 || v2 == 0))
    1113                 :            :     { /* Prop 4.3.1 (a) */
    1114                 :         10 :       pro1 = frac2s(va0+val[1], 6);
    1115                 :         10 :       n = lcmii(denom(dk),denom(pro1));
    1116                 :         10 :       r = gmul(n,pro1);
    1117                 :            :     }
    1118 [ +  + ][ +  - ]:        290 :     else if (20*va0+5*val[1] > 6*va5 && 10*vb2 >= 2*va5+5*val[1])
    1119                 :            :     { /* Prop 4.3.1 (b) */
    1120                 :        125 :       pro1 = frac2s(2*va5+val[1], 8);
    1121                 :        125 :       n = lcmii(denom(dk),denom(pro1));
    1122                 :        125 :       r = gmul(n,pro1);
    1123                 :            :     }
    1124 [ -  + ][ #  # ]:        165 :     else if (2*va0+2*val[1] > 3*vb2 && 2*va5+5*val[1] > 10*vb2)
    1125                 :            :     { /* Prop 4.3.1 (c) */
    1126                 :          0 :       pro1 = gmul2n(stoi(vb2),-2);
    1127                 :          0 :       n = lcmii(denom(dk),denom(pro1));
    1128                 :          0 :       r = gmul(n,pro1);
    1129                 :            :     }
    1130 [ +  - ][ +  - ]:        165 :     else if (3*vb2 >= 2*va0+2*val[1] && 2*va3 > 4*va0+val[1]
    1131         [ +  - ]:        165 :                                      && 6*va5 > 20*va0+5*val[1])
    1132                 :            :     { /* Prop 4.3.1 (d) */
    1133         [ -  + ]:        165 :       if (gequal0(I->A2)) pari_err_BUG("tame567 [bug27]");
    1134                 :        165 :       n = lcmii(denom(dk),denom(rk));
    1135                 :        165 :       r = gmul(n,rk);
    1136                 :            :     }
    1137                 :            :     else
    1138                 :            :     {
    1139                 :          0 :       pari_err_BUG("tame567 [bug29]");
    1140                 :        300 :       return; /*not reached*/
    1141                 :            :     }
    1142                 :            :   }
    1143                 :            :   else
    1144                 :            :   {
    1145                 :         65 :     m = denom(dk);
    1146                 :         65 :     r = gmul(m,dk);
    1147                 :         65 :     n = gmul2n(m,1);
    1148                 :            :   }
    1149                 :        365 :   d = itos(gmul(n,dk));
    1150                 :        365 :   dm = modsi(d,n);
    1151                 :        365 :   r = modii(r,n);
    1152                 :        365 :   *pd = d;
    1153                 :        365 :   *pn = itos(n);
    1154                 :        365 :   *pr = itos(r);
    1155                 :        430 :   *pdm = itos(dm);
    1156                 :            : }
    1157                 :            : 
    1158                 :            : static long
    1159                 :        235 : tame_5(struct igusa *I, struct igusa_p *Ip, GEN dk)
    1160                 :            : {
    1161                 :        235 :   long condp = -1, d, n, dm, r;
    1162                 :        235 :   GEN val = Ip->val;
    1163                 :            : 
    1164                 :        235 :   tame_567_init(I, Ip, dk, &d, &n, &dm, &r);
    1165         [ +  + ]:        235 :   if (! odd(val[Ip->eps2]))
    1166                 :            :   {
    1167   [ +  +  +  +  :        190 :     switch(n)
                +  +  - ]
    1168                 :            :     {
    1169                 :          5 :       case 1: condp = 0;
    1170                 :          5 :         Ip->type = stack_sprintf("[I{0}-I{0}-%ld] page 158", d);
    1171                 :          5 :         Ip->neron = cyclic(1); break;
    1172                 :            :       case 2:
    1173      [ +  +  - ]:         10 :         switch(dm)
    1174                 :            :         {
    1175                 :          5 :           case 0: condp = 4;
    1176                 :          5 :             Ip->type = stack_sprintf("[I*{0}-I*{0}-%ld] page 158",(d-2)/2);
    1177                 :          5 :             Ip->neron = mkvecsmall4(2,2,2,2); break;
    1178                 :          5 :           case 1: condp = 2;
    1179                 :          5 :             Ip->type = stack_sprintf("[I{0}-I*{0}-%ld] page 159",(d-1)/2);
    1180                 :          5 :             Ip->neron = dicyclic(2,2); break;
    1181                 :            :         }
    1182                 :         10 :         break;
    1183                 :            :       case 3:
    1184   [ +  +  +  - ]:         25 :         switch(dm)
    1185                 :            :         {
    1186                 :          5 :           case 0: condp = 4;
    1187                 :          5 :             Ip->type = stack_sprintf("[IV-IV*-%ld] page 165",(d-3)/3);
    1188                 :          5 :             Ip->neron = dicyclic(3,3); break;
    1189                 :            :           case 1:
    1190      [ +  +  - ]:         10 :             switch(r)
    1191                 :            :             {
    1192                 :          5 :               case 0: case 1: condp = 2;
    1193                 :          5 :                 Ip->type = stack_sprintf("[I{0}-IV-%ld] page 160",(d-1)/3);
    1194                 :          5 :                 Ip->neron = cyclic(3); break;
    1195                 :          5 :               case 2: condp = 4;
    1196                 :          5 :                 Ip->type = stack_sprintf("[IV*-IV*-%ld] page 166",(d-4)/3);
    1197                 :          5 :                 Ip->neron = dicyclic(3,3); break;
    1198                 :            :             }
    1199                 :         10 :             break;
    1200                 :            :           case 2:
    1201      [ +  +  - ]:         10 :             switch(r)
    1202                 :            :             {
    1203                 :          5 :               case 0: case 2: condp = 2;
    1204                 :          5 :                 Ip->type = stack_sprintf("[I{0}-IV*-%ld] page 160",(d-2)/3);
    1205                 :          5 :                 Ip->neron = cyclic(3); break;
    1206                 :          5 :               case 1: condp = 4;
    1207                 :          5 :                 Ip->type = stack_sprintf("[IV-IV-%ld] page 165",(d-2)/3);
    1208                 :          5 :                 Ip->neron = dicyclic(3,3); break;
    1209                 :            :             }
    1210                 :         10 :             break;
    1211                 :            :         }
    1212                 :         25 :         break;
    1213                 :            :       case 4:
    1214   [ +  +  +  +  :         35 :         switch(dm)
                      - ]
    1215                 :            :         {
    1216                 :          5 :           case 0: condp = 4;
    1217                 :          5 :             Ip->type = stack_sprintf("[III-III*-%ld] page 169",(d-4)/4);
    1218                 :          5 :             Ip->neron = dicyclic(2,2); break;
    1219                 :            :           case 1:
    1220      [ +  +  - ]:         10 :             switch(r)
    1221                 :            :             {
    1222                 :          5 :               case 0: case 1: condp = 2;
    1223                 :          5 :                 Ip->type = stack_sprintf("[I{0}-III-%ld] page 161",(d-1)/4);
    1224                 :          5 :                 Ip->neron = cyclic(2); break;
    1225                 :          5 :               case 2: case 3: condp = 4;
    1226                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-III*-%ld] page 162",(d-5)/4);
    1227                 :          5 :                 Ip->neron = mkvecsmall3(2,2,2); break;
    1228                 :            :             }
    1229                 :         10 :             break;
    1230                 :         10 :           case 2: condp = 4;
    1231                 :         10 :             Ip->neron = dicyclic(2,2);
    1232      [ +  +  - ]:         10 :             switch(r)
    1233                 :            :             {
    1234                 :            :               case 1:
    1235                 :          5 :                 Ip->type = stack_sprintf("[III-III-%ld] page 169",(d-2)/4);
    1236                 :          5 :                 break;
    1237                 :            :               case 3:
    1238                 :          5 :                 Ip->type = stack_sprintf("[III*-III*-%ld] page 169",(d-6)/4);
    1239                 :          5 :                 break;
    1240                 :          0 :               default: pari_err_BUG("tame5 [bug29]");
    1241                 :            :             }
    1242                 :         10 :             break;
    1243                 :            :           case 3:
    1244      [ +  +  - ]:         10 :             switch(r)
    1245                 :            :             {
    1246                 :          5 :               case 0: case 3: condp = 2;
    1247                 :          5 :                 Ip->type = stack_sprintf("[I{0}-III*-%ld] page 162",(d-3)/4);
    1248                 :          5 :                 Ip->neron = cyclic(2); break;
    1249                 :          5 :               case 1: case 2: condp = 4;
    1250                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-III-%ld] page 162",(d-3)/4);
    1251                 :          5 :                 Ip->neron = mkvecsmall3(2,2,2); break;
    1252                 :            :             }
    1253                 :         10 :             break;
    1254                 :            :         }
    1255                 :         35 :         break;
    1256                 :            :       case 6:
    1257   [ +  +  +  +  :         75 :         switch(dm)
                +  +  - ]
    1258                 :            :         {
    1259                 :          5 :           case 0: condp = 4;
    1260                 :          5 :             Ip->type = stack_sprintf("[II-II*-%ld] page 163",(d-6)/6);
    1261                 :          5 :             Ip->neron = cyclic(1); break;
    1262                 :            :           case 1:
    1263   [ +  +  +  - ]:         15 :             switch(r)
    1264                 :            :             {
    1265                 :          5 :               case 0: case 1: condp = 2;
    1266                 :          5 :                 Ip->type = stack_sprintf("[I{0}-II-%ld] page 159",(d-1)/6);
    1267                 :          5 :                 Ip->neron = cyclic(1); break;
    1268                 :          5 :               case 2: case 5: condp = 4;
    1269                 :          5 :                 Ip->type = stack_sprintf("[II*-IV-%ld] page 164",(d-7)/6);
    1270                 :          5 :                 Ip->neron = cyclic(3); break;
    1271                 :          5 :               case 3: case 4: condp = 4;
    1272                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-IV*-%ld] page 161",(d-7)/6);
    1273                 :          5 :                 Ip->neron = mkvecsmall2(6,2); break;
    1274                 :            :             }
    1275                 :         15 :             break;
    1276                 :            :           case 2:
    1277      [ +  +  - ]:         15 :             switch(r)
    1278                 :            :             {
    1279                 :         10 :               case 1: condp = 4;
    1280                 :         10 :                 Ip->type = stack_sprintf("[II-II-%ld] page 163",(d-2)/6);
    1281                 :         10 :                 Ip->neron = cyclic(1); break;
    1282                 :          5 :               case 3: case 5: condp = 4;
    1283                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-II*-%ld] page 160",(d-8)/6);
    1284                 :          5 :                 Ip->neron = dicyclic(2,2); break;
    1285                 :          0 :               default: pari_err_BUG("tame5 [bug30]");
    1286                 :            :             }
    1287                 :         15 :             break;
    1288                 :            :           case 3:
    1289                 :         10 :             Ip->neron = cyclic(3);
    1290      [ +  +  - ]:         10 :             switch(r)
    1291                 :            :             {
    1292                 :          5 :               case 1: case 2: condp = 4;
    1293                 :          5 :                 Ip->type = stack_sprintf("[II-IV-%ld] page 164",(d-3)/6);
    1294                 :          5 :                 break;
    1295                 :          5 :               case 4: case 5: condp = 4;
    1296                 :          5 :                 Ip->type = stack_sprintf("[II*-IV*-%ld] page 164",(d-9)/6);
    1297                 :          5 :                 break;
    1298                 :          0 :               default: pari_err_BUG("tame5 [bug31]");
    1299                 :            :             }
    1300                 :         10 :             break;
    1301                 :            :           case 4:
    1302      [ +  +  - ]:         15 :             switch(r)
    1303                 :            :             {
    1304                 :          5 :               case 1: case 3: condp = 4;
    1305                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-II-%ld] page 160",(d-4)/6);
    1306                 :          5 :                 Ip->neron = dicyclic(2,2); break;
    1307                 :         10 :               case 5: condp = 4;
    1308                 :         10 :                 Ip->type = stack_sprintf("[II*-II*-%ld] page 163",(d-10)/6);
    1309                 :         10 :                 Ip->neron = cyclic(1); break;
    1310                 :          0 :               default: pari_err_BUG("tame5 [bug32]");
    1311                 :            :             }
    1312                 :         15 :             break;
    1313                 :            :           case 5:
    1314   [ +  +  +  - ]:         15 :             switch(r)
    1315                 :            :             {
    1316                 :          5 :               case 0: case 5: condp = 2;
    1317                 :          5 :                 Ip->type = stack_sprintf("[I{0}-II*-%ld] page 160",(d-5)/6);
    1318                 :          5 :                 Ip->neron = cyclic(1); break;
    1319                 :          5 :               case 1: case 4: condp = 4;
    1320                 :          5 :                 Ip->type = stack_sprintf("[II-IV*-%ld] page 164",(d-5)/6);
    1321                 :          5 :                 Ip->neron = cyclic(3); break;
    1322                 :          5 :               case 2: case 3: condp = 4;
    1323                 :          5 :                 Ip->type = stack_sprintf("[I*{0}-IV-%ld] page 161",(d-5)/6);
    1324                 :          5 :                 Ip->neron = mkvecsmall2(6,2); break;
    1325                 :            :             }
    1326                 :         15 :             break;
    1327                 :          0 :           default: pari_err_BUG("tame5 [bug33]");
    1328                 :            :         }
    1329                 :         75 :         break;
    1330                 :            :       case 12:
    1331                 :         40 :         condp = 4;
    1332   [ +  +  +  +  :         40 :         switch(dm)
                      - ]
    1333                 :            :         {
    1334                 :            :           case 1:
    1335      [ +  +  - ]:         10 :             switch(r)
    1336                 :            :             {
    1337                 :            :               case 3: case 10:
    1338                 :          5 :                 Ip->type = stack_sprintf("[II*-III-%ld] page 166",(d-13)/12);
    1339                 :          5 :                 Ip->neron = cyclic(2); break;
    1340                 :            :               case 4: case 9:
    1341                 :          5 :                 Ip->type = stack_sprintf("[IV-III*-%ld] page 167",(d-13)/12);
    1342                 :          5 :                 Ip->neron = cyclic(6); break;
    1343                 :          0 :               default: pari_err_BUG("tame5 [bug34]");
    1344                 :            :             }
    1345                 :         10 :             break;
    1346                 :            :           case 5:
    1347      [ +  +  - ]:         10 :             switch(r)
    1348                 :            :             {
    1349                 :            :               case 2: case 3:
    1350                 :          5 :                 Ip->type = stack_sprintf("[II-III-%ld] page 166",(d-5)/12);
    1351                 :          5 :                 Ip->neron = cyclic(2); break;
    1352                 :            :               case 8: case 9:
    1353                 :          5 :                 Ip->type = stack_sprintf("[IV*-III*-%ld] page 168",(d-17)/12);
    1354                 :          5 :                 Ip->neron = cyclic(6); break;
    1355                 :          0 :               default: pari_err_BUG("tame5 [bug35]");
    1356                 :            :             }
    1357                 :         10 :             break;
    1358                 :            :           case 7:
    1359      [ +  +  - ]:         10 :             switch(r)
    1360                 :            :             {
    1361                 :            :               case 3: case 4:
    1362                 :          5 :                 Ip->type = stack_sprintf("[IV-III-%ld] page 167",(d-7)/12);
    1363                 :          5 :                 Ip->neron = cyclic(6); break;
    1364                 :            :               case 9: case 10:
    1365                 :          5 :                 Ip->type = stack_sprintf("[II*-III*-%ld] page 167",(d-19)/12);
    1366                 :          5 :                 Ip->neron = cyclic(2); break;
    1367                 :          0 :               default: pari_err_BUG("tame5 [bug36]");
    1368                 :            :             }
    1369                 :         10 :             break;
    1370                 :            :           case 11:
    1371      [ +  +  - ]:         10 :             switch(r)
    1372                 :            :             {
    1373                 :            :               case 3: case 8:
    1374                 :          5 :                 Ip->type = stack_sprintf("[IV*-III-%ld] page 168",(d-11)/12);
    1375                 :          5 :                 Ip->neron = cyclic(6); break;
    1376                 :            :               case 2: case 9:
    1377                 :          5 :                 Ip->type = stack_sprintf("[II-III*-%ld] page 166",(d-11)/12);
    1378                 :          5 :                 Ip->neron = cyclic(2); break;
    1379                 :          0 :               default: pari_err_BUG("tame5 [bug37]");
    1380                 :            :             }
    1381                 :         10 :             break;
    1382                 :          0 :           default: pari_err_BUG("tame5 [bug38]");
    1383                 :            :         }
    1384                 :         40 :         break;
    1385                 :        190 :       default: pari_err_BUG("tame5 [bug39]");
    1386                 :            :     }
    1387                 :            :   }
    1388                 :            :   else
    1389                 :            :   {
    1390                 :         45 :     r %= (n >> 1);
    1391   [ +  +  +  +  :         45 :     switch(n)
                   +  - ]
    1392                 :            :     {
    1393                 :          5 :       case 2: condp = 2;
    1394                 :          5 :         Ip->type = stack_sprintf("[2I{0}-%ld] page 159",(d/2));
    1395                 :          5 :         Ip->neron = cyclic(1); break;
    1396                 :         10 :       case 4: condp = 4;
    1397                 :         10 :         Ip->type = stack_sprintf("[2I*{0}-%ld] page 159",(d/2-1)/2);
    1398                 :         10 :         Ip->neron = dicyclic(2,2); break;
    1399                 :         10 :       case 6: condp = 4;
    1400                 :         10 :         Ip->neron = cyclic(3);
    1401      [ +  +  - ]:         10 :         switch(r)
    1402                 :            :           {
    1403                 :            :           case 1:
    1404                 :          5 :             Ip->type = stack_sprintf("[2IV-%ld] page 165",(d/2-1)/3);
    1405                 :          5 :             break;
    1406                 :            :           case 2:
    1407                 :          5 :             Ip->type = stack_sprintf("[2IV*-%ld] page 165",(d/2-2)/3);
    1408                 :          5 :             break;
    1409                 :          0 :           default: pari_err_BUG("tame5 [bug40]");
    1410                 :            :           }
    1411                 :         10 :         break;
    1412                 :         10 :       case 8: condp = 4;
    1413                 :         10 :         Ip->neron = cyclic(2);
    1414      [ +  +  - ]:         10 :         switch(r)
    1415                 :            :         {
    1416                 :            :           case 1:
    1417                 :          5 :             Ip->type = stack_sprintf("[2III-%ld] page 168",(d/2-1)/4);
    1418                 :          5 :             break;
    1419                 :            :           case 3:
    1420                 :          5 :             Ip->type = stack_sprintf("[2III*-%ld] page 168",(d/2-3)/4);
    1421                 :          5 :             break;
    1422                 :          0 :           default: pari_err_BUG("tame5 [bug41]");
    1423                 :            :         }
    1424                 :         10 :         break;
    1425                 :         10 :       case 12: condp = 4;
    1426                 :         10 :         Ip->neron = cyclic(1);
    1427      [ +  +  - ]:         10 :         switch(r)
    1428                 :            :         {
    1429                 :            :           case 1:
    1430                 :          5 :             Ip->type = stack_sprintf("[2II-%ld] page 162",(d/2-1)/6);
    1431                 :          5 :             break;
    1432                 :            :           case 5:
    1433                 :          5 :             Ip->type = stack_sprintf("[2II*-%ld] page 163",(d/2-5)/6);
    1434                 :          5 :             break;
    1435                 :          0 :           default: pari_err_BUG("tame5 [bug42]");
    1436                 :            :         }
    1437                 :         10 :         break;
    1438                 :          0 :       default: pari_err_BUG("tame5 [bug43]");
    1439                 :            :     }
    1440                 :            :   }
    1441                 :        235 :   return condp;
    1442                 :            : }
    1443                 :            : 
    1444                 :            : static long
    1445                 :        130 : tame_6(struct igusa *I, struct igusa_p *Ip, GEN dk,
    1446                 :            :          GEN polh, GEN theta, long alpha, long dismin)
    1447                 :            : {
    1448                 :        130 :   long condp = -1, d, d1, n, dm, r;
    1449                 :        130 :   GEN val = Ip->val, d1k;
    1450                 :            : 
    1451                 :        130 :   tame_567_init(I, Ip, dk, &d, &n, &dm, &r);
    1452                 :        130 :   d1k = frac2s(Ip->eps*(val[6]-val[7])+val[Ip->eps2], Ip->eps);
    1453                 :        130 :   d1 = itos(gmulsg(n,d1k));
    1454   [ +  +  +  +  :        130 :   switch(n)
                   +  - ]
    1455                 :            :   {
    1456                 :         40 :     case 1: condp = 1;
    1457                 :         40 :       Ip->type = stack_sprintf("[I{%ld}-I{0}-%ld] page 170",d1,d);
    1458                 :         40 :       Ip->neron = cyclic(d1); break;
    1459                 :            :     case 2:
    1460      [ +  +  - ]:         15 :       switch(dm)
    1461                 :            :       {
    1462                 :          5 :         case 0: condp = 4;
    1463                 :          5 :           Ip->type=stack_sprintf("[I*{0}-I*{%ld}-%ld] page 171", d1/2,(d-2)/2);
    1464                 :          5 :           Ip->neron = concat(groupH(d1/2), dicyclic(2,2)); break;
    1465                 :         10 :         case 1: return labelm3(polh,theta,alpha,dismin,I,Ip);
    1466                 :          0 :         default: pari_err_BUG("tame6 [bug44]");
    1467                 :            :       }
    1468                 :          5 :       break;
    1469                 :         10 :     case 3: condp = 3;
    1470                 :         10 :       Ip->neron = dicyclic(3,d1/3);
    1471      [ +  +  - ]:         10 :       switch(dm)
    1472                 :            :       {
    1473                 :            :         case 1:
    1474                 :          5 :           Ip->type = stack_sprintf("[IV-I{%ld}-%ld] page 173",d1/3,(d-1)/3);
    1475                 :          5 :           break;
    1476                 :            :         case 2:
    1477                 :          5 :           Ip->type = stack_sprintf("[IV*-I{%ld}-%ld] page 173",d1/3,(d-2)/3);
    1478                 :          5 :           break;
    1479                 :          0 :         default: pari_err_BUG("tame6 [bug45]");
    1480                 :            :       }
    1481                 :         10 :       break;
    1482                 :            :     case 4:
    1483      [ +  +  - ]:         25 :       switch(dm)
    1484                 :            :       {
    1485                 :            :         case 1:
    1486      [ +  +  - ]:         15 :           switch(r)
    1487                 :            :           {
    1488                 :          5 :             case 0: case 1: condp = 3;
    1489                 :          5 :               Ip->type=stack_sprintf("[III-I{%ld}-%ld] page 176",d1/4,(d-1)/4);
    1490                 :          5 :               Ip->neron = dicyclic(2,d1/4); break;
    1491                 :         10 :             case 2: case 3: condp = 4;
    1492                 :         10 :               Ip->type=stack_sprintf("[III*-I*{%ld}-%ld] page 177",d1/4,(d-5)/4);
    1493                 :         10 :               Ip->neron = concat(groupH(d1/4), cyclic(2)); break;
    1494                 :            :               break;
    1495                 :          0 :             default: pari_err_BUG("tame6 [bug46]");
    1496                 :            :           }
    1497                 :         15 :           break;
    1498                 :            :         case 3:
    1499      [ +  +  - ]:         10 :           switch(r)
    1500                 :            :           {
    1501                 :          5 :             case 0: case 3: condp = 3;
    1502                 :          5 :               Ip->type=stack_sprintf("[III*-I{%ld}-%ld] page 176",d1/4,(d-3)/4);
    1503                 :          5 :               Ip->neron = dicyclic(2,d1/4); break;
    1504                 :          5 :             case 1: case 2: condp = 4;
    1505                 :          5 :               Ip->type=stack_sprintf("[III-I*{%ld}-%ld] page 177",d1/4,(d-3)/4);
    1506                 :          5 :               Ip->neron = concat(groupH(d1/4), cyclic(2)); break;
    1507                 :          0 :             default: pari_err_BUG("tame6 [bug47]");
    1508                 :            :           }
    1509                 :         10 :           break;
    1510                 :          0 :         default: pari_err_BUG("tame6 [bug48]");
    1511                 :            :       }
    1512                 :         25 :       break;
    1513                 :            :     case 6:
    1514   [ +  +  +  +  :         40 :       switch(dm)
                      - ]
    1515                 :            :       {
    1516                 :            :         case 1:
    1517      [ +  +  - ]:         15 :           switch(r)
    1518                 :            :           {
    1519                 :          5 :             case 0: case 1: condp = 3;
    1520                 :          5 :               Ip->type = stack_sprintf("[II-I{%ld}-%ld] page 172",d1/6,(d-1)/6);
    1521                 :          5 :               Ip->neron = cyclic(d1/6); break;
    1522                 :         10 :             case 3: case 4: condp = 4;
    1523                 :         10 :               Ip->type=stack_sprintf("[IV*-I*{%ld}-%ld] page 174",d1/6,(d-7)/6);
    1524                 :         10 :               Ip->neron = concat(groupH(d1/6), cyclic(3)); break;
    1525                 :          0 :             default: pari_err_BUG("tame6 [bug49]");
    1526                 :            :           }
    1527                 :         15 :           break;
    1528                 :         10 :         case 2: condp = 4;
    1529                 :         10 :           Ip->type = stack_sprintf("[II*-I*{%ld}-%ld] page 174",d1/6,(d-8)/6);
    1530                 :         10 :           Ip->neron = groupH(d1/6); break;
    1531                 :          5 :         case 4: condp = 4;
    1532                 :          5 :           Ip->type = stack_sprintf("[II-I*{%ld}-%ld] page 173",d1/6,(d-4)/6);
    1533                 :          5 :           Ip->neron = groupH(d1/6); break;
    1534                 :            :         case 5:
    1535      [ +  +  - ]:         10 :           switch(r)
    1536                 :            :           {
    1537                 :          5 :             case 0: case 5: condp = 3;
    1538                 :          5 :               Ip->type=stack_sprintf("[II*-I{%ld}-%ld] page 172",d1/6,(d-5)/6);
    1539                 :          5 :               Ip->neron = cyclic(d1/6); break;
    1540                 :          5 :             case 2: case 3: condp = 4;
    1541                 :          5 :               Ip->type=stack_sprintf("[IV-I*{%ld}-%ld] page 174",d1/6,(d-5)/6);
    1542                 :          5 :               Ip->neron = concat(groupH(d1/6), cyclic(3)); break;
    1543                 :          0 :             default: pari_err_BUG("tame6 [bug50]");
    1544                 :            :           }
    1545                 :         10 :           break;
    1546                 :          0 :         default: pari_err_BUG("tame6 [bug51]");
    1547                 :            :       }
    1548                 :         40 :       break;
    1549                 :          0 :     default: pari_err_BUG("tame6 [bug52]");
    1550                 :            :   }
    1551                 :        130 :   return condp;
    1552                 :            : }
    1553                 :            : 
    1554                 :            : static long
    1555                 :         65 : tame_7(struct igusa *I, struct igusa_p *Ip, GEN dk,
    1556                 :            :          GEN polh, GEN theta, long alpha, long dismin)
    1557                 :            : {
    1558                 :         65 :   long condp = -1, d, d1, d2, n, dm, r;
    1559                 :         65 :   GEN val = Ip->val, d1k, d2k, pro1;
    1560                 :            : 
    1561                 :         65 :   tame_567_init(I, Ip, dk, &d, &n, &dm, &r);
    1562                 :         65 :   pro1 = frac2s(Ip->eps*val[6]+val[Ip->eps2]-3*Ip->eps*val[3], Ip->eps);
    1563                 :         65 :   d1k = gmin(stoi(val[7]-3*val[3]),gmul2n(pro1,-1));
    1564                 :         65 :   d2k = gsub(pro1,d1k);
    1565                 :            : 
    1566                 :         65 :   d1 = itos(gmulsg(n,d1k));
    1567                 :         65 :   d2 = itos(gmulsg(n,d2k));
    1568   [ +  +  +  - ]:         65 :   switch(n)
    1569                 :            :   {
    1570                 :         30 :     case 1: condp = 2;
    1571                 :         30 :       Ip->type = stack_sprintf("[I{%ld}-I{%ld}-%ld] page 179",d1,d2,d);
    1572                 :         30 :       Ip->neron = dicyclic(d1,d2); break;
    1573                 :            :     case 2:
    1574         [ +  + ]:         25 :       if ( odd(val[Ip->eps2]) )
    1575                 :            :       {
    1576                 :         10 :         condp = 3;
    1577                 :         10 :         Ip->type = stack_sprintf("[2I{%ld}-%ld] page 181",d1,d/2);
    1578                 :         10 :         Ip->neron = cyclic(d1);
    1579                 :            :       }
    1580         [ +  + ]:         15 :       else if (dm == 0)
    1581                 :            :       {
    1582                 :         10 :         condp = 4;
    1583                 :         10 :         Ip->type = stack_sprintf("[I*{%ld}-I*{%ld}-%ld] page 180", d1/2,d2/2,(d-2)/2);
    1584                 :         10 :         Ip->neron = concat(groupH(d1/2),groupH(d2/2));
    1585                 :            :       }
    1586                 :            :       else
    1587                 :            :       {
    1588                 :            :         GEN H;
    1589         [ +  - ]:          5 :         if (d1 != d2) return labelm3(polh,theta,alpha,dismin,I,Ip);
    1590                 :          0 :         condp = 3; H = groupH(d1/2);
    1591                 :          0 :         Ip->type = stack_sprintf("[I{%ld}-I*{%ld}-%ld] page 180", d1/2,d1/2,(d-1)/2);
    1592                 :          0 :         Ip->neron = concat(H, H);
    1593                 :            :       }
    1594                 :         20 :       break;
    1595                 :         10 :     case 4: condp = 4;
    1596                 :         10 :       Ip->type = stack_sprintf("[2I*{%ld}-%ld] page 181",d1/2,(d-2)/4);
    1597                 :         10 :       Ip->neron = groupH(d1/2); break;
    1598                 :          0 :     default: pari_err_BUG("tame7 [bug55]");
    1599                 :            :   }
    1600                 :         65 :   return condp;
    1601                 :            : }
    1602                 :            : 
    1603                 :            : static long
    1604                 :        590 : tame(GEN polh, GEN theta, long alpha, long dismin, struct igusa *I, struct igusa_p *Ip)
    1605                 :            : {
    1606                 :        590 :   GEN val = Ip->val, dk;
    1607                 :        590 :   Ip->tame = 1;
    1608   [ +  +  +  +  :        590 :   switch(Ip->tt)
             +  +  +  - ]
    1609                 :            :   {
    1610                 :         15 :     case 1: return tame_1(I, Ip);
    1611                 :         65 :     case 2: return tame_2(I, Ip, myval(I->i12,  Ip->p));
    1612                 :         40 :     case 3: return tame_3(I, Ip, 3*myval(I->i4, Ip->p));
    1613                 :         40 :     case 4: return tame_4(I, Ip, 6*myval(I->j2, Ip->p));
    1614                 :            :     case 5:
    1615                 :        235 :       dk = frac2s(Ip->eps*val[6]-5*val[Ip->eps2], 12*Ip->eps);
    1616                 :        235 :       return tame_5(I, Ip, dk);
    1617                 :            :     case 6:
    1618                 :        130 :       dk = frac2s(Ip->eps*val[7]-6*val[Ip->eps2], 12*Ip->eps);
    1619                 :        130 :       return tame_6(I, Ip, dk, polh, theta, alpha, dismin);
    1620                 :            :     case 7:
    1621                 :         65 :       dk = frac2s(Ip->eps*val[3]-2*val[Ip->eps2], 4*Ip->eps);
    1622                 :         65 :       return tame_7(I, Ip, dk, polh, theta, alpha, dismin);
    1623                 :            :   }
    1624                 :        590 :   return -1; /*not reached*/
    1625                 :            : }
    1626                 :            : 
    1627                 :            : /* maxc = maximum conductor valuation at p */
    1628                 :            : static long
    1629                 :        320 : get_maxc(GEN p)
    1630                 :            : {
    1631   [ -  +  -  + ]:        320 :   switch (itos_or_0(p))
    1632                 :            :   {
    1633                 :          0 :     case 2:  return 20; break;
    1634                 :        190 :     case 3:  return 10; break;
    1635                 :          0 :     case 5:  return 9; break;
    1636                 :        320 :     default: return 4; break; /* p > 5 */
    1637                 :            :   }
    1638                 :            : }
    1639                 :            : 
    1640                 :            : /* p = 3 */
    1641                 :            : static long
    1642                 :         55 : quartic(GEN polh, long alpha, long dismin, struct igusa_p *Ip)
    1643                 :            : {
    1644                 :         55 :   GEN theta, val = Ip->val, p = Ip->p;
    1645                 :         55 :   GEN polf = polymini_zi2(ZX_Z_mul(polh, powiu(p, alpha)));
    1646                 :         55 :   long condp = -1, d, R, r1, beta;
    1647                 :         55 :   theta = gel(polf,1);
    1648                 :         55 :   beta = itos(gel(polf,2));
    1649         [ -  + ]:         55 :   if (odd(beta)) pari_err_BUG("quartic [type over Z[i] must be [K-K-(2*m)]]");
    1650                 :         55 :   R = beta/2;
    1651                 :         55 :   r1 = itos(gmulgs(theta,6));
    1652   [ +  -  +  - ]:         55 :   switch(Ip->tt)
    1653                 :            :   {
    1654                 :         45 :     case 1: case 5: d = 0;break;
    1655                 :          0 :     case 3: d = val[6] - 5*val[3]/2;break;
    1656                 :         10 :     case 7: d = val[6] - 3*val[3] + val[Ip->eps2]/Ip->eps;break;
    1657                 :          0 :     default: pari_err_BUG("quartic [type choices]");
    1658                 :          0 :              d = 0; /*not reached*/
    1659                 :            :   }
    1660   [ +  +  +  +  :         55 :   switch(r1)
             +  +  +  +  
                      - ]
    1661                 :            :   {
    1662                 :            :     case 0:
    1663         [ +  + ]:         15 :       if (d)
    1664                 :            :       {
    1665                 :          5 :         condp = 3;
    1666                 :          5 :         Ip->type = stack_sprintf("[2I{%ld}-%ld] page 181",d,R);
    1667                 :          5 :         Ip->neron = cyclic(d);
    1668                 :            :       }
    1669                 :            :       else
    1670                 :            :       {
    1671                 :         10 :         condp = 2;
    1672                 :         10 :         Ip->neron = cyclic(1);
    1673         [ +  + ]:         10 :         if (R) Ip->type = stack_sprintf("[2I{0}-%ld] page 159",R);
    1674                 :          5 :         else   Ip->type = "[II] page 155";
    1675                 :            :       }
    1676                 :         15 :       break;
    1677                 :          5 :     case 6: condp = 4;
    1678                 :          5 :       Ip->type = stack_sprintf("[2I*{%ld}-%ld] pages 159, 181",d,R);
    1679                 :          5 :       Ip->neron = dicyclic(2,2); break;
    1680                 :          5 :     case 3: condp = 4;
    1681                 :          5 :       Ip->type = stack_sprintf("[2III-%ld] page 168",R);
    1682                 :          5 :       Ip->neron = cyclic(2); break;
    1683                 :          5 :     case 9: condp = 4;
    1684                 :          5 :       Ip->type = stack_sprintf("[2III*-%ld] page 168",R);
    1685                 :          5 :       Ip->neron = cyclic(2); break;
    1686                 :          5 :     case 2: condp = dismin-12*R-13;
    1687                 :          5 :       Ip->type = stack_sprintf("[2II-%ld] page 162",R);
    1688                 :          5 :       Ip->neron = cyclic(1); break;
    1689                 :         10 :     case 8: condp = dismin-12*R-19;
    1690                 :         10 :       Ip->type = stack_sprintf("[2IV*-%ld] page 165",R);
    1691                 :         10 :       Ip->neron = cyclic(3); break;
    1692                 :          5 :     case 4: condp = dismin-12*R-15;
    1693                 :          5 :       Ip->type = stack_sprintf("[2IV-%ld] page 165",R);
    1694                 :          5 :       Ip->neron = cyclic(3); break;
    1695                 :          5 :     case 10: condp = dismin-12*R-21;
    1696                 :          5 :       Ip->type = stack_sprintf("[2II*-%ld] page 163",R);
    1697                 :          5 :       Ip->neron = cyclic(1); break;
    1698                 :          0 :     default: pari_err_BUG("quartic [type1]");
    1699                 :            :   }
    1700 [ +  - ][ -  + ]:         55 :   if (condp > get_maxc(p) || condp < 0) pari_err_BUG("quartic [conductor]");
    1701                 :         55 :   return condp;
    1702                 :            : }
    1703                 :            : 
    1704                 :            : static long
    1705                 :        175 : litredtp(long alpha, long alpha1, GEN theta, GEN theta1, GEN polh, GEN polh1,
    1706                 :            :          long dismin, struct igusa *I, struct igusa_p *Ip)
    1707                 :            : {
    1708                 :        175 :   GEN val = Ip->val, p = Ip->p;
    1709                 :        175 :   long condp = -1, indice, d, R = Ip->R;
    1710                 :            : 
    1711 [ +  + ][ +  + ]:        175 :   if ((Ip->r1 == 0||Ip->r1 == 6) && (Ip->r2 == 0||Ip->r2 == 6))
         [ +  + ][ +  + ]
    1712                 :            :   { /* (r1,r2) = (0,0), (0,6), (6,0) or (6,6) */
    1713         [ +  + ]:        105 :     if (Ip->tt == 5)
    1714                 :            :     {
    1715   [ +  +  +  - ]:         15 :       switch(Ip->r1 + Ip->r2)
    1716                 :            :       {
    1717                 :            :       case 0: /* (0,0) */
    1718                 :          5 :         condp = 0;
    1719                 :          5 :         Ip->type = stack_sprintf("[I{0}-I{0}-%ld] page 158",R);
    1720                 :          5 :         Ip->neron = cyclic(1); break;
    1721                 :            :       case 6: /* (0,6) or (6,0) */
    1722                 :          5 :         condp = 2;
    1723                 :          5 :         Ip->type = stack_sprintf("[I*{0}-I{0}-%ld] page 159",R);
    1724                 :          5 :         Ip->neron = dicyclic(2,2); break;
    1725                 :            :       case 12: /* (6,6) */
    1726                 :          5 :         condp = 4;
    1727                 :          5 :         Ip->type = stack_sprintf("[I*{0}-I*{0}-%ld] page 158",R);
    1728                 :          5 :         Ip->neron = mkvecsmall4(2,2,2,2); break;
    1729                 :            :       }
    1730                 :         15 :       return condp;
    1731                 :            :     }
    1732         [ +  + ]:         90 :     if (Ip->r1 == Ip->r2) return tame(polh, theta, alpha, dismin, I, Ip);
    1733         [ +  + ]:         25 :     if (Ip->tt == 6)
    1734                 :            :     {
    1735                 :         15 :       d = val[6] - val[7] + (val[Ip->eps2]/Ip->eps);
    1736 [ +  - ][ +  - ]:         15 :       if (Ip->r1 && alpha1 == 0) /* H(px) / p^3 */
    1737                 :         15 :         polh1 = RgX_Rg_div(RgX_unscale(polh1,p), powiu(p,3));
    1738         [ +  + ]:         15 :       if (FpX_is_squarefree(FpX_red(polh1,p),p))
    1739                 :          5 :       { indice = 0; condp = 3-Ip->r2/6; }
    1740                 :            :       else
    1741                 :         10 :       { indice = d; condp = 3-Ip->r1/6; }
    1742                 :            :     }
    1743                 :            :     else
    1744                 :            :     { /* Ip->tt == 7 */
    1745                 :            :       long d1;
    1746                 :         10 :       d = val[6] - 3*val[3] + (val[Ip->eps2]/Ip->eps);
    1747         [ +  - ]:         10 :       if (gequal1(theta1)) /* H(px) / p^3 */
    1748                 :         10 :         polh1 = RgX_Rg_div(RgX_unscale(polh1,p), powiu(p,3));
    1749                 :         10 :       d1 = minss(val[7]-3*val[3],d/2);
    1750         [ -  + ]:         10 :       if (d == 2*d1) indice = d1;
    1751                 :            :       else
    1752                 :            :       {
    1753                 :         10 :         indice = discpart(polh1,p,d1+1);
    1754         [ -  + ]:         10 :         if (indice>= d1+1) indice = d-d1;
    1755                 :         10 :         else indice = d1;
    1756                 :            :       }
    1757                 :         10 :       condp = 3;
    1758                 :            :     }
    1759         [ +  - ]:         25 :     if (Ip->r1)
    1760                 :            :     { /* (6,0) */
    1761                 :         25 :       Ip->neron = concat(cyclic(d-indice),groupH(indice));
    1762         [ +  + ]:         25 :       if (Ip->tt == 6)
    1763                 :         15 :         Ip->type = stack_sprintf("[I*{%ld}-I{%ld}-%ld] page 170",indice,d-indice,R);
    1764                 :            :       else
    1765                 :         10 :         Ip->type = stack_sprintf("[I*{%ld}-I{%ld}-%ld] page 180",indice,d-indice,R);
    1766                 :            :     }
    1767                 :            :     else
    1768                 :            :     { /* (0,6) */
    1769                 :          0 :       Ip->neron = concat(cyclic(indice),groupH(d-indice));
    1770         [ #  # ]:          0 :       if (Ip->tt == 6)
    1771                 :          0 :         Ip->type = stack_sprintf("[I{%ld}-I*{%ld}-%ld] page 170", indice,d-indice,R);
    1772                 :            :       else
    1773                 :          0 :         Ip->type = stack_sprintf("[I{%ld}-I*{%ld}-%ld] page 180", indice,d-indice,R);
    1774                 :            :     }
    1775                 :         25 :     return condp;
    1776                 :            :   }
    1777         [ -  + ]:         70 :   if (Ip->tt == 7) pari_err_BUG("litredtp [switch ri]");
    1778                 :            :   {
    1779                 :            :     struct red S1, S;
    1780                 :         70 :     long comp = get_red(&S1, Ip, polh1, p, alpha1, Ip->r1)
    1781                 :         70 :               + get_red(&S,  Ip, polh, p, alpha, Ip->r2);
    1782                 :         70 :     Ip->type = stack_sprintf("[%s-%s-%ld] pages %s", S1.t, S.t, R, S.pages);
    1783                 :         70 :     Ip->neron = concat(S1.g, S.g);
    1784         [ +  + ]:         70 :     condp = (R >= 0)? dismin-comp+2-12*R: dismin-comp+4;
    1785                 :            :   }
    1786         [ -  + ]:         70 :   if (condp > get_maxc(p)) pari_err_BUG("litredtp [conductor]");
    1787                 :        175 :   return condp;
    1788                 :            : }
    1789                 :            : 
    1790                 :            : static long
    1791                 :        160 : labelm3(GEN polh, GEN theta, long alpha, long dismin,
    1792                 :            :         struct igusa *I, struct igusa_p *Ip)
    1793                 :            : {
    1794                 :        160 :   GEN polh1, theta1, polf, val = Ip->val, p = Ip->p;
    1795                 :            :   long alpha1, lambda, beta, R;
    1796                 :            : 
    1797                 :        160 :   polh1 = polh;
    1798                 :        160 :   theta1 = theta;
    1799                 :        160 :   alpha1 = alpha;
    1800                 :        160 :   polf = polymini(ZX_Z_mul(RgX_recip6(polh), powiu(p,alpha)), p);
    1801                 :        160 :   polh  = gel(polf,1);
    1802                 :        160 :   lambda= itos(gel(polf,2));
    1803                 :        160 :   theta = gel(polf,3);
    1804                 :        160 :   alpha = itos(gel(polf,4));
    1805                 :        160 :   beta  = itos(gel(polf,6));
    1806         [ -  + ]:        160 :   if (lambda != 3) pari_err_BUG("labelm3 [lambda = 3]");
    1807                 :        160 :   R = beta-alpha1-alpha;
    1808         [ -  + ]:        160 :   if (R&1) pari_err_BUG("labelm3 [R odd]");
    1809                 :        160 :   R >>= 1;
    1810         [ -  + ]:        160 :   if (R <= -2) pari_err_BUG("labelm3 [R <= -2]");
    1811         [ -  + ]:        160 :   if (val[Ip->eps2] % (2*Ip->eps)) pari_err_BUG("labelm3 [val(eps2)]");
    1812 [ +  + ][ -  + ]:        160 :   if (R >= 0 && (alpha+alpha1) >= 1) pari_err_BUG("labelm3 [minimal equation]");
    1813                 :        160 :   Ip->r1 = itos(gmulgs(theta1,6)) + 6*alpha1;
    1814                 :        160 :   Ip->r2 = itos(gmulgs(theta, 6)) + 6*alpha;
    1815                 :        160 :   Ip->R = R;
    1816                 :        160 :   return litredtp(alpha, alpha1, theta, theta1, polh, polh1, dismin, I, Ip);
    1817                 :            : }
    1818                 :            : 
    1819                 :            : /* p = 3 */
    1820                 :            : static long
    1821                 :         15 : quadratic(GEN polh, long alpha, long dismin,
    1822                 :            :           struct igusa *I, struct igusa_p *Ip)
    1823                 :            : {
    1824                 :            :   long alpha1, beta, R;
    1825                 :            :   GEN polf, polh1, theta, theta1;
    1826                 :         15 :   alpha1 = alpha;
    1827                 :         15 :   polf = polymini_zi(ZX_Z_mul(polh, powiu(Ip->p,alpha)));
    1828                 :         15 :   theta = gel(polf,1);
    1829                 :         15 :   alpha = itos(gel(polf,2));
    1830                 :         15 :   beta  = itos(gel(polf,3));
    1831 [ -  + ][ #  # ]:         15 :   if (alpha && beta >= 1) pari_err_BUG("quadratc");
    1832                 :         15 :   R = beta-alpha;
    1833 [ +  - ][ -  + ]:         15 :   if (R >= 0 && alpha1)
    1834                 :            :   {
    1835                 :          0 :     dismin -= 10;
    1836         [ #  # ]:          0 :     if (DEBUGLEVEL)
    1837                 :          0 :       err_printf("(Care: minimal discriminant over Z[i] smaller than over Z)\n");
    1838                 :            :   }
    1839                 :         15 :   Ip->r1 = itos(gmulgs(theta,6))+6*alpha;
    1840                 :         15 :   Ip->r2 = Ip->r1;
    1841                 :         15 :   Ip->R = R;
    1842                 :         15 :   alpha1 = alpha;
    1843                 :         15 :   theta1 = theta;
    1844                 :         15 :   polh1 = polh; /* FIXME !!! */
    1845                 :         15 :   return litredtp(alpha, alpha1, theta, theta1, polh, polh1, dismin, I, Ip);
    1846                 :            : }
    1847                 :            : 
    1848                 :            : static long
    1849                 :        950 : genus2localred(struct igusa *I, struct igusa_p *Ip, GEN p, GEN polmini)
    1850                 :            : {
    1851                 :            :   GEN val, polh, theta, list, c1, c2, c3, c4, c5, c6, prod;
    1852                 :            :   long i, vb5, vb6, d, dismin, alpha, lambda;
    1853                 :        950 :   long condp = -1, indice, vc6, mm, nb, dism;
    1854                 :            : 
    1855                 :        950 :   val = cgetg(8, t_VECSMALL);
    1856                 :        950 :   Ip->tame = 0;
    1857                 :        950 :   Ip->neron = NULL;
    1858                 :        950 :   Ip->type = NULL;
    1859                 :        950 :   Ip->p = p;
    1860                 :        950 :   Ip->val = val;
    1861                 :        950 :   val[1] = myval(I->j2,p);
    1862                 :        950 :   val[2] = myval(I->j4,p);
    1863                 :        950 :   val[3] = myval(I->i4,p);
    1864                 :        950 :   val[4] = myval(I->j6,p);
    1865                 :        950 :   val[5] = myval(I->j8,p);
    1866                 :        950 :   val[6] = myval(I->j10,p);
    1867                 :        950 :   val[7] = myval(I->i12,p);
    1868                 :        950 :   dismin = val[6];
    1869                 :        950 :   stable_reduction(I, Ip);
    1870         [ +  + ]:        950 :   if (dismin == 0)
    1871                 :            :   {
    1872                 :          5 :     Ip->tame = 1;
    1873                 :          5 :     Ip->type = "[I{0-0-0}] page 155";
    1874                 :          5 :     Ip->neron = cyclic(1); return 0;
    1875                 :            :   }
    1876         [ -  + ]:        945 :   if (dismin == 1)
    1877                 :            :   {
    1878                 :          0 :     Ip->type = "[I{1-0-0}] page 170";
    1879                 :          0 :     Ip->neron = cyclic(1); return 1;
    1880                 :            :   }
    1881         [ +  + ]:        945 :   if (dismin == 2) switch(Ip->tt)
           [ -  -  +  - ]
    1882                 :            :   {
    1883                 :            :     case 2:
    1884                 :          0 :       Ip->type = "[I{2-0-0}] page 170";
    1885                 :          0 :       Ip->neron = cyclic(2); return 1;
    1886                 :            :     case 3:
    1887                 :          0 :       Ip->type = "[I{1-1-0}] page 179";
    1888                 :          0 :       Ip->neron = cyclic(1); return 2;
    1889                 :            :     case 5:
    1890         [ -  + ]:          5 :       if (cmpis(p,3) <= 0) pari_err_BUG("genus2localred [tt 1]");
    1891                 :          5 :       Ip->type = "[I{0}-II-0] page 159";
    1892                 :          5 :       Ip->neron = cyclic(1); return 2;
    1893                 :          0 :     default: pari_err_BUG("genus2localred [tt 2]");
    1894                 :            :   }
    1895         [ +  + ]:        940 :   if (equaliu(p,2)) return -1;
    1896                 :        935 :   polh = gel(polmini,1);
    1897                 :        935 :   lambda = itos(gel(polmini,2));
    1898                 :        935 :   theta = gel(polmini,3);
    1899                 :        935 :   alpha = itos(gel(polmini,4));
    1900         [ +  + ]:        935 :   if (!gequal0(gel(polmini,5)))
    1901         [ +  - ]:         15 :     return equalis(p,3)? quadratic(polh, alpha, dismin, I, Ip):
    1902                 :            :                          tame(polh, theta, alpha, dismin, I, Ip);
    1903 [ +  + ][ +  + ]:        920 :   if (gequal0(theta) && lambda<= 2)
    1904                 :            :   {
    1905         [ -  + ]:          5 :     if (Ip->tt >= 5) pari_err_BUG("genus2localred [tt 3]");
    1906                 :          5 :     return tame(polh, theta, alpha, dismin, I, Ip);
    1907                 :            :   }
    1908         [ -  + ]:        915 :   if (dismin == 3)
    1909                 :            :   {
    1910   [ #  #  #  #  :          0 :     switch(Ip->tt)
                   #  # ]
    1911                 :            :     {
    1912                 :          0 :       case 2: return tame(polh, theta, alpha, dismin, I, Ip);
    1913                 :          0 :       case 3: Ip->type = "[I{2-1-0}] page 179"; Ip->neron = cyclic(2); return 2;
    1914                 :          0 :       case 4: Ip->type = "[I{1-1-1}] page 182"; Ip->neron = cyclic(3); return 2;
    1915                 :            :       case 5:
    1916 [ #  # ][ #  # ]:          0 :         if (equalis(p,3) && !gequal(theta,ghalf))
    1917                 :          0 :           return labelm3(polh,theta,alpha,dismin,I,Ip);
    1918                 :          0 :         Ip->type = "[I{0}-III-0] page 161"; Ip->neron = cyclic(2); return 2;
    1919                 :            :       case 6:
    1920         [ #  # ]:          0 :         if (equalis(p,3)) pari_err_BUG("genus2localred [conductor]");
    1921                 :          0 :         Ip->type = "[I{1}-II-0] page 172"; Ip->neron = cyclic(1); return 3;
    1922                 :            :     }
    1923                 :          0 :     pari_err_BUG("genus2localred [switch tt 4]");
    1924                 :          0 :     return -1; /* not reached */
    1925                 :            :   }
    1926   [ +  +  +  +  :        915 :   switch(lambda)
                      - ]
    1927                 :            :   {
    1928                 :            :     case 0:
    1929   [ +  +  +  +  :        250 :       switch(itos(gmulgs(theta, 60))+alpha)
             +  +  +  +  
                      - ]
    1930                 :            :       {
    1931                 :            :         case 10:
    1932                 :          5 :           condp = dismin-1;
    1933                 :          5 :           Ip->type = "[V] page 156";
    1934                 :          5 :           Ip->neron = cyclic(3); break;
    1935                 :            :         case 11:
    1936                 :          5 :           condp = dismin-11;
    1937                 :          5 :           Ip->type = "[V*] page 156";
    1938                 :          5 :           Ip->neron = cyclic(3); break;
    1939                 :            :         case 12:
    1940                 :          5 :           condp = dismin-2;
    1941                 :          5 :           Ip->type = "[IX-2] page 157";
    1942                 :          5 :           Ip->neron = cyclic(5); break;
    1943                 :            :         case 13:
    1944                 :          5 :           condp = dismin-12;
    1945                 :          5 :           Ip->type = "[VIII-4] page 157";
    1946                 :          5 :           Ip->neron = cyclic(1); break;
    1947                 :            :         case 24:
    1948                 :          5 :           condp = dismin-8;
    1949                 :          5 :           Ip->type = "[IX-4] page 158";
    1950                 :          5 :           Ip->neron = cyclic(5);
    1951                 :          5 :           break;
    1952                 :            :         case 15: case 16:
    1953         [ -  + ]:         10 :           if (Ip->tt>= 5) pari_err_BUG("genus2localred [tt 6]");
    1954                 :         10 :           return tame(polh, theta, alpha, dismin, I, Ip);
    1955                 :            :         case 20: case 21:
    1956                 :            :           {
    1957                 :            :             GEN b0, b1, b2, b3, b4, b5, b6, b02, b03, b04, b05;
    1958                 :         80 :             RgX_to_6(polh, &b0,&b1,&b2,&b3,&b4,&b5,&b6);
    1959                 :         80 :             vb5 = myval(b5,p);
    1960                 :         80 :             vb6 = myval(b6,p);
    1961         [ +  + ]:         80 :             if (vb6 >= 3)
    1962                 :            :             {
    1963         [ -  + ]:         10 :               if (vb5 < 2) pari_err_BUG("genus2localred [red1]");
    1964         [ +  + ]:         10 :               if (vb5 >= 3)
    1965                 :            :               {
    1966                 :          5 :                 condp = dismin-8;
    1967                 :          5 :                 Ip->type = "[II*-IV-(-1)] page 164";
    1968                 :          5 :                 Ip->neron = cyclic(3);
    1969                 :            :               }
    1970                 :            :               else
    1971                 :            :               {
    1972                 :          5 :                 condp = dismin-7;
    1973                 :          5 :                 Ip->type = "[IV-III*-(-1)] page 167";
    1974                 :          5 :                 Ip->neron = cyclic(6);
    1975                 :            :               }
    1976                 :            :               break;
    1977                 :            :             }
    1978         [ -  + ]:         70 :             if (dvdii(b0,p)) pari_err_BUG("genus2localred [b0]");
    1979                 :         70 :             b02 = gsqr(b0);
    1980                 :         70 :             b03 = gmul(b02, b0);
    1981                 :         70 :             b04 = gmul(b03, b0);
    1982                 :         70 :             b05 = gmul(b04, b0);
    1983                 :         70 :             c1 = gmul2n(b1,-1);
    1984                 :         70 :             c2 = gmul2n(gsub(gmul(b0,b2), gsqr(c1)),-1);
    1985                 :         70 :             c3 = gmul2n(gsub(gmul(b02,b3), gmul2n(gmul(c1,c2),1)),-1);
    1986                 :         70 :             c4 = gsub(gmul(b03,b4), gadd(gmul2n(gmul(c1,c3),1),gsqr(c2)));
    1987                 :         70 :             c5 = gsub(gmul(b04,b5), gmul2n(gmul(c2,c3),1));
    1988                 :         70 :             c6 = gsub(gmul(b05,b6), gsqr(c3));
    1989                 :            :             /* b0^5*H(x/b0) = (x^3+c1*x^2+c2*x+c3)^2+c4*x^2+c5*x+c6 */
    1990                 :         70 :             vc6 = myval(c6,p);
    1991         [ +  + ]:         70 :             if (vc6 == 2)
    1992                 :            :             {
    1993         [ -  + ]:          5 :               if (alpha)
    1994                 :            :               {
    1995                 :          0 :                 condp = dismin-16;
    1996                 :          0 :                 Ip->type = "[IV] page 155";
    1997                 :          0 :                 Ip->neron = cyclic(1);
    1998                 :            :               }
    1999                 :            :               else
    2000                 :            :               {
    2001                 :          5 :                 condp = dismin-6;
    2002                 :          5 :                 Ip->type = "[III] page 155";
    2003                 :          5 :                 Ip->neron = dicyclic(3,3);
    2004                 :            :               }
    2005                 :            :             }
    2006                 :            :             else
    2007                 :            :             {
    2008         [ -  + ]:         65 :               if (myval(c3,p) > 1) pari_err_BUG("genus2localred [c3]");
    2009                 :         65 :               mm = min3(3*myval(c4,p)-4, 3*myval(c5,p)-5, 3*vc6-6);
    2010         [ +  + ]:         65 :               if (alpha)
    2011                 :            :               {
    2012                 :         25 :                 condp = dismin-mm-16;
    2013                 :         25 :                 Ip->type = stack_sprintf("[III*{%ld}] page 184", mm);
    2014                 :         25 :                 Ip->neron = cyclic(1);
    2015                 :            :               }
    2016                 :            :               else
    2017                 :            :               {
    2018                 :         40 :                 condp = dismin-mm-6;
    2019                 :         40 :                 Ip->type = stack_sprintf("[III{%ld}] page 184", mm);
    2020         [ +  + ]:         40 :                 Ip->neron = (mm%3)? cyclic(9): dicyclic(3,3);
    2021                 :            :               }
    2022                 :            :             }
    2023                 :            :           }
    2024                 :         80 :           break;
    2025                 :            :         case 30:
    2026                 :        270 :           return equalis(p,3)? quartic(polh, alpha, dismin, Ip)
    2027         [ +  + ]:        135 :                              : tame(polh, theta, alpha, dismin, I, Ip);
    2028                 :          0 :         default: pari_err_BUG("genus2localred [red2]");
    2029                 :            :       }
    2030                 :        105 :       break;
    2031                 :            :     case 1:
    2032   [ +  +  +  +  :         75 :       switch(itos(gmulgs(theta, 60))+alpha)
          +  +  +  +  +  
                   +  - ]
    2033                 :            :       {
    2034                 :            :         case 12:
    2035                 :          5 :           condp = dismin;
    2036                 :          5 :           Ip->type = "[VIII-1] page 156";
    2037                 :          5 :           Ip->neron = cyclic(1); break;
    2038                 :            :         case 13:
    2039                 :          5 :           condp = dismin-10;
    2040                 :          5 :           Ip->type = "[IX-3] page 157";
    2041                 :          5 :           Ip->neron = cyclic(5); break;
    2042                 :            :         case 24:
    2043                 :          5 :           condp = dismin-4;
    2044                 :          5 :           Ip->type = "[IX-1] page 157";
    2045                 :          5 :           Ip->neron = cyclic(5); break;
    2046                 :            :         case 25:
    2047                 :          5 :           condp = dismin-14;
    2048                 :          5 :           Ip->type = "[VIII-3] page 157";
    2049                 :          5 :           Ip->neron = cyclic(1); break;
    2050                 :            :         case 36:
    2051                 :          5 :           condp = dismin-8;
    2052                 :          5 :           Ip->type = "[VIII-2] page 157";
    2053                 :          5 :           Ip->neron = cyclic(1); break;
    2054                 :            :         case 15:
    2055                 :          5 :           condp = dismin-1;
    2056                 :          5 :           Ip->type = "[VII] page 156";
    2057                 :          5 :           Ip->neron = cyclic(2); break;
    2058                 :            :         case 16:
    2059                 :          5 :           condp = dismin-11;
    2060                 :          5 :           Ip->type = "[VII*] page 156";
    2061                 :          5 :           Ip->neron = cyclic(2); break;
    2062                 :            :         case 20:
    2063         [ +  + ]:         10 :           if (cmpis(p,3))
    2064                 :            :           {
    2065                 :          5 :             d = 6*val[6]-5*val[7]-2;
    2066         [ -  + ]:          5 :             if (d%6) pari_err_BUG("genus2localred [index]");
    2067                 :          5 :             dism = (d/6);
    2068                 :            :           }
    2069                 :            :           else
    2070                 :            :           {
    2071                 :          5 :             list = padicfactors(polh,p,dismin-5);
    2072                 :          5 :             nb = lg(list);
    2073                 :          5 :             prod = pol_1(varn(polh));
    2074         [ +  + ]:         15 :             for(i = 1;i<nb;i++)
    2075                 :            :             {
    2076                 :         10 :               GEN c = gel(list,i);
    2077 [ +  - ][ +  + ]:         10 :               if (valp(gel(c,2)) && degpol(c)<= 2) prod = RgX_mul(prod,c);
    2078                 :            :             }
    2079         [ -  + ]:          5 :             if (degpol(prod) > 2) pari_err_BUG("genus2localred [padicfactors]");
    2080                 :          5 :             dism = valp(RgX_disc(prod)) - 1;
    2081                 :            :           }
    2082                 :         10 :           condp = dismin-dism-3;
    2083                 :         10 :           Ip->type = stack_sprintf("[II-II*{%ld}] page 176", dism);
    2084                 :         10 :           Ip->neron = groupH(dism+1); break;
    2085                 :            :         case 21:
    2086                 :         10 :           vb6 = myval(RgX_coeff(polh,0),p);
    2087         [ -  + ]:         10 :           if (vb6<2) pari_err_BUG("genus2localred [red3]");
    2088                 :         10 :           condp = dismin-14;
    2089                 :         10 :           Ip->type = "[IV*-II{0}] page 175";
    2090                 :         10 :           Ip->neron = cyclic(1); break;
    2091                 :            :         case 30:
    2092                 :         20 :           vb5 = myval(RgX_coeff(polh,1),p);
    2093         [ +  + ]:         20 :           if (vb5 == 2)
    2094                 :            :           {
    2095         [ -  + ]:         15 :             if (Ip->tt >= 5) pari_err_BUG("genus2localred [tt 6]");
    2096                 :         15 :             return tame(polh, theta, alpha, dismin, I, Ip);
    2097                 :            :           }
    2098                 :          5 :           condp = dismin-7;
    2099                 :          5 :           Ip->type = "[II*-III-(-1)] page 167";
    2100                 :          5 :           Ip->neron = cyclic(2); break;
    2101                 :            :       }
    2102                 :         60 :       break;
    2103                 :            :     case 2:
    2104         [ +  + ]:        105 :       if (equalis(denom(theta),4))
    2105                 :            :       {
    2106         [ -  + ]:         20 :         if (Ip->tt>4) pari_err_BUG("genus2localred [tt 5]");
    2107                 :         20 :         return tame(polh, theta, alpha, dismin, I, Ip);
    2108                 :            :       }
    2109 [ +  + ][ +  + ]:         85 :       if (!equalis(p,3) && equalis(denom(theta),3))
    2110                 :         15 :         return tame(polh, theta, alpha, dismin, I, Ip);
    2111                 :         70 :       list = padicfactors(polh,p,dismin-10*alpha);
    2112                 :         70 :       nb = lg(list); prod = pol_1(varn(polh));
    2113         [ +  + ]:        240 :       for(i = 1;i<nb;i++)
    2114                 :            :       {
    2115                 :        170 :         GEN c = gel(list,i);
    2116         [ +  + ]:        170 :         if (!valp(gel(c,2))) prod = RgX_mul(prod,c);
    2117                 :            :       }
    2118   [ -  +  +  - ]:         70 :       switch(degpol(prod))
    2119                 :            :       {
    2120                 :            :         GEN e0, e1, e2;
    2121                 :            :         case 0:
    2122                 :          0 :           dism = 0; break;
    2123                 :            :         case 1:
    2124                 :          5 :           e1 = gel(prod,3);
    2125                 :          5 :           dism = 2*valp(e1); break;
    2126                 :            :         case 2:
    2127                 :         65 :           e0 = gel(prod,2);
    2128                 :         65 :           e1 = gel(prod,3);
    2129                 :         65 :           e2 = gel(prod,4);
    2130                 :         65 :           dism = valp(gsub(gsqr(e1),gmul2n(gmul(e0,e2),2))); break;
    2131                 :            :         default:
    2132                 :          0 :           pari_err_BUG("genus2localred [padicfactors 2]");
    2133                 :          0 :           dism = 0;
    2134                 :            :       }
    2135   [ +  +  +  +  :         70 :       switch(itos(gmulgs(theta,12))+alpha-4)
                      - ]
    2136                 :            :       {
    2137                 :            :         case 0:
    2138                 :         10 :           condp = dismin-dism-1;
    2139                 :         10 :           Ip->type = stack_sprintf("[IV-II{%ld}] page 175", dism);
    2140                 :         10 :           Ip->neron = cyclic(3*dism+2); break;
    2141                 :            :         case 1:
    2142                 :          5 :           condp = dismin-dism-10;
    2143                 :          5 :           Ip->type = stack_sprintf("[II*-II*{%ld}] page 176",dism);
    2144                 :          5 :           Ip->neron = groupH(dism+1); break;
    2145                 :            :           break;
    2146                 :            :         case 2: case 3:
    2147         [ +  + ]:         50 :           if (myval(RgX_coeff(polh,0),p) == 2)
    2148                 :            :           {
    2149         [ -  + ]:         40 :             if (Ip->tt>4) pari_err_BUG("genus2localred [tt 5]");
    2150                 :         40 :             return tame(polh, theta, alpha, dismin, I, Ip);
    2151                 :            :           }
    2152                 :         10 :           dism++;
    2153                 :         10 :           indice = val[6]-(5*val[3]/2)-dism;
    2154                 :         10 :           condp = dismin-dism-indice-2;
    2155                 :         10 :           Ip->type = stack_sprintf("[II{%ld-%ld}] page 182", dism,indice);
    2156         [ -  + ]:         10 :           Ip->neron = both_odd(dism,indice)? dicyclic(2,2*dism): cyclic(4*dism);
    2157                 :         10 :           break;
    2158                 :            :         case 4:
    2159                 :          5 :           condp = dismin-dism-5;
    2160                 :          5 :           Ip->type = stack_sprintf("[IV*-II{%ld}] page 175",dism+1);
    2161                 :          5 :           Ip->neron = cyclic(3*dism+4); break;
    2162                 :            :       }
    2163                 :         30 :       break;
    2164                 :            :     case 3:
    2165 [ +  + ][ +  + ]:        485 :       if (!equalis(p,3) || Ip->tt <= 4)
    2166                 :        340 :         return tame(polh, theta, alpha, dismin, I, Ip);
    2167                 :        145 :       return labelm3(polh,theta,alpha,dismin,I,Ip); /* p = 3 */
    2168                 :          0 :     default: pari_err_BUG("genus2localred [switch lambda]");
    2169                 :            :   }
    2170 [ +  - ][ -  + ]:        195 :   if (condp < 2 || condp > get_maxc(p))
    2171                 :          0 :     pari_err_BUG("genus2localred [conductor]");
    2172                 :        950 :   return condp;
    2173                 :            : }
    2174                 :            : 
    2175                 :            : static long
    2176                 :       1880 : chk_pol(GEN P) {
    2177      [ +  +  - ]:       1880 :   switch(typ(P))
    2178                 :            :   {
    2179                 :        920 :     case t_INT: break;
    2180                 :        960 :     case t_POL: RgX_check_ZX(P,"genus2red"); return varn(P); break;
    2181                 :          0 :     default: pari_err_TYPE("genus2red", P);
    2182                 :            :   }
    2183                 :       1880 :   return -1;
    2184                 :            : }
    2185                 :            : 
    2186                 :            : /* P,Q are ZX, study Y^2 + Q(X) Y = P(X) */
    2187                 :            : GEN
    2188                 :        940 : genus2red(GEN Q, GEN P, GEN p)
    2189                 :            : {
    2190                 :        940 :   pari_sp av = avma;
    2191                 :            :   struct igusa I;
    2192                 :            :   GEN j22, j42, j2j6, a0,a1,a2,a3,a4,a5,a6, V,polr,facto,factp, vecmini, cond;
    2193                 :            :   long i, l, dd, vP,vQ;
    2194                 :            : 
    2195                 :        940 :   vP = chk_pol(P);
    2196                 :        940 :   vQ = chk_pol(Q);
    2197         [ +  + ]:        940 :   if (vP < 0)
    2198                 :            :   {
    2199         [ -  + ]:          5 :     if (vQ < 0) pari_err_TYPE("genus2red",mkvec2(P,Q));
    2200                 :          5 :     P = scalarpol(P,vQ);
    2201                 :            :   }
    2202         [ +  + ]:        935 :   else if (vQ < 0) Q = scalarpol(Q,vP);
    2203 [ +  + ][ -  + ]:        940 :   if (p && typ(p) != t_INT) pari_err_TYPE("genus2red", p);
    2204                 :            : 
    2205                 :        940 :   polr = ZX_add(ZX_sqr(Q), gmul2n(P,2)); /* ZX */
    2206         [ +  - ]:        940 :   switch(degpol(polr))
    2207                 :            :   {
    2208                 :        940 :     case 5: case 6: break;
    2209                 :          0 :     default: pari_err_DOMAIN("genus2red","genus","!=", gen_2,mkvec2(P,Q));
    2210                 :            :   }
    2211                 :            : 
    2212                 :        940 :   RgX_to_6(polr, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
    2213         [ +  + ]:        940 :   I.j10 = !signe(a0)? mulii(sqri(a1), ZX_disc(polr)): ZX_disc(polr);
    2214         [ -  + ]:        940 :   if (!signe(I.j10))
    2215                 :          0 :     pari_err_DOMAIN("genus2red","genus","<",gen_2,mkvec2(P,Q));
    2216                 :        940 :   I.j10 = gmul2n(I.j10, -12); /* t_INT */
    2217                 :            : 
    2218         [ +  + ]:        940 :   if (p == NULL)
    2219                 :            :   {
    2220                 :         10 :     facto = factor(absi(I.j10));
    2221                 :         10 :     factp = gel(facto,1);
    2222                 :            :   }
    2223                 :            :   else
    2224                 :            :   {
    2225                 :        930 :     factp = mkcol(p);
    2226                 :        930 :     facto = mkmat2(factp, mkcol(gen_1));
    2227                 :            :   }
    2228                 :        940 :   l = lg(factp);
    2229                 :        940 :   vecmini = cgetg(l, t_COL);
    2230         [ +  + ]:       1890 :   for(i = 1; i<l; i++)
    2231                 :            :   {
    2232                 :        950 :     GEN l = gel(factp,i), pm;
    2233 [ +  + ][ +  + ]:        950 :     if (i == 1 && equalis(l, 2)) { gel(vecmini,1) = gen_0; continue; }
    2234                 :        945 :     gel(vecmini,i) = pm = polymini(polr, l);
    2235                 :        945 :     polr = RgX_Rg_mul(gel(pm,1), powii(l, gel(pm,4)));
    2236                 :            :   }
    2237                 :        940 :   RgX_to_6(polr, &a0,&a1,&a2,&a3,&a4,&a5,&a6);
    2238         [ +  + ]:        940 :   I.j10 = !signe(a0)? mulii(sqri(a1), ZX_disc(polr)): ZX_disc(polr);
    2239                 :        940 :   I.j10 = gmul2n(I.j10,-12);
    2240                 :            : 
    2241                 :        940 :   I.a0 = a0;
    2242                 :        940 :   I.A2 = apol2(a0,a1,a2);
    2243                 :        940 :   I.A3 = apol3(a0,a1,a2,a3);
    2244                 :        940 :   I.A5 = apol5(a0,a1,a2,a3,a4,a5);
    2245                 :        940 :   I.B2 = bpol2(a0,a1,a2,a3,a4);
    2246                 :            : 
    2247                 :        940 :   I.j2 = igusaj2(a0,a1,a2,a3,a4,a5,a6);
    2248                 :        940 :   I.j4 = igusaj4(a0,a1,a2,a3,a4,a5,a6);
    2249                 :        940 :   I.i4 = gsub(gsqr(I.j2), gmulsg(24,I.j4));
    2250                 :        940 :   I.j6 = igusaj6(a0,a1,a2,a3,a4,a5,a6);
    2251                 :        940 :   j42 = gsqr(I.j4);
    2252                 :        940 :   j22 = gsqr(I.j2);
    2253                 :        940 :   j2j6 = gmul(I.j2,I.j6);
    2254                 :        940 :   I.j8 = gmul2n(gsub(j2j6,j42), -2);
    2255                 :        940 :   I.i12= gmul2n(gsub(gadd(gmul(j22,j42),gmulsg(36,gmul(j2j6,I.j4))),
    2256                 :            :                      gadd(gadd(gmulsg(32,gmul(j42,I.j4)),gmul(j2j6,j22)),gmulsg(108,gsqr(I.j6)))),-2);
    2257                 :            : 
    2258         [ +  + ]:       1890 :   for(i = 1; i < l; i++)
    2259                 :        950 :     gcoeff(facto,i,2) = stoi(Q_pval(I.j10, gel(factp,i)));
    2260                 :        940 :   dd = polval(polr,gen_2) & (~1); /* = 2 floor(val/2) */
    2261                 :        940 :   polr = gmul2n(polr, -dd);
    2262                 :            : 
    2263                 :        940 :   V = cgetg(l, t_VEC);
    2264         [ +  + ]:       1890 :   for (i = 1; i < l; i++)
    2265                 :            :   {
    2266                 :        950 :     GEN q = gel(factp,i), red, N = NULL;
    2267                 :            :     struct igusa_p Ip;
    2268                 :        950 :     long f = genus2localred(&I, &Ip, q, gel(vecmini,i));
    2269                 :        950 :     gcoeff(facto,i,2) = stoi(f);
    2270         [ +  + ]:        950 :     if (Ip.tame) Ip.type = stack_strcat("(tame) ", Ip.type);
    2271         [ +  + ]:        950 :     if (f >= 0)
    2272                 :        945 :       N = zv_snf(Ip.neron);
    2273         [ -  + ]:        950 :     if (DEBUGLEVEL)
    2274                 :            :     {
    2275         [ #  # ]:          0 :       if (!p) err_printf("p = %Ps\n", q);
    2276                 :          0 :       err_printf("(potential) stable reduction: %Ps\n", Ip.stable);
    2277         [ #  # ]:          0 :       if (f >= 0) {
    2278                 :          0 :         err_printf("reduction at p: %s, %Ps", Ip.type, N);
    2279                 :          0 :         err_printf(", f = %ld\n", f);
    2280                 :            :       }
    2281                 :            :     }
    2282         [ +  + ]:        950 :     red = f >= 0? mkvec2(strtoGENstr(Ip.type), N): cgetg(1, t_VEC);
    2283                 :        950 :     gel(V, i) = mkvec3(q, Ip.stable, red);
    2284                 :            :   }
    2285         [ +  + ]:        940 :   if (p) V = gel(V,1);
    2286                 :        940 :   cond = factorback(facto);
    2287                 :            :   /* remove denominator 2 coming from f = -1 in genuslocalred(, p = 2) */
    2288         [ +  + ]:        940 :   if (typ(cond) != t_INT) cond = gel(cond,1);
    2289                 :        940 :   return gerepilecopy(av, mkvec4(cond, facto, polr, V));
    2290                 :            : }

Generated by: LCOV version 1.9