Code coverage tests

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

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

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

LCOV - code coverage report
Current view: top level - modules - genus2red.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.14.0 lcov report (development 27097-5794cdef16) Lines: 1308 1424 91.9 %
Date: 2021-12-01 07:05:07 Functions: 54 54 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13