CoCalc -- paridecl.h

Testing latest pari + WASM + node.js... and it works?! Wow.
pari / 2021-07-01 / pari-2.14.0.alpha / src / headers / paridecl.h
²⁸⁴⁸⁵ views
License: GPL3
ubuntu2004
1
/* Copyright (C) 1999-2004  The PARI group.
2

3
This file is part of the PARI/GP package.
4

5
PARI/GP is free software; you can redistribute it and/or modify it under the
6
terms of the GNU General Public License as published by the Free Software
7
Foundation; either version 2 of the License, or (at your option) any later
8
version. It is distributed in the hope that it will be useful, but WITHOUT
9
ANY WARRANTY WHATSOEVER.
10

11
Check the License for details. You should have received a copy of it, along
12
with the package; see the file 'COPYING'. If not, write to the Free Software
13
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
14

15
/*******************************************************************/
16
/*                                                                 */
17
/*                DECLARATIONS of PUBLIC FUNCTIONS                 */
18
/*                                                                 */
19
/*******************************************************************/
20
#include "parinf.h"
21

22
/* black box groups */
23
struct bb_group
24
{
25
  GEN   (*mul)(void *E, GEN, GEN);
26
  GEN   (*pow)(void *E, GEN, GEN);
27
  GEN   (*rand)(void *E);
28
  ulong (*hash)(GEN);
29
  int   (*equal)(GEN,GEN);
30
  int   (*equal1)(GEN);
31
  GEN   (*easylog)(void *E, GEN, GEN, GEN);
32
};
33

34
/* black box fields */
35
struct bb_field
36
{
37
  GEN (*red)(void *E ,GEN);
38
  GEN (*add)(void *E ,GEN, GEN);
39
  GEN (*mul)(void *E ,GEN, GEN);
40
  GEN (*neg)(void *E ,GEN);
41
  GEN (*inv)(void *E ,GEN);
42
  int (*equal0)(GEN);
43
  GEN (*s)(void *E, long);
44
};
45

46
/* black box algebra */
47
struct bb_algebra
48
{
49
  GEN (*red)(void *E, GEN x);
50
  GEN (*add)(void *E, GEN x, GEN y);
51
  GEN (*sub)(void *E, GEN x, GEN y);
52
  GEN (*mul)(void *E, GEN x, GEN y);
53
  GEN (*sqr)(void *E, GEN x);
54
  GEN (*one)(void *E);
55
  GEN (*zero)(void *E);
56
};
57

58
/* black box ring */
59
struct bb_ring
60
{
61
  GEN (*add)(void *E, GEN x, GEN y);
62
  GEN (*mul)(void *E, GEN x, GEN y);
63
  GEN (*sqr)(void *E, GEN x);
64
};
65

66
/* OBSOLETE */
67
GEN     buchimag(GEN D, GEN c1, GEN c2, GEN gCO);
68
GEN     buchreal(GEN D, GEN gsens, GEN c1, GEN c2, GEN gRELSUP, long prec);
69
GEN     zidealstar(GEN nf, GEN x);
70
GEN     zidealstarinit(GEN nf, GEN x);
71
GEN     zidealstarinitgen(GEN nf, GEN x);
72
GEN     factmod(GEN f, GEN p);
73
void    mpbern(long n, long prec);
74
GEN     simplefactmod(GEN f, GEN p);
75
void    listkill(GEN list);
76
GEN     isprincipalforce(GEN bnf,GEN x);
77
GEN     isprincipalgen(GEN bnf, GEN x);
78
GEN     isprincipalgenforce(GEN bnf,GEN x);
79

80
/* F2v.c */
81

82
GEN     F2Ms_ker(GEN M, long nrows);
83
GEN     F2Ms_to_F2m(GEN M, long nrows);
84
GEN     F2c_to_ZC(GEN x);
85
GEN     F2c_to_mod(GEN x);
86
GEN     F2m_F2c_gauss(GEN a, GEN b);
87
GEN     F2m_F2c_invimage(GEN A, GEN y);
88
GEN     F2m_F2c_mul(GEN x, GEN y);
89
GEN     F2m_deplin(GEN x);
90
ulong   F2m_det(GEN x);
91
ulong   F2m_det_sp(GEN x);
92
GEN     F2m_gauss(GEN a, GEN b);
93
GEN     F2m_inv(GEN x);
94
GEN     F2m_invimage(GEN A, GEN B);
95
GEN     F2m_ker(GEN x);
96
GEN     F2m_ker_sp(GEN x, long deplin);
97
GEN     F2m_mul(GEN x, GEN y);
98
GEN     F2m_powu(GEN x, ulong n);
99
long    F2m_rank(GEN x);
100
GEN     F2m_row(GEN x, long j);
101
GEN     F2m_rowslice(GEN x, long a, long b);
102
GEN     F2m_to_F2Ms(GEN M);
103
GEN     F2m_to_Flm(GEN z);
104
GEN     F2m_to_ZM(GEN z);
105
GEN     F2m_to_mod(GEN z);
106
GEN     F2m_transpose(GEN x);
107
void    F2v_add_inplace(GEN x, GEN y);
108
void    F2v_and_inplace(GEN x, GEN y);
109
ulong   F2v_dotproduct(GEN x, GEN y);
110
int     F2v_equal0(GEN a);
111
ulong   F2v_hamming(GEN H);
112
void    F2v_negimply_inplace(GEN x, GEN y);
113
void    F2v_or_inplace(GEN x, GEN y);
114
GEN     F2v_slice(GEN x, long a, long b);
115
GEN     F2v_to_Flv(GEN x);
116
GEN     matid_F2m(long n);
117

118
/* F2x.c */
119

120
GEN     F2x_F2xq_eval(GEN Q, GEN x, GEN T);
121
GEN     F2x_F2xqV_eval(GEN P, GEN V, GEN T);
122
GEN     F2x_Frobenius(GEN T);
123
GEN     F2x_1_add(GEN y);
124
GEN     F2x_add(GEN x, GEN y);
125
GEN     F2x_deflate(GEN x0, long d);
126
GEN     F2x_degfact(GEN f);
127
long    F2x_degree(GEN x);
128
GEN     F2x_deriv(GEN x);
129
GEN     F2x_divrem(GEN x, GEN y, GEN *pr);
130
ulong   F2x_eval(GEN P, ulong x);
131
void    F2x_even_odd(GEN p, GEN *pe, GEN *po);
132
GEN     F2x_extgcd(GEN a, GEN b, GEN *ptu, GEN *ptv);
133
GEN     F2x_gcd(GEN a, GEN b);
134
GEN     F2x_get_red(GEN T);
135
GEN     F2x_halfgcd(GEN a, GEN b);
136
int     F2x_issquare(GEN a);
137
GEN     F2x_matFrobenius(GEN T);
138
GEN     F2x_mul(GEN x, GEN y);
139
GEN     F2x_recip(GEN T);
140
GEN     F2x_rem(GEN x, GEN y);
141
GEN     F2x_shift(GEN y, long d);
142
GEN     F2x_sqr(GEN x);
143
GEN     F2x_sqrt(GEN x);
144
GEN     F2x_to_F2v(GEN x, long n);
145
GEN     F2x_to_F2xX(GEN z, long sv);
146
GEN     F2x_to_Flx(GEN x);
147
GEN     F2x_to_ZX(GEN x);
148
long    F2x_valrem(GEN x, GEN *Z);
149
GEN     F2xC_to_FlxC(GEN v);
150
GEN     F2xC_to_ZXC(GEN x);
151
GEN     F2xV_to_F2m(GEN v, long n);
152
void    F2xV_to_FlxV_inplace(GEN v);
153
void    F2xV_to_ZXV_inplace(GEN v);
154
GEN     F2xX_F2x_add(GEN x, GEN y);
155
GEN     F2xX_F2x_mul(GEN P, GEN U);
156
GEN     F2xX_add(GEN x, GEN y);
157
GEN     F2xX_deriv(GEN z);
158
GEN     F2xX_renormalize(GEN /*in place*/ x, long lx);
159
GEN     F2xX_to_Kronecker(GEN P, long d);
160
GEN     F2xX_to_FlxX(GEN B);
161
GEN     F2xX_to_ZXX(GEN B);
162
GEN     F2xX_to_F2xC(GEN x, long N, long sv);
163
GEN     F2xXV_to_F2xM(GEN v, long n, long sv);
164
GEN     F2xXC_to_ZXXC(GEN B);
165
GEN     F2xY_F2xq_evalx(GEN P, GEN x, GEN T);
166
GEN     F2xY_F2xqV_evalx(GEN P, GEN x, GEN T);
167
long    F2xY_degreex(GEN b);
168
GEN     F2xn_inv(GEN f, long e);
169
GEN     F2xn_red(GEN a, long n);
170
GEN     F2xq_Artin_Schreier(GEN a, GEN T);
171
GEN     F2xq_autpow(GEN x, long n, GEN T);
172
GEN     F2xq_conjvec(GEN x, GEN T);
173
GEN     F2xq_div(GEN x,GEN y,GEN T);
174
GEN     F2xq_inv(GEN x, GEN T);
175
GEN     F2xq_invsafe(GEN x, GEN T);
176
GEN     F2xq_log(GEN a, GEN g, GEN ord, GEN T);
177
GEN     F2xq_matrix_pow(GEN y, long n, long m, GEN P);
178
GEN     F2xq_mul(GEN x, GEN y, GEN pol);
179
GEN     F2xq_order(GEN a, GEN ord, GEN T);
180
GEN     F2xq_pow(GEN x, GEN n, GEN pol);
181
GEN     F2xq_pow_init(GEN x, GEN n, long k,  GEN T);
182
GEN     F2xq_pow_table(GEN R, GEN n, GEN T);
183
GEN     F2xq_powu(GEN x, ulong n, GEN pol);
184
GEN     F2xq_powers(GEN x, long l, GEN T);
185
GEN     F2xq_sqr(GEN x,GEN pol);
186
GEN     F2xq_sqrt(GEN a, GEN T);
187
GEN     F2xq_sqrt_fast(GEN c, GEN sqx, GEN T);
188
GEN     F2xq_sqrtn(GEN a, GEN n, GEN T, GEN *zeta);
189
ulong   F2xq_trace(GEN x, GEN T);
190
GEN     F2xqX_F2xq_mul(GEN P, GEN U, GEN T);
191
GEN     F2xqX_F2xq_mul_to_monic(GEN P, GEN U, GEN T);
192
GEN     F2xqX_F2xqXQ_eval(GEN Q, GEN x, GEN S, GEN T);
193
GEN     F2xqX_F2xqXQV_eval(GEN P, GEN V, GEN S, GEN T);
194
GEN     F2xqX_disc(GEN x, GEN T);
195
GEN     F2xqX_divrem(GEN x, GEN y, GEN T, GEN *pr);
196
GEN     F2xqX_extgcd(GEN x, GEN y, GEN T,  GEN *ptu, GEN *ptv);
197
GEN     F2xqX_gcd(GEN a, GEN b, GEN T);
198
GEN     F2xqX_get_red(GEN S, GEN T);
199
GEN     F2xqX_halfgcd(GEN x, GEN y, GEN T);
200
GEN     F2xqX_invBarrett(GEN T, GEN Q);
201
long    F2xqX_ispower(GEN f, long k, GEN T, GEN *pt_r);
202
GEN     F2xqX_mul(GEN x, GEN y, GEN T);
203
GEN     F2xqX_normalize(GEN z, GEN T);
204
GEN     F2xqX_powu(GEN x, ulong n, GEN T);
205
GEN     F2xqX_red(GEN z, GEN T);
206
GEN     F2xqX_rem(GEN x, GEN S, GEN T);
207
GEN     F2xqX_resultant(GEN x, GEN y, GEN T);
208
GEN     F2xqX_sqr(GEN x, GEN T);
209
GEN     F2xqXQ_inv(GEN x, GEN S, GEN T);
210
GEN     F2xqXQ_invsafe(GEN x, GEN S, GEN T);
211
GEN     F2xqXQ_mul(GEN x, GEN y, GEN S, GEN T);
212
GEN     F2xqXQ_sqr(GEN x, GEN S, GEN T);
213
GEN     F2xqXQ_pow(GEN x, GEN n, GEN S, GEN T);
214
GEN     F2xqXQ_powers(GEN x, long l, GEN S, GEN T);
215
GEN     F2xqXQ_autpow(GEN aut, long n, GEN S, GEN T);
216
GEN     F2xqXQ_auttrace(GEN aut, long n, GEN S, GEN T);
217
GEN     F2xqXQV_red(GEN z, GEN S, GEN T);
218
GEN     Flm_to_F2m(GEN x);
219
GEN     Flv_to_F2v(GEN x);
220
GEN     Flx_to_F2x(GEN x);
221
GEN     FlxC_to_F2xC(GEN x);
222
GEN     FlxX_to_F2xX(GEN B);
223
GEN     FlxXC_to_F2xXC(GEN B);
224
GEN     Kronecker_to_F2xqX(GEN z, GEN T);
225
GEN     Rg_to_F2xq(GEN x, GEN T);
226
GEN     RgM_to_F2m(GEN x);
227
GEN     RgV_to_F2v(GEN x);
228
GEN     RgX_to_F2x(GEN x);
229
GEN     Z_to_F2x(GEN x, long v);
230
GEN     ZM_to_F2m(GEN x);
231
GEN     ZV_to_F2v(GEN x);
232
GEN     ZX_to_F2x(GEN x);
233
GEN     ZXX_to_F2xX(GEN B, long v);
234
GEN     const_F2v(long m);
235
GEN     gener_F2xq(GEN T, GEN *po);
236
const struct bb_field *get_F2xq_field(void **E, GEN T);
237
GEN     monomial_F2x(long d, long vs);
238
GEN     pol1_F2xX(long v, long sv);
239
GEN     polx_F2xX(long v, long sv);
240
GEN     random_F2xqX(long d1, long v, GEN T);
241

242
/* F2xqE.c */
243

244
GEN     F2x_Teichmuller(GEN P, long n);
245
GEN     F2xq_ellcard(GEN a2, GEN a6, GEN T);
246
GEN     F2xq_ellgens(GEN a2, GEN a6, GEN ch, GEN D, GEN m, GEN T);
247
GEN     F2xq_ellgroup(GEN a2, GEN a6, GEN N, GEN T, GEN *pt_m);
248
void    F2xq_elltwist(GEN a, GEN a6, GEN T, GEN *pt_a, GEN *pt_a6);
249
GEN     F2xqE_add(GEN P, GEN Q, GEN a2, GEN T);
250
GEN     F2xqE_changepoint(GEN x, GEN ch, GEN T);
251
GEN     F2xqE_changepointinv(GEN x, GEN ch, GEN T);
252
GEN     F2xqE_dbl(GEN P, GEN a2, GEN T);
253
GEN     F2xqE_log(GEN a, GEN b, GEN o, GEN a2, GEN T);
254
GEN     F2xqE_mul(GEN P, GEN n, GEN a2, GEN T);
255
GEN     F2xqE_neg(GEN P, GEN a2, GEN T);
256
GEN     F2xqE_order(GEN z, GEN o, GEN a2, GEN T);
257
GEN     F2xqE_sub(GEN P, GEN Q, GEN a2, GEN T);
258
GEN     F2xqE_tatepairing(GEN t, GEN s, GEN m, GEN a2, GEN T);
259
GEN     F2xqE_weilpairing(GEN t, GEN s, GEN m, GEN a2, GEN T);
260
const struct bb_group * get_F2xqE_group(void **E, GEN a2, GEN a6, GEN T);
261
GEN     RgE_to_F2xqE(GEN x, GEN T);
262
GEN     random_F2xqE(GEN a2, GEN a6, GEN T);
263

264
/* F3v.c */
265

266
GEN     F3m_ker(GEN x);
267
GEN     F3m_ker_sp(GEN x, long deplin);
268
GEN     F3m_mul(GEN x, GEN y);
269
GEN     F3m_row(GEN x, long j);
270
GEN     F3m_to_Flm(GEN z);
271
GEN     F3m_to_ZM(GEN z);
272
GEN     F3m_transpose(GEN x);
273
GEN     F3v_to_Flv(GEN x);
274
ulong   F3v_coeff(GEN x,long v);
275
void    F3v_clear(GEN x, long v);
276
void    F3v_set(GEN x, long v, ulong n);
277
GEN     Flm_to_F3m(GEN x);
278
GEN     Flv_to_F3v(GEN x);
279
GEN     RgM_to_F3m(GEN x);
280
GEN     RgV_to_F3v(GEN x);
281
GEN     ZM_to_F3m(GEN x);
282
GEN     ZV_to_F3v(GEN x);
283
GEN     zero_F3m_copy(long m, long n);
284
GEN     zero_F3v(long m);
285

286
/* Fle.c */
287

288
ulong   Fl_elldisc(ulong a4, ulong a6, ulong p);
289
ulong   Fl_elldisc_pre(ulong a4, ulong a6, ulong p, ulong pi);
290
ulong   Fl_ellj(ulong a4, ulong a6, ulong p);
291
void    Fl_ellj_to_a4a6(ulong j, ulong p, ulong *pt_a4, ulong *pt_a6);
292
GEN     Fl_ellptors(ulong l, ulong N, ulong a4, ulong a6, ulong p);
293
void    Fl_elltwist(ulong a4, ulong a6, ulong p, ulong *pt_a4, ulong *pt_a6);
294
void    Fl_elltwist_disc(ulong a4, ulong a6, ulong D, ulong p, ulong *pt_a4, ulong *pt_a6);
295
GEN     Fle_add(GEN P, GEN Q, ulong a4, ulong p);
296
GEN     Fle_dbl(GEN P, ulong a4, ulong p);
297
GEN     Fle_changepoint(GEN x, GEN ch, ulong p);
298
GEN     Fle_changepointinv(GEN x, GEN ch, ulong p);
299
GEN     Fle_log(GEN a, GEN b, GEN o, ulong a4, ulong p);
300
GEN     Fle_mul(GEN P, GEN n, ulong a4, ulong p);
301
GEN     Fle_mulu(GEN P, ulong n, ulong a4, ulong p);
302
GEN     Fle_order(GEN z, GEN o, ulong a4, ulong p);
303
GEN     Fle_sub(GEN P, GEN Q, ulong a4, ulong p);
304
ulong   Fle_tatepairing(GEN P, GEN Q, ulong m, ulong a4, ulong p);
305
GEN     Fle_to_Flj(GEN P);
306
ulong   Fle_weilpairing(GEN P, GEN Q, ulong m, ulong a4, ulong p);
307
GEN     Flj_add_pre(GEN P, GEN Q, ulong a4, ulong p, ulong pi);
308
GEN     Flj_changepointinv_pre(GEN P, GEN ch, ulong p, ulong pi);
309
GEN     Flj_dbl_pre(GEN P, ulong a4, ulong p, ulong pi);
310
GEN     Flj_mulu_pre(GEN P, ulong n, ulong a4, ulong p, ulong pi);
311
GEN     Flj_neg(GEN Q, ulong p);
312
GEN     Flj_to_Fle(GEN P, ulong p);
313
GEN     Flj_to_Fle_pre(GEN P, ulong p, ulong pi);
314
GEN     FljV_factorback_pre(GEN P, GEN L, ulong a4, ulong p, ulong pi);
315
GEN     random_Fle(ulong a4, ulong a6, ulong p);
316
GEN     random_Fle_pre(ulong a4, ulong a6, ulong p, ulong pi);
317
GEN     random_Flj_pre(ulong a4, ulong a6, ulong p, ulong pi);
318

319
/* Flv.c */
320

321
GEN     Flc_to_ZC(GEN z);
322
GEN     Flc_to_ZC_inplace(GEN z);
323
GEN     Flm_Flc_gauss(GEN a, GEN b, ulong p);
324
GEN     Flm_Flc_invimage(GEN mat, GEN y, ulong p);
325
GEN     Flm_adjoint(GEN A, ulong p);
326
GEN     Flm_deplin(GEN x, ulong p);
327
ulong   Flm_det(GEN x, ulong p);
328
ulong   Flm_det_sp(GEN x, ulong p);
329
GEN     Flm_gauss(GEN a, GEN b, ulong p);
330
GEN     Flm_intersect(GEN x, GEN y, ulong p);
331
GEN     Flm_intersect_i(GEN x, GEN y, ulong p);
332
GEN     Flm_inv(GEN x, ulong p);
333
GEN     Flm_invimage(GEN m, GEN v, ulong p);
334
GEN     Flm_ker(GEN x, ulong p);
335
GEN     Flm_ker_sp(GEN x, ulong p, long deplin);
336
long    Flm_rank(GEN x, ulong p);
337
GEN     Flm_to_ZM(GEN z);
338
GEN     Flm_to_ZM_inplace(GEN z);
339
GEN     Flv_to_ZV(GEN z);
340

341
/* Flx.c */
342

343
GEN     Fl_to_Flx(ulong x, long sv);
344
int     Fl2_equal1(GEN x);
345
GEN     Fl2_inv_pre(GEN x, ulong D, ulong p, ulong pi);
346
GEN     Fl2_mul_pre(GEN x, GEN y, ulong D, ulong p, ulong pi);
347
ulong   Fl2_norm_pre(GEN x, ulong D, ulong p, ulong pi);
348
GEN     Fl2_pow_pre(GEN x, GEN n, ulong D, ulong p, ulong pi);
349
GEN     Fl2_sqr_pre(GEN x, ulong D, ulong p, ulong pi);
350
GEN     Fl2_sqrtn_pre(GEN a, GEN n, ulong D, ulong p, ulong pi, GEN *zeta);
351
GEN     Flm_to_FlxV(GEN x, long sv);
352
GEN     Flm_to_FlxX(GEN x, long v,long w);
353
GEN     Flv_Flm_polint(GEN xa, GEN ya, ulong p, long vs);
354
GEN     Flv_inv(GEN x, ulong p);
355
void    Flv_inv_inplace(GEN x, ulong p);
356
void    Flv_inv_pre_inplace(GEN x, ulong p, ulong pi);
357
GEN     Flv_inv_pre(GEN x, ulong p, ulong pi);
358
GEN     Flv_invVandermonde(GEN L, ulong den, ulong p);
359
GEN     Flv_polint(GEN xa, GEN ya, ulong p, long vs);
360
ulong   Flv_prod(GEN v, ulong p);
361
ulong   Flv_prod_pre(GEN x, ulong p, ulong pi);
362
GEN     Flv_roots_to_pol(GEN a, ulong p, long vs);
363
GEN     Flv_to_Flx(GEN x, long vs);
364
GEN     Flx_Fl_add(GEN y, ulong x, ulong p);
365
GEN     Flx_Fl_mul(GEN y, ulong x, ulong p);
366
GEN     Flx_Fl_mul_to_monic(GEN y, ulong x, ulong p);
367
GEN     Flx_Fl_sub(GEN y, ulong x, ulong p);
368
GEN     Flx_Fl2_eval_pre(GEN x, GEN y, ulong D, ulong p, ulong pi);
369
GEN     Flx_Flv_multieval(GEN P, GEN v, ulong p);
370
GEN     Flx_Flxq_eval(GEN f,GEN x,GEN T,ulong p);
371
GEN     Flx_FlxqV_eval(GEN f,GEN x,GEN T,ulong p);
372
GEN     Flx_Frobenius(GEN T, ulong p);
373
GEN     Flx_Laplace(GEN x, ulong p);
374
GEN     Flx_Newton(GEN P, long n, ulong p);
375
GEN     Flx_add(GEN x, GEN y, ulong p);
376
GEN     Flx_blocks(GEN P, long n, long m);
377
GEN     Flx_deflate(GEN x0, long d);
378
GEN     Flx_deriv(GEN z, ulong p);
379
GEN     Flx_diff1(GEN P, ulong p);
380
GEN     Flx_digits(GEN x, GEN T, ulong p);
381
GEN     Flx_div_by_X_x(GEN a, ulong x, ulong p, ulong *rem);
382
GEN     Flx_divrem(GEN x, GEN y, ulong p, GEN *pr);
383
GEN     Flx_double(GEN y, ulong p);
384
int     Flx_equal(GEN V, GEN W);
385
ulong   Flx_eval(GEN x, ulong y, ulong p);
386
ulong   Flx_eval_powers_pre(GEN x, GEN y, ulong p, ulong pi);
387
ulong   Flx_eval_pre(GEN x, ulong y, ulong p, ulong pi);
388
GEN     Flx_extgcd(GEN a, GEN b, ulong p, GEN *ptu, GEN *ptv);
389
ulong   Flx_extresultant(GEN a, GEN b, ulong p, GEN *ptU, GEN *ptV);
390
GEN     Flx_fromNewton(GEN P, ulong p);
391
GEN     Flx_gcd(GEN a, GEN b, ulong p);
392
GEN     Flx_get_red(GEN T, ulong p);
393
GEN     Flx_halfgcd(GEN a, GEN b, ulong p);
394
GEN     Flx_halve(GEN y, ulong p);
395
GEN     Flx_inflate(GEN x0, long d);
396
GEN     Flx_integ(GEN z, ulong p);
397
GEN     Flx_invBarrett(GEN T, ulong p);
398
GEN     Flx_invLaplace(GEN x, ulong p);
399
int     Flx_is_squarefree(GEN z, ulong p);
400
int     Flx_is_smooth(GEN g, long r, ulong p);
401
GEN     Flx_matFrobenius(GEN T, ulong p);
402
GEN     Flx_mod_Xn1(GEN T, ulong n, ulong p);
403
GEN     Flx_mod_Xnm1(GEN T, ulong n, ulong p);
404
GEN     Flx_mul(GEN x, GEN y, ulong p);
405
GEN     Flx_neg(GEN x, ulong p);
406
GEN     Flx_neg_inplace(GEN x, ulong p);
407
GEN     Flx_normalize(GEN z, ulong p);
408
GEN     Flx_powu(GEN x, ulong n, ulong p);
409
GEN     Flx_recip(GEN x);
410
GEN     Flx_red(GEN z, ulong p);
411
GEN     Flx_rem(GEN x, GEN y, ulong p);
412
GEN     Flx_renormalize(GEN x, long l);
413
GEN     Flx_rescale(GEN P, ulong h, ulong p);
414
ulong   Flx_resultant(GEN a, GEN b, ulong p);
415
GEN     Flx_shift(GEN a, long n);
416
GEN     Flx_splitting(GEN p, long k);
417
GEN     Flx_sqr(GEN x, ulong p);
418
GEN     Flx_sub(GEN x, GEN y, ulong p);
419
GEN     Flx_translate1(GEN P, ulong p);
420
GEN     Flx_translate1_basecase(GEN P, ulong p);
421
GEN     Flx_to_Flv(GEN x, long N);
422
GEN     Flx_to_FlxX(GEN z, long v);
423
GEN     Flx_to_ZX(GEN z);
424
GEN     Flx_to_ZX_inplace(GEN z);
425
GEN     Flx_triple(GEN y, ulong p);
426
long    Flx_val(GEN x);
427
long    Flx_valrem(GEN x, GEN *Z);
428
GEN     FlxC_FlxqV_eval(GEN x, GEN v, GEN T, ulong p);
429
GEN     FlxC_Flxq_eval(GEN x, GEN F, GEN T, ulong p);
430
GEN     FlxC_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi);
431
GEN     FlxC_neg(GEN x, ulong p);
432
GEN     FlxC_sub(GEN x, GEN y, ulong p);
433
GEN     FlxC_to_ZXC(GEN x);
434
GEN     FlxM_Flx_add_shallow(GEN x, GEN y, ulong p);
435
GEN     FlxM_eval_powers_pre(GEN z, GEN x, ulong p, ulong pi);
436
GEN     FlxM_neg(GEN x, ulong p);
437
GEN     FlxM_sub(GEN x, GEN y, ulong p);
438
GEN     FlxM_to_ZXM(GEN z);
439
GEN     FlxT_red(GEN z, ulong p);
440
GEN     FlxV_Flc_mul(GEN V, GEN W, ulong p);
441
GEN     FlxV_Flv_multieval(GEN P, GEN v, ulong p);
442
GEN     FlxV_Flx_fromdigits(GEN x, GEN T, ulong p);
443
GEN     FlxV_prod(GEN V, ulong p);
444
GEN     FlxV_red(GEN z, ulong p);
445
GEN     FlxV_to_Flm(GEN v, long n);
446
GEN     FlxV_to_FlxX(GEN x, long v);
447
GEN     FlxV_to_ZXV(GEN x);
448
void    FlxV_to_ZXV_inplace(GEN v);
449
GEN     Flxn_exp(GEN h, long e, ulong p);
450
GEN     Flxn_expint(GEN h, long e, ulong p);
451
GEN     Flxn_inv(GEN f, long e, ulong p);
452
GEN     Flxn_mul(GEN a, GEN b, long n, ulong p);
453
GEN     Flxn_sqr(GEN a, long n, ulong p);
454
GEN     Flxn_red(GEN a, long n);
455
GEN     Flxq_autpow(GEN x, ulong n, GEN T, ulong p);
456
GEN     Flxq_autpowers(GEN x, ulong n, GEN T, ulong p);
457
GEN     Flxq_autsum(GEN x, ulong n, GEN T, ulong p);
458
GEN     Flxq_auttrace(GEN x, ulong n, GEN T, ulong p);
459
GEN     Flxq_charpoly(GEN x, GEN T, ulong p);
460
GEN     Flxq_conjvec(GEN x, GEN T, ulong p);
461
GEN     Flxq_div(GEN x, GEN y, GEN T, ulong p);
462
GEN     Flxq_inv(GEN x,GEN T,ulong p);
463
GEN     Flxq_invsafe(GEN x, GEN T, ulong p);
464
int     Flxq_issquare(GEN x, GEN T, ulong p);
465
int     Flxq_is2npower(GEN x, long n, GEN T, ulong p);
466
GEN     Flxq_log(GEN a, GEN g, GEN ord, GEN T, ulong p);
467
GEN     Flxq_lroot(GEN a, GEN T, long p);
468
GEN     Flxq_lroot_fast(GEN a, GEN sqx, GEN T, long p);
469
GEN     Flxq_matrix_pow(GEN y, long n, long m, GEN P, ulong l);
470
GEN     Flxq_minpoly(GEN x, GEN T, ulong p);
471
GEN     Flxq_mul(GEN x, GEN y, GEN T, ulong p);
472
ulong   Flxq_norm(GEN x, GEN T, ulong p);
473
GEN     Flxq_order(GEN a, GEN ord, GEN T, ulong p);
474
GEN     Flxq_pow(GEN x, GEN n, GEN T, ulong p);
475
GEN     Flxq_pow_init(GEN x, GEN n, long k,  GEN T, ulong p);
476
GEN     Flxq_pow_table(GEN R, GEN n, GEN T, ulong p);
477
GEN     Flxq_powu(GEN x, ulong n, GEN T, ulong p);
478
GEN     Flxq_powers(GEN x, long l, GEN T, ulong p);
479
GEN     Flxq_sqr(GEN y,GEN T,ulong p);
480
GEN     Flxq_sqrt(GEN a, GEN T, ulong p);
481
GEN     Flxq_sqrtn(GEN a, GEN n, GEN T, ulong p, GEN *zetan);
482
ulong   Flxq_trace(GEN x, GEN T, ulong p);
483
GEN     FlxqC_Flxq_mul(GEN x, GEN y, GEN T, ulong p);
484
GEN     FlxqM_Flxq_mul(GEN x, GEN y, GEN T, ulong p);
485
GEN     FlxqV_dotproduct(GEN x, GEN y, GEN T, ulong p);
486
ulong   Rg_to_F2(GEN x);
487
ulong   Rg_to_Fl(GEN x, ulong p);
488
GEN     Rg_to_Flxq(GEN x, GEN T, ulong p);
489
GEN     RgX_to_Flx(GEN x, ulong p);
490
GEN     RgXV_to_FlxV(GEN x, ulong p);
491
GEN     Z_to_Flx(GEN x, ulong p, long sv);
492
GEN     ZX_to_Flx(GEN x, ulong p);
493
GEN     ZXV_to_FlxV(GEN v, ulong p);
494
GEN     ZXT_to_FlxT(GEN z, ulong p);
495
GEN     gener_Flxq(GEN T, ulong p, GEN *o);
496
const struct bb_field *get_Flxq_field(void **E, GEN T, ulong p);
497
const struct bb_group *get_Flxq_star(void **E, GEN T, ulong p);
498
GEN     monomial_Flx(ulong a, long d, long vs);
499
GEN     random_Flx(long d1, long v, ulong p);
500
GEN     zero_FlxC(long n, long sv);
501
GEN     zero_FlxM(long r, long c, long sv);
502
GEN     zlx_translate1(GEN P, ulong p, long e);
503
GEN     zx_to_Flx(GEN x, ulong p);
504

505
/* FlxX.c */
506

507
GEN     FlxX_Fl_mul(GEN x, ulong y, ulong p);
508
GEN     FlxX_Flx_add(GEN y, GEN x, ulong p);
509
GEN     FlxX_Flx_mul(GEN x, GEN y, ulong p);
510
GEN     FlxX_Flx_sub(GEN y, GEN x, ulong p);
511
GEN     FlxX_Laplace(GEN x, ulong p);
512
GEN     FlxX_add(GEN P, GEN Q, ulong p);
513
GEN     FlxX_blocks(GEN P, long n, long m, long vs);
514
GEN     FlxX_deriv(GEN z, ulong p);
515
GEN     FlxX_double(GEN x, ulong p);
516
GEN     FlxX_invLaplace(GEN x, ulong p);
517
GEN     FlxX_neg(GEN x, ulong p);
518
GEN     FlxX_renormalize(GEN x, long lx);
519
GEN     FlxX_shift(GEN a, long n, long vs);
520
GEN     FlxX_sub(GEN P, GEN Q, ulong p);
521
GEN     FlxX_swap(GEN x, long n, long ws);
522
GEN     FlxX_to_Flm(GEN v, long n);
523
GEN     FlxX_to_Flx(GEN f);
524
GEN     FlxX_to_FlxC(GEN x, long N, long sv);
525
GEN     FlxX_to_ZXX(GEN B);
526
GEN     FlxX_translate1(GEN P, long p, long n);
527
GEN     FlxX_triple(GEN x, ulong p);
528
GEN     FlxXC_to_ZXXC(GEN B);
529
GEN     FlxXM_to_ZXXM(GEN B);
530
GEN     FlxXV_to_FlxM(GEN v, long n, long sv);
531
GEN     FlxXn_red(GEN a, long n);
532
GEN     FlxY_Flx_div(GEN x, GEN y, ulong p);
533
GEN     FlxY_Flx_translate(GEN P, GEN c, ulong p);
534
GEN     FlxY_Flxq_evalx(GEN P, GEN x, GEN T, ulong p);
535
GEN     FlxY_FlxqV_evalx(GEN P, GEN x, GEN T, ulong p);
536
long    FlxY_degreex(GEN b);
537
ulong   FlxY_eval_powers_pre(GEN pol, GEN ypowers, GEN xpowers, ulong p, ulong pi);
538
GEN     FlxY_evalx(GEN Q, ulong x, ulong p);
539
GEN     FlxY_evalx_powers_pre(GEN pol, GEN ypowers, ulong p, ulong pi);
540
GEN     FlxYqq_pow(GEN x, GEN n, GEN S, GEN T, ulong p);
541
GEN     FlxqV_roots_to_pol(GEN V, GEN T, ulong p, long v);
542
GEN     FlxqX_FlxqXQ_eval(GEN Q, GEN x, GEN S, GEN T, ulong p);
543
GEN     FlxqX_FlxqXQV_eval(GEN P, GEN V, GEN S, GEN T, ulong p);
544
GEN     FlxqX_Flxq_mul(GEN P, GEN U, GEN T, ulong p);
545
GEN     FlxqX_Flxq_mul_to_monic(GEN P, GEN U, GEN T, ulong p);
546
GEN     FlxqX_Newton(GEN P, long n, GEN T, ulong p);
547
GEN     FlxqX_divrem(GEN x, GEN y, GEN T, ulong p, GEN *pr);
548
GEN     FlxqX_disc(GEN x, GEN T, ulong p);
549
GEN     FlxqX_dotproduct(GEN x, GEN y, GEN T, ulong p);
550
GEN     FlxqX_extgcd(GEN a, GEN b, GEN T, ulong p, GEN *ptu, GEN *ptv);
551
GEN     FlxqX_fromNewton(GEN P, GEN T, ulong p);
552
GEN     FlxqX_gcd(GEN P, GEN Q, GEN T, ulong p);
553
GEN     FlxqX_get_red(GEN S, GEN T, ulong p);
554
GEN     FlxqX_halfgcd(GEN x, GEN y, GEN T, ulong p);
555
GEN     FlxqX_invBarrett(GEN T, GEN Q, ulong p);
556
GEN     FlxqX_mul(GEN x, GEN y, GEN T, ulong p);
557
GEN     FlxqX_normalize(GEN z, GEN T, ulong p);
558
GEN     FlxqX_powu(GEN V, ulong n, GEN T, ulong p);
559
GEN     FlxqX_red(GEN z, GEN T, ulong p);
560
GEN     FlxqX_rem(GEN x, GEN y, GEN T, ulong p);
561
GEN     FlxqX_resultant(GEN x, GEN y, GEN T, ulong p);
562
GEN     FlxqX_safegcd(GEN P, GEN Q, GEN T, ulong p);
563
GEN     FlxqX_saferesultant(GEN a, GEN b, GEN T, ulong p);
564
GEN     FlxqX_sqr(GEN x, GEN T, ulong p);
565
GEN     FlxqXQ_div(GEN x, GEN y, GEN S, GEN T, ulong p);
566
GEN     FlxqXQ_inv(GEN x, GEN S, GEN T, ulong p);
567
GEN     FlxqXQ_invsafe(GEN x, GEN S, GEN T, ulong p);
568
GEN     FlxqXQ_matrix_pow(GEN x, long n, long m, GEN S, GEN T, ulong p);
569
GEN     FlxqXQ_minpoly(GEN x, GEN S, GEN T, ulong p);
570
GEN     FlxqXQ_mul(GEN x, GEN y, GEN S, GEN T, ulong p);
571
GEN     FlxqXQ_pow(GEN x, GEN n, GEN S, GEN T, ulong p);
572
GEN     FlxqXQ_powu(GEN x, ulong n, GEN S, GEN T, ulong p);
573
GEN     FlxqXQ_powers(GEN x, long n, GEN S, GEN T, ulong p);
574
GEN     FlxqXQ_sqr(GEN x, GEN S, GEN T, ulong p);
575
GEN     FlxqXQ_autpow(GEN x, long n, GEN S, GEN T, ulong p);
576
GEN     FlxqXQ_autsum(GEN aut, long n, GEN S, GEN T, ulong p);
577
GEN     FlxqXQ_auttrace(GEN x, ulong n, GEN S, GEN T, ulong p);
578
GEN     FlxqXV_prod(GEN V, GEN T, ulong p);
579
GEN     FlxqXn_expint(GEN h, long e, GEN T, ulong p);
580
GEN     FlxqXn_inv(GEN f, long e, GEN T, ulong p);
581
GEN     FlxqXn_mul(GEN a, GEN b, long n, GEN T, ulong p);
582
GEN     FlxqXn_sqr(GEN a, long n, GEN T, ulong p);
583
GEN     Fly_to_FlxY(GEN B, long v);
584
GEN     Kronecker_to_FlxqX(GEN z, GEN T, ulong p);
585
GEN     RgX_to_FlxqX(GEN x, GEN T, ulong p);
586
const struct bb_algebra *get_FlxqXQ_algebra(void **E, GEN S, GEN T, ulong p);
587
GEN     pol1_FlxX(long v, long sv);
588
GEN     polx_FlxX(long v, long sv);
589
GEN     random_FlxqX(long d1, long v, GEN T, ulong p);
590
GEN     zlxX_translate1(GEN P, long p, long e, long n);
591
GEN     zxX_to_FlxX(GEN B, ulong p);
592
GEN     zxX_to_Kronecker(GEN P, GEN Q);
593

594
/* FlxqE.c */
595

596
GEN     Flxq_ellcard(GEN a4, GEN a6, GEN T, ulong p);
597
GEN     Flxq_ellgens(GEN a4, GEN a6, GEN ch, GEN D, GEN m, GEN T, ulong p);
598
GEN     Flxq_ellgroup(GEN a4, GEN a6, GEN N, GEN T, ulong p, GEN *pt_m);
599
void    Flxq_elltwist(GEN a, GEN a6, GEN T, ulong p, GEN *pt_a, GEN *pt_a6);
600
GEN     Flxq_ellj(GEN a4, GEN a6, GEN T, ulong p);
601
void    Flxq_ellj_to_a4a6(GEN j, GEN T, ulong p, GEN *pt_a4, GEN *pt_a6);
602
GEN     FlxqE_add(GEN P, GEN Q, GEN a4, GEN T, ulong p);
603
GEN     FlxqE_changepoint(GEN x, GEN ch, GEN T, ulong p);
604
GEN     FlxqE_changepointinv(GEN x, GEN ch, GEN T, ulong p);
605
GEN     FlxqE_dbl(GEN P, GEN a4, GEN T, ulong p);
606
GEN     FlxqE_log(GEN a, GEN b, GEN o, GEN a4, GEN T, ulong p);
607
GEN     FlxqE_mul(GEN P, GEN n, GEN a4, GEN T, ulong p);
608
GEN     FlxqE_neg(GEN P, GEN T, ulong p);
609
GEN     FlxqE_order(GEN z, GEN o, GEN a4, GEN T, ulong p);
610
GEN     FlxqE_sub(GEN P, GEN Q, GEN a4, GEN T, ulong p);
611
GEN     FlxqE_tatepairing(GEN t, GEN s, GEN m, GEN a4, GEN T, ulong p);
612
GEN     FlxqE_weilpairing(GEN t, GEN s, GEN m, GEN a4, GEN T, ulong p);
613
GEN     ZXX_to_FlxX(GEN B, ulong p, long v);
614
GEN     ZXXT_to_FlxXT(GEN z, ulong p, long v);
615
GEN     ZXXV_to_FlxXV(GEN V, ulong p, long v);
616
const struct bb_group * get_FlxqE_group(void **E, GEN a4, GEN a6, GEN T, ulong p);
617
GEN     RgE_to_FlxqE(GEN x, GEN T, ulong p);
618
GEN     random_FlxqE(GEN a4, GEN a6, GEN T, ulong p);
619

620
/* FpE.c */
621

622
long    Fl_elltrace(ulong a4, ulong a6, ulong p);
623
long    Fl_elltrace_CM(long CM, ulong a4, ulong a6, ulong p);
624
GEN     Fp_ellcard(GEN a4, GEN a6, GEN p);
625
GEN     Fp_elldivpol(GEN a4, GEN a6, long n, GEN p);
626
GEN     Fp_ellgens(GEN a4, GEN a6, GEN ch, GEN D, GEN m, GEN p);
627
GEN     Fp_ellgroup(GEN a4, GEN a6, GEN N, GEN p, GEN *pt_m);
628
GEN     Fp_ellj(GEN a4, GEN a6, GEN p);
629
int     Fp_elljissupersingular(GEN j, GEN p);
630
void    Fp_elltwist(GEN a4, GEN a6, GEN p, GEN *pt_a4, GEN *pt_a6);
631
GEN     Fp_ffellcard(GEN a4, GEN a6, GEN q, long n, GEN p);
632
GEN     FpE_add(GEN P, GEN Q, GEN a4, GEN p);
633
GEN     FpE_changepoint(GEN x, GEN ch, GEN p);
634
GEN     FpE_changepointinv(GEN x, GEN ch, GEN p);
635
GEN     FpE_dbl(GEN P, GEN a4, GEN p);
636
GEN     FpE_log(GEN a, GEN b, GEN o, GEN a4, GEN p);
637
GEN     FpE_mul(GEN P, GEN n, GEN a4, GEN p);
638
GEN     FpE_neg(GEN P, GEN p);
639
GEN     FpE_order(GEN z, GEN o, GEN a4, GEN p);
640
GEN     FpE_sub(GEN P, GEN Q, GEN a4, GEN p);
641
GEN     FpE_to_FpJ(GEN P);
642
GEN     FpE_to_mod(GEN P, GEN p);
643
GEN     FpE_tatepairing(GEN t, GEN s, GEN m, GEN a4, GEN p);
644
GEN     FpE_weilpairing(GEN t, GEN s, GEN m, GEN a4, GEN p);
645
GEN     FpJ_add(GEN P, GEN Q, GEN a4, GEN p);
646
GEN     FpJ_dbl(GEN P, GEN a4, GEN p);
647
GEN     FpJ_mul(GEN P, GEN n, GEN a4, GEN p);
648
GEN     FpJ_neg(GEN Q, GEN p);
649
GEN     FpJ_to_FpE(GEN P, GEN p);
650
GEN     FpXQ_ellcard(GEN a4, GEN a6, GEN T, GEN p);
651
GEN     FpXQ_elldivpol(GEN a4, GEN a6, long n, GEN T, GEN p);
652
GEN     FpXQ_ellgens(GEN a4, GEN a6, GEN ch, GEN D, GEN m, GEN T, GEN p);
653
GEN     FpXQ_ellgroup(GEN a4, GEN a6, GEN N, GEN T, GEN p, GEN *pt_m);
654
GEN     FpXQ_ellj(GEN a4, GEN a6, GEN T, GEN p);
655
int     FpXQ_elljissupersingular(GEN j, GEN T, GEN p);
656
void    FpXQ_elltwist(GEN a4, GEN a6, GEN T, GEN p, GEN *pt_a4, GEN *pt_a6);
657
GEN     FpXQE_add(GEN P, GEN Q, GEN a4, GEN T, GEN p);
658
GEN     FpXQE_changepoint(GEN x, GEN ch, GEN T, GEN p);
659
GEN     FpXQE_changepointinv(GEN x, GEN ch, GEN T, GEN p);
660
GEN     FpXQE_dbl(GEN P, GEN a4, GEN T, GEN p);
661
GEN     FpXQE_log(GEN a, GEN b, GEN o, GEN a4, GEN T, GEN p);
662
GEN     FpXQE_mul(GEN P, GEN n, GEN a4, GEN T, GEN p);
663
GEN     FpXQE_neg(GEN P, GEN T, GEN p);
664
GEN     FpXQE_order(GEN z, GEN o, GEN a4, GEN T, GEN p);
665
GEN     FpXQE_sub(GEN P, GEN Q, GEN a4, GEN T, GEN p);
666
GEN     FpXQE_tatepairing(GEN t, GEN s, GEN m, GEN a4, GEN T, GEN p);
667
GEN     FpXQE_weilpairing(GEN t, GEN s, GEN m, GEN a4, GEN T, GEN p);
668
GEN     Fq_elldivpolmod(GEN a4, GEN a6, long n, GEN h, GEN T, GEN p);
669
GEN     RgE_to_FpE(GEN x, GEN p);
670
GEN     RgE_to_FpXQE(GEN x, GEN T, GEN p);
671
const struct bb_group * get_FpE_group(void **E, GEN a4, GEN a6, GEN p);
672
const struct bb_group * get_FpXQE_group(void **E, GEN a4, GEN a6, GEN T, GEN p);
673
GEN     elltrace_extension(GEN t, long n, GEN p);
674
GEN     random_FpE(GEN a4, GEN a6, GEN p);
675
GEN     random_FpXQE(GEN a4, GEN a6, GEN T, GEN p);
676

677
/* FpX.c */
678

679
int     Fp_issquare(GEN x, GEN p);
680
GEN     Fp_FpX_sub(GEN x, GEN y, GEN p);
681
GEN     Fp_FpXQ_log(GEN a, GEN g, GEN ord, GEN T, GEN p);
682
GEN     FpV_FpM_polint(GEN xa, GEN ya, GEN p, long vs);
683
GEN     FpV_inv(GEN x, GEN p);
684
GEN     FpV_invVandermonde(GEN L, GEN den, GEN p);
685
GEN     FpV_polint(GEN xa, GEN ya, GEN p, long v);
686
GEN     FpV_roots_to_pol(GEN V, GEN p, long v);
687
GEN     FpX_Fp_add(GEN x, GEN y, GEN p);
688
GEN     FpX_Fp_add_shallow(GEN y,GEN x,GEN p);
689
GEN     FpX_Fp_div(GEN x, GEN y, GEN p);
690
GEN     FpX_Fp_mul(GEN x, GEN y, GEN p);
691
GEN     FpX_Fp_mul_to_monic(GEN y,GEN x,GEN p);
692
GEN     FpX_Fp_mulspec(GEN y,GEN x,GEN p,long ly);
693
GEN     FpX_Fp_sub(GEN x, GEN y, GEN p);
694
GEN     FpX_Fp_sub_shallow(GEN y,GEN x,GEN p);
695
GEN     FpX_FpV_multieval(GEN P, GEN xa, GEN p);
696
GEN     FpX_FpXQ_eval(GEN f,GEN x,GEN T,GEN p);
697
GEN     FpX_FpXQV_eval(GEN f,GEN x,GEN T,GEN p);
698
GEN     FpX_FpXV_multirem(GEN P, GEN xa, GEN p);
699
GEN     FpX_Frobenius(GEN T, GEN p);
700
GEN     FpX_Laplace(GEN x, GEN p);
701
GEN     FpX_Newton(GEN P, long n, GEN p);
702
GEN     FpX_add(GEN x, GEN y, GEN p);
703
GEN     FpX_center(GEN x, GEN p, GEN pov2);
704
GEN     FpX_center_i(GEN T, GEN p, GEN pov2);
705
GEN     FpX_chinese_coprime(GEN x,GEN y,GEN Tx,GEN Ty,GEN Tz,GEN p);
706
GEN     FpX_convol(GEN x, GEN y, GEN p);
707
GEN     FpX_deriv(GEN x, GEN p);
708
GEN     FpX_digits(GEN x, GEN y, GEN p);
709
GEN     FpX_disc(GEN x, GEN p);
710
GEN     FpX_div_by_X_x(GEN a, GEN x, GEN p, GEN *r);
711
GEN     FpX_divrem(GEN x, GEN y, GEN p, GEN *pr);
712
GEN     FpX_divu(GEN x, ulong y, GEN p);
713
GEN     FpX_dotproduct(GEN x, GEN y, GEN p);
714
GEN     FpX_eval(GEN x,GEN y,GEN p);
715
GEN     FpX_extgcd(GEN x, GEN y, GEN p, GEN *ptu, GEN *ptv);
716
GEN     FpX_fromNewton(GEN P, GEN p);
717
GEN     FpX_gcd(GEN x, GEN y, GEN p);
718
GEN     FpX_gcd_check(GEN x, GEN y, GEN p);
719
GEN     FpX_get_red(GEN T, GEN p);
720
GEN     FpX_halve(GEN y, GEN p);
721
GEN     FpX_halfgcd(GEN x, GEN y, GEN p);
722
GEN     FpX_integ(GEN x, GEN p);
723
GEN     FpX_invBarrett(GEN T, GEN p);
724
GEN     FpX_invLaplace(GEN x, GEN p);
725
int     FpX_is_squarefree(GEN f, GEN p);
726
long    FpX_ispower(GEN f, ulong k, GEN p, GEN *pt_r);
727
GEN     FpX_matFrobenius(GEN T, GEN p);
728
GEN     FpX_mul(GEN x, GEN y, GEN p);
729
GEN     FpX_mulspec(GEN a, GEN b, GEN p, long na, long nb);
730
GEN     FpX_mulu(GEN x, ulong y, GEN p);
731
GEN     FpX_neg(GEN x, GEN p);
732
GEN     FpX_normalize(GEN z, GEN p);
733
GEN     FpX_powu(GEN x, ulong n, GEN p);
734
GEN     FpX_red(GEN z, GEN p);
735
GEN     FpX_rem(GEN x, GEN y, GEN p);
736
GEN     FpX_rescale(GEN P, GEN h, GEN p);
737
GEN     FpX_resultant(GEN a, GEN b, GEN p);
738
GEN     FpX_sqr(GEN x, GEN p);
739
GEN     FpX_sub(GEN x, GEN y, GEN p);
740
long    FpX_valrem(GEN x0, GEN t, GEN p, GEN *py);
741
GEN     FpXC_FpXQ_eval(GEN Q, GEN x, GEN T, GEN p);
742
GEN     FpXC_FpXQV_eval(GEN Q, GEN x, GEN T, GEN p);
743
GEN     FpXM_FpXQV_eval(GEN Q, GEN x, GEN T, GEN p);
744
GEN     FpXQ_autpow(GEN x, ulong n, GEN T, GEN p);
745
GEN     FpXQ_autpowers(GEN aut, long f, GEN T, GEN p);
746
GEN     FpXQ_autsum(GEN x, ulong n, GEN T, GEN p);
747
GEN     FpXQ_auttrace(GEN x, ulong n, GEN T, GEN p);
748
GEN     FpXQ_charpoly(GEN x, GEN T, GEN p);
749
GEN     FpXQ_conjvec(GEN x, GEN T, GEN p);
750
GEN     FpXQ_div(GEN x,GEN y,GEN T,GEN p);
751
GEN     FpXQ_inv(GEN x,GEN T,GEN p);
752
GEN     FpXQ_invsafe(GEN x, GEN T, GEN p);
753
int     FpXQ_issquare(GEN x, GEN T, GEN p);
754
GEN     FpXQ_log(GEN a, GEN g, GEN ord, GEN T, GEN p);
755
GEN     FpXQ_matrix_pow(GEN y, long n, long m, GEN P, GEN l);
756
GEN     FpXQ_minpoly(GEN x, GEN T, GEN p);
757
GEN     FpXQ_mul(GEN y,GEN x,GEN T,GEN p);
758
GEN     FpXQ_norm(GEN x, GEN T, GEN p);
759
GEN     FpXQ_order(GEN a, GEN ord, GEN T, GEN p);
760
GEN     FpXQ_pow(GEN x, GEN n, GEN T, GEN p);
761
GEN     FpXQ_powu(GEN x, ulong n, GEN T, GEN p);
762
GEN     FpXQ_powers(GEN x, long l, GEN T, GEN p);
763
GEN     FpXQ_red(GEN x, GEN T, GEN p);
764
GEN     FpXQ_sqr(GEN y, GEN T, GEN p);
765
GEN     FpXQ_sqrt(GEN a, GEN T, GEN p);
766
GEN     FpXQ_sqrtn(GEN a, GEN n, GEN T, GEN p, GEN *zetan);
767
GEN     FpXQ_trace(GEN x, GEN T, GEN p);
768
GEN     FpXQC_to_mod(GEN z, GEN T, GEN p);
769
GEN     FpXQM_autsum(GEN x, ulong n, GEN T, GEN p);
770
GEN     FpXT_red(GEN z, GEN p);
771
GEN     FpXV_FpX_fromdigits(GEN x, GEN T, GEN p);
772
GEN     FpXV_chinese(GEN A, GEN P, GEN p, GEN *pt_mod);
773
GEN     FpXV_factorback(GEN fa, GEN e, GEN p, long v);
774
GEN     FpXV_prod(GEN V, GEN p);
775
GEN     FpXV_red(GEN z, GEN p);
776
GEN     FpXn_exp(GEN x, long n, GEN p);
777
GEN     FpXn_expint(GEN x, long n, GEN p);
778
GEN     FpXn_inv(GEN x, long n, GEN p);
779
GEN     FpXn_mul(GEN a, GEN b, long n, GEN p);
780
GEN     FpXn_sqr(GEN a, long n, GEN p);
781
int     Fq_issquare(GEN x, GEN T, GEN p);
782
long    Fq_ispower(GEN x, GEN K, GEN T, GEN p);
783
GEN     Fq_log(GEN a, GEN g, GEN ord, GEN T, GEN p);
784
GEN     FqC_to_mod(GEN z, GEN T, GEN p);
785
GEN     FqM_to_mod(GEN z, GEN T, GEN p);
786
GEN     FqV_inv(GEN x, GEN T, GEN p);
787
GEN     Z_to_FpX(GEN a, GEN p, long v);
788
GEN     gener_FpXQ(GEN T, GEN p, GEN *o);
789
GEN     gener_FpXQ_local(GEN T, GEN p, GEN L);
790
const struct bb_group * get_FpXQ_star(void **E, GEN T, GEN p);
791
const struct bb_algebra * get_FpX_algebra(void **E, GEN p, long v);
792
const struct bb_algebra * get_FpXQ_algebra(void **E, GEN T, GEN p);
793
GEN     random_FpX(long d, long v, GEN p);
794

795
/* FpX_factor.c */
796

797
GEN     F2x_ddf(GEN f);
798
GEN     F2x_factor(GEN f);
799
GEN     F2x_factor_squarefree(GEN f);
800
int     F2x_is_irred(GEN f);
801
GEN     Flx_ddf(GEN T, ulong p);
802
int     Flx_is_irred(GEN f, ulong p);
803
int     Flx_is_totally_split(GEN f, ulong p);
804
long    Flx_ispower(GEN f, ulong k, ulong p, GEN *pt_r);
805
GEN     Flx_degfact(GEN f, ulong p);
806
GEN     Flx_factor(GEN f, ulong p);
807
GEN     Flx_factor_squarefree(GEN f, ulong p);
808
long    Flx_nbfact(GEN z, ulong p);
809
long    Flx_nbfact_Frobenius(GEN T, GEN XP, ulong p);
810
GEN     Flx_nbfact_by_degree(GEN z, long *nb, ulong p);
811
long    Flx_nbroots(GEN f, ulong p);
812
ulong   Flx_oneroot(GEN f, ulong p);
813
ulong   Flx_oneroot_split(GEN f, ulong p);
814
GEN     Flx_roots(GEN f, ulong p);
815
GEN     Flx_rootsff(GEN P, GEN T, ulong p);
816
GEN     FpX_ddf(GEN f, GEN p);
817
long    FpX_ddf_degree(GEN T, GEN XP, GEN p);
818
GEN     FpX_degfact(GEN f, GEN p);
819
GEN     FpX_factor(GEN f, GEN p);
820
GEN     FpX_factor_squarefree(GEN T, GEN p);
821
int     FpX_is_irred(GEN f, GEN p);
822
int     FpX_is_totally_split(GEN f, GEN p);
823
long    FpX_nbfact(GEN f, GEN p);
824
long    FpX_nbfact_Frobenius(GEN T, GEN XP, GEN p);
825
long    FpX_nbroots(GEN f, GEN p);
826
GEN     FpX_oneroot(GEN f, GEN p);
827
GEN     FpX_oneroot_split(GEN fact, GEN p);
828
GEN     FpX_roots(GEN f, GEN p);
829
GEN     FpX_rootsff(GEN P, GEN T, GEN p);
830
GEN     FpX_split_part(GEN f, GEN p);
831

832
/* FpXQX_factor.c */
833

834
GEN     F2xqX_ddf(GEN S, GEN T);
835
GEN     F2xqX_degfact(GEN S, GEN T);
836
GEN     F2xqX_factor(GEN x, GEN T);
837
GEN     F2xqX_factor_squarefree(GEN x, GEN T);
838
GEN     F2xqX_roots(GEN x, GEN T);
839
GEN     Flx_factorff_irred(GEN P, GEN Q, ulong p);
840
void    Flx_ffintersect(GEN P,GEN Q,long n,ulong l,GEN *SP,GEN *SQ,GEN MA,GEN MB);
841
GEN     Flx_ffisom(GEN P,GEN Q,ulong l);
842
GEN     Flxq_ffisom_inv(GEN S,GEN Tp, ulong p);
843
GEN     FlxqX_Frobenius(GEN S, GEN T, ulong p);
844
GEN     FlxqX_ddf(GEN S, GEN T, ulong p);
845
long    FlxqX_ddf_degree(GEN S, GEN XP, GEN T, ulong p);
846
GEN     FlxqX_degfact(GEN S, GEN T, ulong p);
847
GEN     FlxqX_factor(GEN x, GEN T, ulong p);
848
GEN     FlxqX_factor_squarefree(GEN x, GEN T, ulong p);
849
long    FlxqX_ispower(GEN f, ulong k, GEN T, ulong p, GEN *pt_r);
850
long    FlxqX_is_squarefree(GEN P, GEN T, ulong p);
851
long    FlxqX_nbfact(GEN S, GEN T, ulong p);
852
long    FlxqX_nbfact_Frobenius(GEN S, GEN Xq, GEN T, ulong p);
853
long    FlxqX_nbroots(GEN f, GEN T, ulong p);
854
GEN     FlxqX_roots(GEN S, GEN T, ulong p);
855
GEN     FlxqXQ_halfFrobenius(GEN a, GEN S, GEN T, ulong p);
856
GEN     FpX_factorff(GEN P, GEN T, GEN p);
857
GEN     FpX_factorff_irred(GEN P, GEN Q, GEN p);
858
void    FpX_ffintersect(GEN P,GEN Q,long n,GEN l,GEN *SP,GEN *SQ,GEN MA,GEN MB);
859
GEN     FpX_ffisom(GEN P,GEN Q,GEN l);
860
GEN     FpXQ_ffisom_inv(GEN S,GEN Tp, GEN p);
861
GEN     FpXQX_Frobenius(GEN S, GEN T, GEN p);
862
GEN     FpXQX_ddf(GEN S, GEN T, GEN p);
863
long    FpXQX_ddf_degree(GEN S, GEN XP, GEN T, GEN p);
864
GEN     FpXQX_degfact(GEN S, GEN T, GEN p);
865
GEN     FpXQX_factor(GEN x, GEN T, GEN p);
866
GEN     FpXQX_factor_squarefree(GEN x, GEN T, GEN p);
867
long    FpXQX_ispower(GEN f, ulong k, GEN T, GEN p, GEN *pt);
868
long    FpXQX_nbfact(GEN u, GEN T, GEN p);
869
long    FpXQX_nbfact_Frobenius(GEN S, GEN Xq, GEN T, GEN p);
870
long    FpXQX_nbroots(GEN f, GEN T, GEN p);
871
GEN     FpXQX_roots(GEN f, GEN T, GEN p);
872
GEN     FpXQX_split_part(GEN f, GEN T, GEN p);
873
GEN     FpXQXQ_halfFrobenius(GEN a, GEN S, GEN T, GEN p);
874
long    FqX_is_squarefree(GEN P, GEN T, GEN p);
875
long    FqX_ispower(GEN f, ulong k, GEN T, GEN p, GEN *pt);
876
long    FqX_nbfact(GEN u, GEN T, GEN p);
877
long    FqX_nbroots(GEN f, GEN T, GEN p);
878
GEN     factorff(GEN f, GEN p, GEN a);
879
GEN     factormod0(GEN f, GEN p,long flag);
880
GEN     factormodDDF(GEN f, GEN D);
881
GEN     factormodSQF(GEN f, GEN D);
882
int     ff_parse_Tp(GEN Tp, GEN *T, GEN *p, long red);
883
GEN     polrootsff(GEN f, GEN p, GEN T);
884
GEN     polrootsmod(GEN f, GEN p);
885
GEN     rootmod0(GEN f, GEN p,long flag);
886

887
/* FpXX.c */
888

889
GEN     FpXQX_FpXQ_mul(GEN P, GEN U, GEN T, GEN p);
890
GEN     FpXQX_FpXQXQV_eval(GEN P, GEN V, GEN S, GEN T, GEN p);
891
GEN     FpXQX_FpXQXQ_eval(GEN P, GEN x, GEN S, GEN T, GEN p);
892
GEN     FpXQX_digits(GEN x, GEN B, GEN T, GEN p);
893
GEN     FpXQX_disc(GEN x, GEN T, GEN p);
894
GEN     FpXQX_div_by_X_x(GEN a, GEN x, GEN T, GEN p, GEN *pr);
895
GEN     FpXQX_divrem(GEN x, GEN y, GEN T, GEN p, GEN *pr);
896
GEN     FpXQX_dotproduct(GEN x, GEN y, GEN T, GEN p);
897
GEN     FpXQX_extgcd(GEN x, GEN y, GEN T, GEN p, GEN *ptu, GEN *ptv);
898
GEN     FpXQX_gcd(GEN P, GEN Q, GEN T, GEN p);
899
GEN     FpXQX_get_red(GEN S, GEN T, GEN p);
900
GEN     FpXQX_halfgcd(GEN x, GEN y, GEN T, GEN p);
901
GEN     FpXQX_invBarrett(GEN S, GEN T, GEN p);
902
GEN     FpXQX_mul(GEN x, GEN y, GEN T, GEN p);
903
GEN     FpXQX_powu(GEN x, ulong n, GEN T, GEN p);
904
GEN     FpXQX_red(GEN z, GEN T, GEN p);
905
GEN     FpXQX_rem(GEN x, GEN S, GEN T, GEN p);
906
GEN     FpXQX_resultant(GEN a, GEN b, GEN T, GEN p);
907
GEN     FpXQX_sqr(GEN x, GEN T, GEN p);
908
GEN     FpXQX_to_mod(GEN z, GEN T, GEN p);
909
GEN     FpXQXQ_div(GEN x,GEN y,GEN S, GEN T,GEN p);
910
GEN     FpXQXQ_inv(GEN x, GEN S, GEN T,GEN p);
911
GEN     FpXQXQ_invsafe(GEN x, GEN S, GEN T, GEN p);
912
GEN     FpXQXQ_matrix_pow(GEN y, long n, long m, GEN S, GEN T, GEN p);
913
GEN     FpXQXQ_minpoly(GEN x, GEN S, GEN T, GEN p);
914
GEN     FpXQXQ_mul(GEN x, GEN y, GEN S, GEN T, GEN p);
915
GEN     FpXQXQ_pow(GEN x, GEN n, GEN S, GEN T, GEN p);
916
GEN     FpXQXQ_powers(GEN x, long n, GEN S, GEN T, GEN p);
917
GEN     FpXQXQ_sqr(GEN x, GEN S, GEN T, GEN p);
918
GEN     FpXQXQ_autpow(GEN aut, long n, GEN S, GEN T, GEN p);
919
GEN     FpXQXQ_autsum(GEN aut, long n, GEN S, GEN T, GEN p);
920
GEN     FpXQXQ_auttrace(GEN aut, long n, GEN S, GEN T, GEN p);
921
GEN     FpXQXV_FpXQX_fromdigits(GEN x, GEN B, GEN T, GEN p);
922
GEN     FpXQXV_prod(GEN V, GEN Tp, GEN p);
923
GEN     FpXQXn_exp(GEN x, long n, GEN T, GEN p);
924
GEN     FpXQXn_expint(GEN x, long n, GEN T, GEN p);
925
GEN     FpXQXn_inv(GEN x, long n, GEN T, GEN p);
926
GEN     FpXQXn_mul(GEN x, GEN y, long n, GEN T, GEN p);
927
GEN     FpXQXn_sqr(GEN x, long n, GEN T, GEN p);
928
GEN     FpXX_Fp_mul(GEN x, GEN y, GEN p);
929
GEN     FpXX_FpX_mul(GEN x, GEN y, GEN p);
930
GEN     FpXX_add(GEN x, GEN y, GEN p);
931
GEN     FpXX_deriv(GEN P, GEN p);
932
GEN     FpXX_halve(GEN P, GEN p);
933
GEN     FpXX_integ(GEN P, GEN p);
934
GEN     FpXX_mulu(GEN P, ulong u, GEN p);
935
GEN     FpXX_neg(GEN x, GEN p);
936
GEN     FpXX_red(GEN z, GEN p);
937
GEN     FpXX_sub(GEN x, GEN y, GEN p);
938
GEN     FpXY_FpXQ_evalx(GEN P, GEN x, GEN T, GEN p);
939
GEN     FpXY_FpXQV_evalx(GEN P, GEN x, GEN T, GEN p);
940
GEN     FpXY_eval(GEN Q, GEN y, GEN x, GEN p);
941
GEN     FpXY_evalx(GEN Q, GEN x, GEN p);
942
GEN     FpXY_evaly(GEN Q, GEN y, GEN p, long vy);
943
GEN     FpXYQQ_pow(GEN x, GEN n, GEN S, GEN T, GEN p);
944
GEN     FqXC_to_mod(GEN z, GEN T, GEN p);
945
GEN     FqXM_to_mod(GEN z, GEN T, GEN p);
946
GEN     Kronecker_to_FpXQX(GEN z, GEN pol, GEN p);
947
const struct bb_algebra * get_FpXQX_algebra(void **E, GEN T, GEN p, long v);
948
const struct bb_algebra * get_FpXQXQ_algebra(void **E, GEN S, GEN T, GEN p);
949
GEN     random_FpXQX(long d1, long v, GEN T, GEN p);
950

951
/* FpV.c */
952

953
GEN     Flc_Flv_mul(GEN x, GEN y, ulong p);
954
GEN     Flc_to_mod(GEN z, ulong p);
955
GEN     Flm_Fl_add(GEN x, ulong y, ulong p);
956
GEN     Flm_Fl_mul(GEN y, ulong x, ulong p);
957
void    Flm_Fl_mul_inplace(GEN y, ulong x, ulong p);
958
GEN     Flm_Fl_mul_pre(GEN y, ulong x, ulong p, ulong pi);
959
GEN     Flm_Fl_sub(GEN x, ulong y, ulong p);
960
GEN     Flm_Flc_mul(GEN x, GEN y, ulong p);
961
GEN     Flm_Flc_mul_pre(GEN x, GEN y, ulong p, ulong pi);
962
GEN     Flm_Flc_mul_pre_Flx(GEN x, GEN y, ulong p, ulong pi, long sv);
963
GEN     Flm_add(GEN x, GEN y, ulong p);
964
GEN     Flm_center(GEN z, ulong p, ulong ps2);
965
GEN     Flm_mul(GEN x, GEN y, ulong p);
966
GEN     Flm_mul_pre(GEN x, GEN y, ulong p, ulong pi);
967
GEN     Flm_neg(GEN y, ulong p);
968
GEN     Flm_powers(GEN x, ulong n, ulong p);
969
GEN     Flm_powu(GEN x, ulong n, ulong p);
970
GEN     Flm_sub(GEN x, GEN y, ulong p);
971
GEN     Flm_to_mod(GEN z, ulong p);
972
GEN     Flm_transpose(GEN x);
973
GEN     Flv_Fl_div(GEN x, ulong y, ulong p);
974
void    Flv_Fl_div_inplace(GEN x, ulong y, ulong p);
975
GEN     Flv_Fl_mul(GEN x, ulong y, ulong p);
976
void    Flv_Fl_mul_inplace(GEN x, ulong y, ulong p);
977
void    Flv_Fl_mul_part_inplace(GEN x, ulong y, ulong p, long l);
978
GEN     Flv_add(GEN x, GEN y, ulong p);
979
void    Flv_add_inplace(GEN x, GEN y, ulong p);
980
GEN     Flv_center(GEN z, ulong p, ulong ps2);
981
ulong   Flv_dotproduct(GEN x, GEN y, ulong p);
982
ulong   Flv_dotproduct_pre(GEN x, GEN y, ulong p, ulong pi);
983
GEN     Flv_neg(GEN v, ulong p);
984
void    Flv_neg_inplace(GEN v, ulong p);
985
GEN     Flv_sub(GEN x, GEN y, ulong p);
986
void    Flv_sub_inplace(GEN x, GEN y, ulong p);
987
ulong   Flv_sum(GEN x, ulong p);
988
ulong   Flx_dotproduct(GEN x, GEN y, ulong p);
989
GEN     Fp_to_mod(GEN z, GEN p);
990
GEN     FpC_FpV_mul(GEN x, GEN y, GEN p);
991
GEN     FpC_Fp_mul(GEN x, GEN y, GEN p);
992
GEN     FpC_center(GEN z, GEN p, GEN pov2);
993
void    FpC_center_inplace(GEN z, GEN p, GEN pov2);
994
GEN     FpC_red(GEN z, GEN p);
995
GEN     FpC_to_mod(GEN z, GEN p);
996
GEN     FpM_add(GEN x, GEN y, GEN p);
997
GEN     FpM_Fp_mul(GEN X, GEN c, GEN p);
998
GEN     FpM_FpC_mul(GEN x, GEN y, GEN p);
999
GEN     FpM_FpC_mul_FpX(GEN x, GEN y, GEN p, long v);
1000
GEN     FpM_center(GEN z, GEN p, GEN pov2);
1001
void    FpM_center_inplace(GEN z, GEN p, GEN pov2);
1002
GEN     FpM_mul(GEN x, GEN y, GEN p);
1003
GEN     FpM_powu(GEN x, ulong n, GEN p);
1004
GEN     FpM_red(GEN z, GEN p);
1005
GEN     FpM_sub(GEN x, GEN y, GEN p);
1006
GEN     FpM_to_mod(GEN z, GEN p);
1007
GEN     FpMs_FpC_mul(GEN M, GEN B, GEN p);
1008
GEN     FpMs_FpCs_solve(GEN M, GEN B, long nbrow, GEN p);
1009
GEN     FpMs_FpCs_solve_safe(GEN M, GEN A, long nbrow, GEN p);
1010
GEN     FpMs_leftkernel_elt(GEN M, long nbrow, GEN p);
1011
GEN     FpC_add(GEN x, GEN y, GEN p);
1012
GEN     FpC_sub(GEN x, GEN y, GEN p);
1013
GEN     FpV_FpMs_mul(GEN B, GEN M, GEN p);
1014
GEN     FpV_add(GEN x, GEN y, GEN p);
1015
GEN     FpV_sub(GEN x, GEN y, GEN p);
1016
GEN     FpV_dotproduct(GEN x, GEN y, GEN p);
1017
GEN     FpV_dotsquare(GEN x, GEN p);
1018
GEN     FpV_red(GEN z, GEN p);
1019
GEN     FpV_to_mod(GEN z, GEN p);
1020
GEN     FpVV_to_mod(GEN z, GEN p);
1021
GEN     FpX_to_mod(GEN z, GEN p);
1022
GEN     FpXC_to_mod(GEN x, GEN p);
1023
GEN     FpXM_to_mod(GEN x, GEN p);
1024
GEN     ZabM_ker(GEN M, GEN P, long n);
1025
GEN     ZabM_indexrank(GEN M, GEN P, long n);
1026
GEN     ZabM_inv(GEN M, GEN P, long n, GEN *pden);
1027
GEN     ZabM_inv_ratlift(GEN M, GEN P, long n, GEN *pden);
1028
GEN     ZabM_pseudoinv(GEN M, GEN P, long n, GEN *pv, GEN *den);
1029
GEN     ZV_zMs_mul(GEN B, GEN M);
1030
GEN     ZpMs_ZpCs_solve(GEN M, GEN B, long nbrow, GEN p, long e);
1031
GEN     gen_FpM_Wiedemann(void *E, GEN (*f)(void*, GEN), GEN B, GEN p);
1032
GEN     gen_ZpM_Dixon_Wiedemann(void *E, GEN (*f)(void*, GEN), GEN B, GEN p, long e);
1033
GEN     gen_matid(long n, void *E, const struct bb_field *S);
1034
GEN     matid_Flm(long n);
1035
GEN     matid_F2xqM(long n, GEN T);
1036
GEN     matid_FlxqM(long n, GEN T, ulong p);
1037
GEN     random_Flv(long n, ulong p);
1038
GEN     random_FpC(long d, GEN p);
1039
GEN     random_FpV(long d, GEN p);
1040
GEN     scalar_Flm(long s, long n);
1041
GEN     zCs_to_ZC(GEN C, long nbrow);
1042
GEN     zMs_to_ZM(GEN M, long nbrow);
1043
GEN     zMs_ZC_mul(GEN M, GEN B);
1044
GEN     ZMV_to_FlmV(GEN z, ulong m);
1045

1046
/* Hensel.c */
1047

1048
GEN     Flx_Teichmuller(GEN P, ulong p, long n);
1049
GEN     Z2_sqrt(GEN x, long e);
1050
GEN     Zp_sqrt(GEN x, GEN p, long e);
1051
GEN     Zp_sqrtlift(GEN b, GEN a, GEN p, long e);
1052
GEN     Zp_sqrtnlift(GEN b, GEN n, GEN a, GEN p, long e);
1053
GEN     ZpM_invlift(GEN M, GEN C, GEN p, long n);
1054
GEN     ZpX_Frobenius(GEN T, GEN p, long e);
1055
GEN     ZpX_ZpXQ_liftroot(GEN P, GEN S, GEN T, GEN p, long e);
1056
GEN     ZpX_ZpXQ_liftroot_ea(GEN P, GEN S, GEN T, GEN p, long n, void *E,
1057
                     GEN early(void *E, GEN x, GEN q));
1058
GEN     ZpX_liftfact(GEN pol, GEN Q, GEN pe, GEN p, long e);
1059
GEN     ZpX_liftroot(GEN f, GEN a, GEN p, long e);
1060
GEN     ZpX_liftroots(GEN f, GEN S, GEN p, long e);
1061
GEN     ZpX_roots(GEN f, GEN p, long e);
1062
GEN     ZpXQ_div(GEN a, GEN b, GEN T, GEN q, GEN p, long e);
1063
GEN     ZpXQ_inv(GEN a, GEN T, GEN p, long e);
1064
GEN     ZpXQ_invlift(GEN b, GEN a, GEN T, GEN p, long e);
1065
GEN     ZpXQ_log(GEN a, GEN T, GEN p, long N);
1066
GEN     ZpXQ_sqrt(GEN a, GEN T, GEN p, long e);
1067
GEN     ZpXQ_sqrtnlift(GEN b, GEN n, GEN a, GEN T, GEN p, long e);
1068
GEN     ZpXQM_prodFrobenius(GEN M, GEN T, GEN p, long e);
1069
GEN     ZpXQX_digits(GEN x, GEN B, GEN T, GEN q, GEN p, long e);
1070
GEN     ZpXQX_divrem(GEN x, GEN S, GEN T, GEN q, GEN p, long e, GEN *pr);
1071
GEN     ZpXQX_liftfact(GEN pol, GEN Q, GEN T, GEN pe, GEN p, long e);
1072
GEN     ZpXQX_liftroot(GEN f, GEN a, GEN T, GEN p, long e);
1073
GEN     ZpXQX_liftroot_vald(GEN f, GEN a, long v, GEN T, GEN p, long e);
1074
GEN     ZpXQX_liftroots(GEN f, GEN S, GEN T, GEN p, long e);
1075
GEN     ZpXQX_roots(GEN F, GEN T, GEN p, long e);
1076
GEN     Zq_sqrtnlift(GEN a, GEN n, GEN x, GEN T, GEN p, long e);
1077
GEN     ZqX_liftfact(GEN pol, GEN Q, GEN T, GEN pe, GEN p, long e);
1078
GEN     ZqX_liftroot(GEN f, GEN a, GEN T, GEN p, long e);
1079
GEN     ZqX_roots(GEN F, GEN T, GEN p, long e);
1080
GEN     gen_ZpM_Dixon(GEN F, GEN V, GEN q, GEN p, long N, void *E,
1081
                             GEN lin(void *E, GEN F, GEN d, GEN q),
1082
                             GEN invl(void *E, GEN d));
1083
GEN     gen_ZpM_Newton(GEN x, GEN p, long n, void *E,
1084
                              GEN eval(void *E, GEN f, GEN q),
1085
                              GEN invd(void *E, GEN V, GEN v, GEN q, long M));
1086
GEN     gen_ZpX_Dixon(GEN F, GEN V, GEN q, GEN p, long N, void *E,
1087
                             GEN lin(void *E, GEN F, GEN d, GEN q),
1088
                             GEN invl(void *E, GEN d));
1089
GEN     gen_ZpX_Newton(GEN x, GEN p, long n, void *E,
1090
                              GEN eval(void *E, GEN f, GEN q),
1091
                              GEN invd(void *E, GEN V, GEN v, GEN q, long M));
1092
GEN     polteichmuller(GEN P, ulong p, long n);
1093
GEN     polhensellift(GEN pol, GEN fct, GEN p, long exp);
1094
ulong   quadratic_prec_mask(long n);
1095

1096
/* QX_factor.c */
1097

1098
GEN     QX_factor(GEN x);
1099
GEN     ZX_factor(GEN x);
1100
long    ZX_is_irred(GEN x);
1101
GEN     ZX_squff(GEN f, GEN *ex);
1102
GEN     polcyclofactors(GEN f);
1103
long    poliscyclo(GEN f);
1104
long    poliscycloprod(GEN f);
1105

1106

1107
/* RgV.c */
1108

1109
GEN     Rg_RgC_sub(GEN a, GEN x);
1110
GEN     RgC_Rg_add(GEN x, GEN y);
1111
GEN     RgC_Rg_div(GEN x, GEN y);
1112
GEN     RgC_Rg_mul(GEN x, GEN y);
1113
GEN     RgC_Rg_sub(GEN x, GEN y);
1114
GEN     RgC_RgM_mul(GEN x, GEN y);
1115
GEN     RgC_RgV_mul(GEN x, GEN y);
1116
GEN     RgC_add(GEN x, GEN y);
1117
long    RgC_is_ei(GEN x);
1118
GEN     RgC_neg(GEN x);
1119
GEN     RgC_sub(GEN x, GEN y);
1120
GEN     RgM_Rg_add(GEN x, GEN y);
1121
GEN     RgM_Rg_add_shallow(GEN x, GEN y);
1122
GEN     RgM_Rg_div(GEN x, GEN y);
1123
GEN     RgM_Rg_mul(GEN x, GEN y);
1124
GEN     RgM_Rg_sub(GEN x, GEN y);
1125
GEN     RgM_Rg_sub_shallow(GEN x, GEN y);
1126
GEN     RgM_RgC_mul(GEN x, GEN y);
1127
GEN     RgM_RgV_mul(GEN x, GEN y);
1128
GEN     RgM_ZM_mul(GEN x, GEN y);
1129
GEN     RgM_add(GEN x, GEN y);
1130
GEN     RgM_det_triangular(GEN x);
1131
int     RgM_is_QM(GEN x);
1132
int     RgM_is_ZM(GEN x);
1133
int     RgM_isdiagonal(GEN x);
1134
int     RgM_isidentity(GEN x);
1135
int     RgM_isscalar(GEN x, GEN s);
1136
GEN     RgM_mul(GEN x, GEN y);
1137
GEN     RgM_mul_i(GEN x, GEN y);
1138
GEN     RgM_multosym(GEN x, GEN y);
1139
GEN     RgM_neg(GEN x);
1140
GEN     RgM_powers(GEN x, long l);
1141
GEN     RgM_sqr(GEN x);
1142
GEN     RgM_sub(GEN x, GEN y);
1143
GEN     RgM_sumcol(GEN A);
1144
GEN     RgM_transmul(GEN x, GEN y);
1145
GEN     RgM_transmultosym(GEN x, GEN y);
1146
GEN     RgMrow_zc_mul(GEN x, GEN y, long i);
1147
GEN     RgM_zc_mul(GEN x, GEN y);
1148
GEN     RgM_zm_mul(GEN x, GEN y);
1149
GEN     RgMrow_RgC_mul(GEN x, GEN y, long i);
1150
GEN     RgV_RgM_mul(GEN x, GEN y);
1151
GEN     RgV_RgC_mul(GEN x, GEN y);
1152
GEN     RgV_Rg_mul(GEN x, GEN y);
1153
GEN     RgV_add(GEN x, GEN y);
1154
GEN     RgV_dotproduct(GEN x, GEN y);
1155
GEN     RgV_dotsquare(GEN x);
1156
int     RgV_is_ZMV(GEN V);
1157
GEN     RgV_kill0(GEN v);
1158
GEN     RgV_neg(GEN x);
1159
GEN     RgV_prod(GEN v);
1160
GEN     RgV_sub(GEN x, GEN y);
1161
GEN     RgV_sum(GEN v);
1162
GEN     RgV_sumpart(GEN v, long n);
1163
GEN     RgV_sumpart2(GEN v, long m, long n);
1164
GEN     RgV_zc_mul(GEN x, GEN y);
1165
GEN     RgV_zm_mul(GEN x, GEN y);
1166
GEN     RgX_RgM_eval(GEN x, GEN y);
1167
GEN     RgX_RgMV_eval(GEN x, GEN y);
1168
int     isdiagonal(GEN x);
1169
GEN     matid(long n);
1170
GEN     scalarcol(GEN x, long n);
1171
GEN     scalarcol_shallow(GEN x, long n);
1172
GEN     scalarmat(GEN x, long n);
1173
GEN     scalarmat_shallow(GEN x, long n);
1174
GEN     scalarmat_s(long x, long n);
1175

1176
/* RgX.c */
1177

1178
GEN     Kronecker_to_mod(GEN z, GEN pol);
1179
GEN     QX_ZXQV_eval(GEN P, GEN V, GEN dV);
1180
GEN     QXQ_charpoly(GEN A, GEN T, long v);
1181
GEN     QXQ_powers(GEN a, long n, GEN T);
1182
GEN     QXQ_to_mod_shallow(GEN x, GEN T);
1183
GEN     QXQC_to_mod_shallow(GEN V, GEN T);
1184
GEN     QXQM_to_mod_shallow(GEN V, GEN T);
1185
GEN     QXQV_to_mod(GEN V, GEN T);
1186
GEN     QXQX_to_mod_shallow(GEN z, GEN T);
1187
GEN     QXQXV_to_mod(GEN V, GEN T);
1188
GEN     QXV_QXQ_eval(GEN v, GEN a, GEN T);
1189
GEN     QXY_QXQ_evalx(GEN v, GEN a, GEN T);
1190
GEN     Rg_RgX_sub(GEN x, GEN y);
1191
GEN     Rg_get_0(GEN x);
1192
GEN     Rg_get_1(GEN x);
1193
GEN     Rg_to_RgC(GEN x, long N);
1194
GEN     RgM_to_RgXV(GEN x, long v);
1195
GEN     RgM_to_RgXV_reverse(GEN x, long v);
1196
GEN     RgM_to_RgXX(GEN x, long v,long w);
1197
GEN     RgV_to_RgX(GEN x, long v);
1198
GEN     RgV_to_RgM(GEN v, long n);
1199
GEN     RgV_to_RgX_reverse(GEN x, long v);
1200
GEN     RgX_RgXQ_eval(GEN f, GEN x, GEN T);
1201
GEN     RgX_RgXQV_eval(GEN P, GEN V, GEN T);
1202
GEN     RgX_RgXn_eval(GEN Q, GEN x, long n);
1203
GEN     RgX_RgXnV_eval(GEN Q, GEN x, long n);
1204
GEN     RgX_Rg_add(GEN y, GEN x);
1205
GEN     RgX_Rg_add_shallow(GEN y, GEN x);
1206
GEN     RgX_Rg_div(GEN y, GEN x);
1207
GEN     RgX_Rg_divexact(GEN x, GEN y);
1208
GEN     RgX_Rg_eval_bk(GEN Q, GEN x);
1209
GEN     RgX_Rg_mul(GEN y, GEN x);
1210
GEN     RgX_Rg_sub(GEN y, GEN x);
1211
GEN     RgX_RgV_eval(GEN Q, GEN x);
1212
GEN     RgX_add(GEN x, GEN y);
1213
GEN     RgX_addmulXn_shallow(GEN x, GEN y, long d);
1214
GEN     RgX_addmulXn(GEN x, GEN y, long d);
1215
GEN     RgX_addspec(GEN x, GEN y, long nx, long ny);
1216
GEN     RgX_addspec_shallow(GEN x, GEN y, long nx, long ny);
1217
GEN     RgX_blocks(GEN P, long n, long m);
1218
GEN     RgX_deflate(GEN x0, long d);
1219
GEN     RgX_deriv(GEN x);
1220
GEN     RgX_digits(GEN A, GEN B);
1221
GEN     RgX_div_by_X_x(GEN a, GEN x, GEN *r);
1222
GEN     RgX_divrem(GEN x,GEN y,GEN *r);
1223
GEN     RgX_divs(GEN y, long x);
1224
long    RgX_equal(GEN x, GEN y);
1225
void    RgX_even_odd(GEN p, GEN *pe, GEN *po);
1226
GEN     RgX_inflate(GEN x0, long d);
1227
GEN     RgX_mul(GEN x,GEN y);
1228
GEN     RgX_mul_i(GEN x,GEN y);
1229
GEN     RgX_mul_normalized(GEN A, long a, GEN B, long b);
1230
GEN     RgX_mulXn(GEN x, long d);
1231
GEN     RgX_mulhigh_i(GEN f, GEN g, long n);
1232
GEN     RgX_muls(GEN y, long x);
1233
GEN     RgX_mulspec(GEN a, GEN b, long na, long nb);
1234
GEN     RgX_neg(GEN x);
1235
GEN     RgX_normalize(GEN x);
1236
GEN     RgX_pseudodivrem(GEN x, GEN y, GEN *ptr);
1237
GEN     RgX_pseudorem(GEN x, GEN y);
1238
GEN     RgX_recip(GEN x);
1239
GEN     RgX_recip_i(GEN x);
1240
GEN     RgX_recip_shallow(GEN x);
1241
GEN     RgX_rem(GEN x, GEN y);
1242
GEN     RgX_renormalize_lg(GEN x, long lx);
1243
GEN     RgX_rescale(GEN P, GEN h);
1244
GEN     RgX_rotate_shallow(GEN P, long k, long p);
1245
GEN     RgX_shift(GEN a, long n);
1246
GEN     RgX_shift_shallow(GEN x, long n);
1247
GEN     RgX_splitting(GEN p, long k);
1248
GEN     RgX_sqr(GEN x);
1249
GEN     RgX_sqr_i(GEN x);
1250
GEN     RgX_sqrhigh_i(GEN f, long n);
1251
GEN     RgX_sqrspec(GEN a, long na);
1252
GEN     RgX_sub(GEN x, GEN y);
1253
GEN     RgX_to_RgC(GEN x, long N);
1254
GEN     RgX_translate(GEN P, GEN c);
1255
GEN     RgX_unscale(GEN P, GEN h);
1256
GEN     RgXQ_matrix_pow(GEN y, long n, long m, GEN P);
1257
GEN     RgXQ_norm(GEN x, GEN T);
1258
GEN     RgXQ_pow(GEN x, GEN n, GEN T);
1259
GEN     RgXQ_powers(GEN x, long l, GEN T);
1260
GEN     RgXQ_powu(GEN x, ulong n, GEN T);
1261
GEN     RgXQ_trace(GEN x, GEN T);
1262
GEN     RgXQC_red(GEN P, GEN T);
1263
GEN     RgXQM_mul(GEN P, GEN Q, GEN T);
1264
GEN     RgXQM_red(GEN P, GEN T);
1265
GEN     RgXQV_RgXQ_mul(GEN v, GEN x, GEN T);
1266
GEN     RgXQV_factorback(GEN x, GEN n, GEN T);
1267
GEN     RgXQV_red(GEN P, GEN T);
1268
GEN     RgXQX_RgXQ_mul(GEN x, GEN y, GEN T);
1269
GEN     RgXQX_divrem(GEN x,GEN y,GEN T,GEN *r);
1270
GEN     RgXQX_mul(GEN x,GEN y,GEN T);
1271
GEN     RgXQX_powers(GEN P, long n, GEN T);
1272
GEN     RgXQX_pseudodivrem(GEN x, GEN y, GEN T, GEN *ptr);
1273
GEN     RgXQX_pseudorem(GEN x, GEN y, GEN T);
1274
GEN     RgXQX_red(GEN P, GEN T);
1275
GEN     RgXQX_sqr(GEN x, GEN T);
1276
GEN     RgXQX_translate(GEN P, GEN c, GEN T);
1277
GEN     RgXV_RgV_eval(GEN Q, GEN x);
1278
GEN     RgXV_to_RgM(GEN v, long n);
1279
GEN     RgXV_unscale(GEN v, GEN h);
1280
GEN     RgXX_to_RgM(GEN v, long n);
1281
long    RgXY_degreex(GEN bpol);
1282
GEN     RgXY_derivx(GEN x);
1283
GEN     RgXY_swap(GEN x, long n, long w);
1284
GEN     RgXY_swapspec(GEN x, long n, long w, long nx);
1285
GEN     RgXn_eval(GEN Q, GEN x, long n);
1286
GEN     RgXn_exp(GEN f, long e);
1287
GEN     RgXn_expint(GEN f, long e);
1288
GEN     RgXn_inv(GEN f, long e);
1289
GEN     RgXn_inv_i(GEN f, long e);
1290
GEN     RgXn_mul(GEN f, GEN g, long n);
1291
GEN     RgXn_powers(GEN f, long m, long n);
1292
GEN     RgXn_recip_shallow(GEN P, long n);
1293
GEN     RgXn_red_shallow(GEN a, long n);
1294
GEN     RgXn_reverse(GEN f, long e);
1295
GEN     RgXn_sqr(GEN f, long n);
1296
GEN     RgXn_sqrt(GEN f, long n);
1297
GEN     RgXnV_red_shallow(GEN P, long n);
1298
GEN     RgXn_powu(GEN x, ulong m, long n);
1299
GEN     RgXn_powu_i(GEN x, ulong m, long n);
1300
GEN     ZX_translate(GEN P, GEN c);
1301
GEN     ZX_unscale2n(GEN P, long n);
1302
GEN     ZX_unscale(GEN P, GEN h);
1303
GEN     ZX_unscale_div(GEN P, GEN h);
1304
GEN     ZX_z_unscale(GEN P, long h);
1305
GEN     ZXQ_powers(GEN x, long l, GEN T);
1306
GEN     ZXQ_powu(GEN x, ulong n, GEN T);
1307
int     ZXQX_dvd(GEN x, GEN y, GEN T);
1308
long    brent_kung_optpow(long d, long n, long m);
1309
GEN     gen_bkeval(GEN Q, long d, GEN x, int use_sqr, void *E,
1310
          const struct bb_algebra *ff, GEN cmul(void *E, GEN P, long a, GEN x));
1311
GEN     gen_bkeval_powers(GEN P, long d, GEN V, void *E,
1312
          const struct bb_algebra *ff, GEN cmul(void *E, GEN P, long a, GEN x));
1313
const struct bb_algebra * get_Rg_algebra(void);
1314
long    rfrac_deflate_order(GEN F);
1315
GEN     rfrac_deflate_max(GEN F, long *m);
1316
GEN     rfrac_deflate(GEN F, long m);
1317

1318
/* ZG.c */
1319
void    ZGC_G_mul_inplace(GEN v, GEN x);
1320
GEN     ZGCs_add(GEN x, GEN y);
1321
GEN     G_ZGC_mul(GEN x, GEN v);
1322
GEN     G_ZG_mul(GEN x, GEN y);
1323
GEN     ZGC_G_mul(GEN v, GEN x);
1324
GEN     ZGC_Z_mul(GEN v, GEN x);
1325
GEN     ZG_G_mul(GEN x, GEN y);
1326
GEN     ZG_Z_mul(GEN x, GEN c);
1327
GEN     ZG_add(GEN x, GEN y);
1328
GEN     ZG_mul(GEN x, GEN y);
1329
GEN     ZG_neg(GEN x);
1330
GEN     ZG_normalize(GEN x);
1331
GEN     ZG_sub(GEN x, GEN y);
1332

1333
/* ZV.c */
1334

1335
void    Flc_lincomb1_inplace(GEN X, GEN Y, ulong v, ulong q);
1336
GEN     vecsmall_prod(GEN v);
1337
GEN     QM_QC_mul(GEN x, GEN y);
1338
GEN     QM_det(GEN x);
1339
GEN     QM_ker(GEN M);
1340
GEN     QM_mul(GEN x, GEN y);
1341
GEN     QM_sqr(GEN x);
1342
void    RgM_check_ZM(GEN A, const char *s);
1343
void    RgV_check_ZV(GEN A, const char *s);
1344
GEN     Z_ZC_sub(GEN a, GEN x);
1345
GEN     ZV_zc_mul(GEN x, GEN y);
1346
GEN     ZC_Q_mul(GEN A, GEN z);
1347
GEN     ZC_Z_add(GEN x, GEN y);
1348
GEN     ZC_Z_div(GEN x, GEN c);
1349
GEN     ZC_Z_divexact(GEN X, GEN c);
1350
GEN     ZC_Z_mul(GEN X, GEN c);
1351
GEN     ZC_Z_sub(GEN x, GEN y);
1352
GEN     ZC_ZV_mul(GEN x, GEN y);
1353
GEN     ZC_divexactu(GEN x, ulong c);
1354
GEN     ZC_add(GEN x, GEN y);
1355
GEN     ZC_copy(GEN x);
1356
GEN     ZC_hnfremdiv(GEN x, GEN y, GEN *Q);
1357
long    ZC_is_ei(GEN x);
1358
GEN     ZC_lincomb(GEN u, GEN v, GEN X, GEN Y);
1359
void    ZC_lincomb1_inplace(GEN X, GEN Y, GEN v);
1360
void    ZC_lincomb1_inplace_i(GEN X, GEN Y, GEN v, long n);
1361
GEN     ZC_neg(GEN M);
1362
GEN     ZC_reducemodlll(GEN x,GEN y);
1363
GEN     ZC_reducemodmatrix(GEN v, GEN y);
1364
GEN     ZC_sub(GEN x, GEN y);
1365
GEN     ZC_z_mul(GEN X, long c);
1366
GEN     ZM_Q_mul(GEN A, GEN z);
1367
GEN     ZM_ZC_mul(GEN x, GEN y);
1368
GEN     ZM_Z_div(GEN X, GEN c);
1369
GEN     ZM_Z_divexact(GEN X, GEN c);
1370
GEN     ZM_Z_mul(GEN X, GEN c);
1371
GEN     ZM_add(GEN x, GEN y);
1372
GEN     ZM_copy(GEN x);
1373
GEN     ZM_det_triangular(GEN mat);
1374
GEN     ZM_diag_mul(GEN m, GEN d);
1375
GEN     ZM_divexactu(GEN x, ulong c);
1376
int     ZM_equal(GEN A, GEN B);
1377
int     ZM_equal0(GEN A);
1378
GEN     ZM_hnfdivrem(GEN x, GEN y, GEN *Q);
1379
int     ZM_ishnf(GEN x);
1380
int     ZM_isdiagonal(GEN x);
1381
int     ZM_isidentity(GEN x);
1382
int     ZM_isscalar(GEN x, GEN s);
1383
long    ZM_max_lg(GEN x);
1384
GEN     ZM_mul(GEN x, GEN y);
1385
GEN     ZM_mul_diag(GEN m, GEN d);
1386
GEN     ZM_multosym(GEN x, GEN y);
1387
GEN     ZM_neg(GEN x);
1388
GEN     ZM_nm_mul(GEN x, GEN y);
1389
GEN     ZM_pow(GEN x, GEN n);
1390
GEN     ZM_powu(GEN x, ulong n);
1391
GEN     ZM_reducemodlll(GEN x,GEN y);
1392
GEN     ZM_reducemodmatrix(GEN v, GEN y);
1393
GEN     ZM_sqr(GEN x);
1394
GEN     ZM_sub(GEN x, GEN y);
1395
GEN     ZM_supnorm(GEN x);
1396
GEN     ZM_to_Flm(GEN x, ulong p);
1397
GEN     ZM_to_zm(GEN z);
1398
GEN     ZM_transmul(GEN x, GEN y);
1399
GEN     ZM_transmultosym(GEN x, GEN y);
1400
GEN     ZMV_to_zmV(GEN z);
1401
void    ZM_togglesign(GEN M);
1402
GEN     ZM_zc_mul(GEN x, GEN y);
1403
GEN     ZM_zm_mul(GEN x, GEN y);
1404
GEN     ZMrow_ZC_mul(GEN x, GEN y, long i);
1405
int     ZMrow_equal0(GEN V, long i);
1406
GEN     ZV_ZM_mul(GEN x, GEN y);
1407
int     ZV_abscmp(GEN x, GEN y);
1408
int     ZV_cmp(GEN x, GEN y);
1409
GEN     ZV_content(GEN x);
1410
GEN     ZV_dotproduct(GEN x,GEN y);
1411
GEN     ZV_dotsquare(GEN x);
1412
int     ZV_equal(GEN V, GEN W);
1413
int     ZV_equal0(GEN V);
1414
long    ZV_max_lg(GEN x);
1415
void    ZV_neg_inplace(GEN M);
1416
GEN     ZV_prod(GEN v);
1417
GEN     ZV_sum(GEN v);
1418
GEN     ZV_to_Flv(GEN x, ulong p);
1419
GEN     ZV_to_nv(GEN z);
1420
void    ZV_togglesign(GEN M);
1421
GEN     gram_matrix(GEN M);
1422
GEN     nm_Z_mul(GEN X, GEN c);
1423
GEN     zm_mul(GEN x, GEN y);
1424
GEN     zm_to_Flm(GEN z, ulong p);
1425
GEN     zm_to_ZM(GEN z);
1426
GEN     zm_zc_mul(GEN x, GEN y);
1427
GEN     zmV_to_ZMV(GEN z);
1428
GEN     zv_abs(GEN x);
1429
long    zv_content(GEN x);
1430
long    zv_dotproduct(GEN x, GEN y);
1431
int     zv_equal(GEN V, GEN W);
1432
int     zv_equal0(GEN V);
1433
GEN     zv_neg(GEN x);
1434
GEN     zv_neg_inplace(GEN M);
1435
long    zv_prod(GEN v);
1436
GEN     zv_prod_Z(GEN v);
1437
long    zv_sum(GEN v);
1438
long    zv_sumpart(GEN v, long n);
1439
GEN     zv_to_Flv(GEN z, ulong p);
1440
GEN     zv_z_mul(GEN v, long n);
1441
GEN     zv_ZM_mul(GEN x, GEN y);
1442
int     zvV_equal(GEN V, GEN W);
1443

1444
/* ZX.c */
1445

1446
GEN     Kronecker_to_ZXQX(GEN z, GEN T);
1447
GEN     Kronecker_to_ZXX(GEN z, long N, long v);
1448
GEN     QX_ZX_rem(GEN x, GEN y);
1449
GEN     QX_mul(GEN x, GEN y);
1450
GEN     QX_sqr(GEN x);
1451
GEN     QXQM_mul(GEN x, GEN y, GEN T);
1452
GEN     QXQM_sqr(GEN x, GEN T);
1453
GEN     QXQX_QXQ_mul(GEN P, GEN U, GEN T);
1454
GEN     QXQX_mul(GEN x, GEN y, GEN T);
1455
GEN     QXQX_powers(GEN P, long n, GEN T);
1456
GEN     QXQX_sqr(GEN x, GEN T);
1457
void    RgX_check_QX(GEN x, const char *s);
1458
void    RgX_check_ZX(GEN x, const char *s);
1459
void    RgX_check_ZXX(GEN x, const char *s);
1460
GEN     Z_ZX_sub(GEN x, GEN y);
1461
GEN     ZX_Z_add(GEN y,GEN x);
1462
GEN     ZX_Z_add_shallow(GEN y, GEN x);
1463
GEN     ZX_Z_divexact(GEN y,GEN x);
1464
GEN     ZX_Z_eval(GEN x, GEN y);
1465
GEN     ZX_Z_mul(GEN y,GEN x);
1466
GEN     ZX_Z_sub(GEN y, GEN x);
1467
GEN     ZX_add(GEN x, GEN y);
1468
GEN     ZX_copy(GEN x);
1469
GEN     ZX_deriv(GEN x);
1470
GEN     ZX_div_by_X_1(GEN a, GEN *r);
1471
GEN     ZX_divuexact(GEN y, ulong x);
1472
int     ZX_equal(GEN V, GEN W);
1473
GEN     ZX_eval1(GEN x);
1474
long    ZX_max_lg(GEN x);
1475
GEN     ZX_mod_Xnm1(GEN T, ulong n);
1476
GEN     ZX_mul(GEN x, GEN y);
1477
GEN     ZX_mulspec(GEN a, GEN b, long na, long nb);
1478
GEN     ZX_mulu(GEN y, ulong x);
1479
GEN     ZX_neg(GEN x);
1480
GEN     ZX_rem(GEN x, GEN y);
1481
GEN     ZX_remi2n(GEN y, long n);
1482
GEN     ZX_rescale2n(GEN P, long n);
1483
GEN     ZX_rescale(GEN P, GEN h);
1484
GEN     ZX_rescale_lt(GEN P);
1485
GEN     ZX_shifti(GEN x, long n);
1486
GEN     ZX_sqr(GEN x);
1487
GEN     ZX_sqrspec(GEN a, long na);
1488
GEN     ZX_sub(GEN x, GEN y);
1489
long    ZX_val(GEN x);
1490
long    ZX_valrem(GEN x, GEN *Z);
1491
GEN     ZXC_to_FlxC(GEN x, ulong p, long vs);
1492
GEN     ZXM_to_FlxM(GEN x, ulong p, long vs);
1493
GEN     ZXQM_mul(GEN x, GEN y, GEN T);
1494
GEN     ZXQM_sqr(GEN x, GEN T);
1495
GEN     ZXQX_ZXQ_mul(GEN P, GEN U, GEN T);
1496
GEN     ZXQX_sqr(GEN x, GEN T);
1497
GEN     ZXQX_mul(GEN x, GEN y, GEN T);
1498
GEN     ZXT_remi2n(GEN z, long n);
1499
GEN     ZXV_Z_mul(GEN y, GEN x);
1500
GEN     ZXV_dotproduct(GEN V, GEN W);
1501
int     ZXV_equal(GEN V, GEN W);
1502
GEN     ZXV_remi2n(GEN x, long n);
1503
GEN     ZXX_Z_divexact(GEN y, GEN x);
1504
GEN     ZXX_Z_mul(GEN y, GEN x);
1505
GEN     ZXX_Z_add_shallow(GEN x, GEN y);
1506
GEN     ZXX_evalx0(GEN y);
1507
long    ZXX_max_lg(GEN x);
1508
GEN     ZXX_mul_Kronecker(GEN x, GEN y, long n);
1509
GEN     ZXX_renormalize(GEN x, long lx);
1510
GEN     ZXX_sqr_Kronecker(GEN x, long n);
1511
GEN     RgXX_to_Kronecker(GEN P, long n);
1512
GEN     RgXX_to_Kronecker_spec(GEN P, long lP, long n);
1513
GEN     ZXn_mul(GEN x, GEN y, long n);
1514
GEN     ZXn_sqr(GEN x, long n);
1515
GEN     scalar_ZX(GEN x, long v);
1516
GEN     scalar_ZX_shallow(GEN x, long v);
1517
GEN     zx_to_ZX(GEN z);
1518
GEN     zx_z_divexact(GEN y, long x);
1519

1520
/* algebras.c */
1521

1522
GEN     alg_centralproj(GEN al, GEN z, long maps);
1523
GEN     alg_changeorder(GEN al, GEN ord);
1524
GEN     alg_complete(GEN rnf, GEN aut, GEN hi, GEN hf, long maxord);
1525
GEN     alg_csa_table(GEN nf, GEN mt, long v, long maxord);
1526
GEN     alg_cyclic(GEN rnf, GEN aut, GEN b, long maxord);
1527
long    alg_get_absdim(GEN al);
1528
GEN     alg_get_abssplitting(GEN al);
1529
GEN     alg_get_aut(GEN al);
1530
GEN     algaut(GEN al);
1531
GEN     alg_get_auts(GEN al);
1532
GEN     alg_get_b(GEN al);
1533
GEN     algb(GEN al);
1534
GEN     algcenter(GEN al);
1535
GEN     alg_get_center(GEN al);
1536
GEN     alg_get_char(GEN al);
1537
GEN     algchar(GEN al);
1538
long    alg_get_degree(GEN al);
1539
long    algdegree(GEN al);
1540
long    alg_get_dim(GEN al);
1541
long    algdim(GEN al, long abs);
1542
GEN     alg_get_hasse_f(GEN al);
1543
GEN     alghassef(GEN al);
1544
GEN     alg_get_hasse_i(GEN al);
1545
GEN     alghassei(GEN al);
1546
GEN     alg_get_invbasis(GEN al);
1547
GEN     alginvbasis(GEN al);
1548
GEN     alg_get_multable(GEN al);
1549
GEN     alg_get_basis(GEN al);
1550
GEN     algbasis(GEN al);
1551
GEN     alg_get_relmultable(GEN al);
1552
GEN     algrelmultable(GEN al);
1553
GEN     alg_get_splitpol(GEN al);
1554
GEN     alg_get_splittingfield(GEN al);
1555
GEN     algsplittingfield(GEN al);
1556
GEN     alg_get_splittingbasis(GEN al);
1557
GEN     alg_get_splittingbasisinv(GEN al);
1558
GEN     alg_get_splittingdata(GEN al);
1559
GEN     algsplittingdata(GEN al);
1560
GEN     alg_get_tracebasis(GEN al);
1561
GEN     alg_hasse(GEN nf, long n, GEN hi, GEN hf, long var, long maxord);
1562
GEN     alg_hilbert(GEN nf, GEN a, GEN b, long v, long maxord);
1563
GEN     alg_matrix(GEN nf, long n, long v, GEN L, long maxord);
1564
long    alg_model(GEN al, GEN x);
1565
GEN     alg_quotient(GEN al, GEN I, long maps);
1566
GEN     algradical(GEN al);
1567
GEN     algsimpledec(GEN al, long maps);
1568
GEN     algsimpledec_ss(GEN al, long maps);
1569
GEN     algsubalg(GEN al, GEN basis);
1570
long    alg_type(GEN al);
1571
GEN     algadd(GEN al, GEN x, GEN y);
1572
GEN     algalgtobasis(GEN al, GEN x);
1573
GEN     algbasistoalg(GEN al, GEN x);
1574
GEN     algcharpoly(GEN al, GEN x, long v, long abs);
1575
GEN     algdisc(GEN al);
1576
GEN     algdivl(GEN al, GEN x, GEN y);
1577
GEN     algdivr(GEN al, GEN x, GEN y);
1578
GEN     alggroup(GEN gal, GEN p);
1579
GEN     alggroupcenter(GEN gal, GEN p, GEN* ptr_conjclasses);
1580
GEN     alghasse(GEN al, GEN pl);
1581
GEN     alginit(GEN A, GEN B, long v, long maxord);
1582
long    algindex(GEN al, GEN pl);
1583
GEN     alginv(GEN al, GEN x);
1584
int     algisassociative(GEN mt0, GEN p);
1585
int     algiscommutative(GEN al);
1586
int     algisdivision(GEN al, GEN pl);
1587
int     algisramified(GEN al, GEN pl);
1588
int     algissemisimple(GEN al);
1589
int     algissimple(GEN al, long ss);
1590
int     algissplit(GEN al, GEN pl);
1591
int     algisdivl(GEN al, GEN x, GEN y, GEN* ptz);
1592
int     algisinv(GEN al, GEN x, GEN* ptix);
1593
GEN     algmakeintegral(GEN mt0, long maps);
1594
GEN     algmul(GEN al, GEN x, GEN y);
1595
GEN     algmultable(GEN al);
1596
GEN     alglat_get_primbasis(GEN lat);
1597
GEN     alglat_get_scalar(GEN lat);
1598
GEN     alglatadd(GEN al, GEN lat1, GEN lat2, GEN* ptinter);
1599
int     alglatcontains(GEN al, GEN lat, GEN x, GEN* ptc);
1600
GEN     alglatelement(GEN al, GEN lat, GEN c);
1601
GEN     alglathnf(GEN al, GEN m, GEN d);
1602
GEN     alglatindex(GEN al, GEN lat1, GEN lat2);
1603
GEN     alglatinter(GEN al, GEN lat1, GEN lat2, GEN* ptsum);
1604
GEN     alglatmul(GEN al, GEN lat1, GEN lat2);
1605
GEN     alglatlefttransporter(GEN al, GEN lat1, GEN lat2);
1606
GEN     alglatrighttransporter(GEN al, GEN lat1, GEN lat2);
1607
int     alglatsubset(GEN al, GEN lat1, GEN lat2, GEN* ptindex);
1608
GEN     algneg(GEN al, GEN x);
1609
GEN     algnorm(GEN al, GEN x, long abs);
1610
GEN     algpoleval(GEN al, GEN pol, GEN x);
1611
GEN     algpow(GEN al, GEN x, GEN n);
1612
GEN     algprimesubalg(GEN al);
1613
GEN     algramifiedplaces(GEN al);
1614
GEN     algrandom(GEN al, GEN b);
1615
GEN     algsplit(GEN al, long v);
1616
GEN     algtomatrix(GEN al, GEN x, long abs);
1617
GEN     algsqr(GEN al, GEN x);
1618
GEN     algsub(GEN al, GEN x, GEN y);
1619
GEN     algtableinit(GEN mt, GEN p);
1620
GEN     algtensor(GEN al1, GEN al2, long maxord);
1621
GEN     algtrace(GEN al, GEN x, long abs);
1622
long    algtype(GEN al);
1623
GEN     bnfgwgeneric(GEN bnf, GEN Lpr, GEN Ld, GEN pl, long var);
1624
void    checkalg(GEN x);
1625
void    checkhasse(GEN nf, GEN hi, GEN hf, long n);
1626
void    checklat(GEN al, GEN lat);
1627
GEN     conjclasses_algcenter(GEN cc, GEN p);
1628
GEN     galoischardet(GEN gal, GEN ch, long o);
1629
GEN     galoischarpoly(GEN gal, GEN ch, long o);
1630
GEN     galoischartable(GEN gal);
1631
GEN     nfgrunwaldwang(GEN nf0, GEN Lpr, GEN Ld, GEN pl, long var);
1632
GEN     nfgwkummer(GEN nf, GEN Lpr, GEN Ld, GEN pl, long var);
1633

1634
/* alglin1.c */
1635

1636
GEN     F2Ms_colelim(GEN M, long nbrow);
1637
GEN     F2m_image(GEN x);
1638
GEN     F2m_indexrank(GEN x);
1639
GEN     F2m_suppl(GEN x);
1640
GEN     F2xqM_F2xqC_gauss(GEN a, GEN b, GEN T);
1641
GEN     F2xqM_F2xqC_invimage(GEN a, GEN b, GEN T);
1642
GEN     F2xqM_F2xqC_mul(GEN a, GEN b, GEN T);
1643
GEN     F2xqM_deplin(GEN x, GEN T);
1644
GEN     F2xqM_det(GEN a, GEN T);
1645
GEN     F2xqM_gauss(GEN a, GEN b, GEN T);
1646
GEN     F2xqM_ker(GEN x, GEN T);
1647
GEN     F2xqM_image(GEN x, GEN T);
1648
GEN     F2xqM_indexrank(GEN x, GEN T);
1649
GEN     F2xqM_inv(GEN a, GEN T);
1650
GEN     F2xqM_invimage(GEN a, GEN b, GEN T);
1651
GEN     F2xqM_mul(GEN a, GEN b, GEN T);
1652
long    F2xqM_rank(GEN x, GEN T);
1653
GEN     F2xqM_suppl(GEN x, GEN T);
1654
GEN     Flm_image(GEN x, ulong p);
1655
GEN     Flm_indexrank(GEN x, ulong p);
1656
GEN     Flm_suppl(GEN x, ulong p);
1657
GEN     FlxqM_FlxqC_gauss(GEN a, GEN b, GEN T, ulong p);
1658
GEN     FlxqM_FlxqC_invimage(GEN a, GEN b, GEN T, ulong p);
1659
GEN     FlxqM_FlxqC_mul(GEN a, GEN b, GEN T, ulong p);
1660
GEN     FlxqM_deplin(GEN x, GEN T, ulong p);
1661
GEN     FlxqM_det(GEN a, GEN T, ulong p);
1662
GEN     FlxqM_gauss(GEN a, GEN b, GEN T, ulong p);
1663
GEN     FlxqM_ker(GEN x, GEN T, ulong p);
1664
GEN     FlxqM_image(GEN x, GEN T, ulong p);
1665
GEN     FlxqM_indexrank(GEN x, GEN T, ulong p);
1666
GEN     FlxqM_inv(GEN x, GEN T, ulong p);
1667
GEN     FlxqM_invimage(GEN a, GEN b, GEN T, ulong p);
1668
GEN     FlxqM_mul(GEN a, GEN b, GEN T, ulong p);
1669
long    FlxqM_rank(GEN x, GEN T, ulong p);
1670
GEN     FlxqM_suppl(GEN x, GEN T, ulong p);
1671
GEN     FpM_FpC_gauss(GEN a, GEN b, GEN p);
1672
GEN     FpM_FpC_invimage(GEN m, GEN v, GEN p);
1673
GEN     FpM_deplin(GEN x, GEN p);
1674
GEN     FpM_det(GEN x, GEN p);
1675
GEN     FpM_gauss(GEN a, GEN b, GEN p);
1676
GEN     FpM_image(GEN x, GEN p);
1677
GEN     FpM_indexrank(GEN x, GEN p);
1678
GEN     FpM_intersect(GEN x, GEN y, GEN p);
1679
GEN     FpM_intersect_i(GEN x, GEN y, GEN p);
1680
GEN     FpM_inv(GEN x, GEN p);
1681
GEN     FpM_invimage(GEN m, GEN v, GEN p);
1682
GEN     FpM_ker(GEN x, GEN p);
1683
long    FpM_rank(GEN x, GEN p);
1684
GEN     FpM_suppl(GEN x, GEN p);
1685
GEN     FqM_FqC_gauss(GEN a, GEN b, GEN T, GEN p);
1686
GEN     FqM_FqC_invimage(GEN a, GEN b, GEN T, GEN p);
1687
GEN     FqM_FqC_mul(GEN a, GEN b, GEN T, GEN p);
1688
GEN     FqM_deplin(GEN x, GEN T, GEN p);
1689
GEN     FqM_det(GEN x, GEN T, GEN p);
1690
GEN     FqM_gauss(GEN a, GEN b, GEN T, GEN p);
1691
GEN     FqM_ker(GEN x, GEN T, GEN p);
1692
GEN     FqM_image(GEN x, GEN T, GEN p);
1693
GEN     FqM_indexrank(GEN x, GEN T, GEN p);
1694
GEN     FqM_inv(GEN x, GEN T, GEN p);
1695
GEN     FqM_invimage(GEN a, GEN b, GEN T, GEN p);
1696
GEN     FqM_mul(GEN a, GEN b, GEN T, GEN p);
1697
long    FqM_rank(GEN a, GEN T, GEN p);
1698
GEN     FqM_suppl(GEN x, GEN T, GEN p);
1699
GEN     QM_image_shallow(GEN A);
1700
GEN     QM_image(GEN A);
1701
GEN     QM_gauss(GEN a, GEN b);
1702
GEN     QM_gauss_i(GEN M, GEN B, long flag);
1703
GEN     QM_indexrank(GEN x);
1704
GEN     QM_inv(GEN M);
1705
long    QM_rank(GEN x);
1706
GEN     RgM_Fp_init(GEN a, GEN p, ulong *pp);
1707
GEN     RgM_Hadamard(GEN a);
1708
GEN     RgM_RgC_invimage(GEN A, GEN B);
1709
GEN     RgM_diagonal(GEN m);
1710
GEN     RgM_diagonal_shallow(GEN m);
1711
GEN     RgM_inv(GEN a);
1712
GEN     RgM_inv_upper(GEN a);
1713
GEN     RgM_invimage(GEN A, GEN B);
1714
GEN     RgM_solve(GEN a, GEN b);
1715
GEN     RgM_solve_realimag(GEN x, GEN y);
1716
void    RgMs_structelim(GEN M, long nbrow, GEN A, GEN *p_col, GEN *p_lin);
1717
GEN     ZM_det(GEN a);
1718
GEN     ZM_detmult(GEN A);
1719
GEN     ZM_gauss(GEN a, GEN b);
1720
GEN     ZM_ker(GEN M);
1721
GEN     ZM_imagecompl(GEN x);
1722
GEN     ZM_indeximage(GEN x);
1723
GEN     ZM_indexrank(GEN x);
1724
GEN     ZM_inv(GEN M, GEN *den);
1725
GEN     ZM_inv_ratlift(GEN M, GEN *pden);
1726
GEN     ZM_pseudoinv(GEN M, GEN *pv, GEN *den);
1727
long    ZM_rank(GEN x);
1728
GEN     ZlM_gauss(GEN a, GEN b, ulong p, long e, GEN C);
1729
GEN     closemodinvertible(GEN x, GEN y);
1730
GEN     deplin(GEN x);
1731
GEN     det(GEN a);
1732
GEN     det0(GEN a,long flag);
1733
GEN     det2(GEN a);
1734
GEN     detint(GEN x);
1735
GEN     eigen(GEN x, long prec);
1736
GEN     gauss(GEN a, GEN b);
1737
GEN     gaussmodulo(GEN M, GEN D, GEN Y);
1738
GEN     gaussmodulo2(GEN M, GEN D, GEN Y);
1739
GEN     gen_Gauss(GEN a, GEN b, void *E, const struct bb_field *ff);
1740
GEN     gen_Gauss_pivot(GEN x, long *rr, void *E, const struct bb_field *ff);
1741
GEN     gen_det(GEN a, void *E, const struct bb_field *ff);
1742
GEN     gen_ker(GEN x, long deplin, void *E, const struct bb_field *ff);
1743
GEN     gen_matcolinvimage(GEN a, GEN b, void *E, const struct bb_field *ff);
1744
GEN     gen_matcolmul(GEN a, GEN b, void *E, const struct bb_field *ff);
1745
GEN     gen_matinvimage(GEN a, GEN b, void *E, const struct bb_field *ff);
1746
GEN     gen_matmul(GEN a, GEN b, void *E, const struct bb_field *ff);
1747
GEN     image(GEN x);
1748
GEN     image2(GEN x);
1749
GEN     imagecompl(GEN x);
1750
GEN     indexrank(GEN x);
1751
GEN     inverseimage(GEN mat, GEN y);
1752
GEN     ker(GEN x);
1753
GEN     mateigen(GEN x, long flag, long prec);
1754
GEN     matimage0(GEN x,long flag);
1755
GEN     matker0(GEN x, long flag);
1756
long    rank(GEN x);
1757
GEN     reducemodinvertible(GEN x, GEN y);
1758
GEN     reducemodlll(GEN x,GEN y);
1759
GEN     split_realimag(GEN x, long r1, long r2);
1760
GEN     suppl(GEN x);
1761

1762
/* alglin2.c */
1763

1764
GEN     Flm_charpoly(GEN x, ulong p);
1765
GEN     Flm_hess(GEN x, ulong p);
1766
GEN     FpM_charpoly(GEN x, GEN p);
1767
GEN     FpM_hess(GEN x, GEN p);
1768
GEN     Frobeniusform(GEN V, long n);
1769
GEN			RgM_Frobenius(GEN A, long flag, GEN* pt_P, GEN* pt_v);
1770
GEN     QM_minors_coprime(GEN x, GEN pp);
1771
GEN     QM_ImZ(GEN x);
1772
GEN     QM_ImZ_all(GEN x, GEN *U, long remove, long hnf);
1773
GEN     QM_ImZ_hnf(GEN x);
1774
GEN     QM_ImZ_hnfall(GEN x, GEN *U, long remove);
1775
GEN     QM_ImQ(GEN x);
1776
GEN     QM_ImQ_all(GEN x, GEN *U, long remove, long hnf);
1777
GEN     QM_ImQ_hnf(GEN x);
1778
GEN     QM_ImQ_hnfall(GEN x, GEN *U, long remove);
1779
GEN     QM_charpoly_ZX(GEN M);
1780
GEN     QM_charpoly_ZX_bound(GEN M, long bit);
1781
GEN     ZM_charpoly(GEN x);
1782
GEN     adj(GEN x);
1783
GEN     adjsafe(GEN x);
1784
GEN     caract(GEN x, long v);
1785
GEN     caradj(GEN x, long v, GEN *py);
1786
GEN     carberkowitz(GEN x, long v);
1787
GEN     carhess(GEN x, long v);
1788
GEN     charpoly(GEN x, long v);
1789
GEN     charpoly0(GEN x, long v,long flag);
1790
GEN     gnorm(GEN x);
1791
GEN     gnorml1(GEN x,long prec);
1792
GEN     gnorml1_fake(GEN x);
1793
GEN     gnormlp(GEN x, GEN p, long prec);
1794
GEN     gnorml2(GEN x);
1795
GEN     gsupnorm(GEN x, long prec);
1796
void    gsupnorm_aux(GEN x, GEN *m, GEN *msq, long prec);
1797
GEN     gtrace(GEN x);
1798
GEN     hess(GEN x);
1799
GEN     intersect(GEN x, GEN y);
1800
GEN     jacobi(GEN a, long prec);
1801
GEN     matadjoint0(GEN x, long flag);
1802
GEN     matcompanion(GEN x);
1803
GEN     matrixqz0(GEN x, GEN pp);
1804
GEN     minpoly(GEN x, long v);
1805
GEN     qfgaussred(GEN a);
1806
GEN     qfgaussred_positive(GEN a);
1807
GEN     qfsign(GEN a);
1808

1809
/* alglin3.c */
1810

1811
GEN     apply0(GEN f, GEN A);
1812
GEN     diagonal(GEN x);
1813
GEN     diagonal_shallow(GEN x);
1814
GEN     extract0(GEN x, GEN l1, GEN l2);
1815
GEN     fold0(GEN f, GEN A);
1816
GEN     genapply(void *E, GEN (*f)(void *E, GEN x), GEN A);
1817
GEN     genfold(void *E, GEN (*f)(void *E, GEN x, GEN y), GEN A);
1818
GEN     genindexselect(void *E, long (*f)(void *E, GEN x), GEN A);
1819
GEN     genselect(void *E, long (*f)(void *E, GEN x), GEN A);
1820
GEN     gtomat(GEN x);
1821
GEN     gtrans(GEN x);
1822
GEN     matmuldiagonal(GEN x, GEN d);
1823
GEN     matmultodiagonal(GEN x, GEN y);
1824
GEN     matslice0(GEN A, long x1, long x2, long y1, long y2);
1825
GEN     parapply(GEN V, GEN C);
1826
void    parfor(GEN a, GEN b, GEN code, void *E, long call(void*, GEN, GEN));
1827
void    parfor_init(parfor_t *T, GEN a, GEN b, GEN code);
1828
GEN     parfor_next(parfor_t *T);
1829
void    parfor_stop(parfor_t *T);
1830
void    parforeach(GEN x, GEN code, void *E, long call(void*, GEN, GEN));
1831
void    parforeach_init(parforeach_t *T, GEN x, GEN code);
1832
GEN     parforeach_next(parforeach_t *T);
1833
void    parforeach_stop(parforeach_t *T);
1834
void    parforprime(GEN a, GEN b, GEN code, void *E, long call(void*, GEN, GEN));
1835
void    parforprime_init(parforprime_t *T, GEN a, GEN b, GEN code);
1836
GEN     parforprime_next(parforprime_t *T);
1837
void    parforprime_stop(parforprime_t *T);
1838
void    parforprimestep(GEN a, GEN b, GEN q, GEN code, void *E, long call(void*, GEN, GEN));
1839
void    parforprimestep_init(parforprime_t *T, GEN a, GEN b, GEN q, GEN code);
1840
void    parforvec(GEN x, GEN code, long flag, void *E, long call(void*, GEN, GEN));
1841
void    parforvec_init(parforvec_t *T, GEN x, GEN code, long flag);
1842
GEN     parforvec_next(parforvec_t *T);
1843
void    parforvec_stop(parforvec_t *T);
1844
GEN     parselect(GEN C, GEN D, long flag);
1845
GEN     select0(GEN A, GEN f, long flag);
1846
GEN     shallowextract(GEN x, GEN L);
1847
GEN     shallowmatextract(GEN x, GEN l1, GEN l2);
1848
GEN     shallowtrans(GEN x);
1849
GEN     vecapply(void *E, GEN (*f)(void* E, GEN x), GEN x);
1850
GEN     veccatapply(void *E, GEN (*f)(void* E, GEN x), GEN x);
1851
GEN     veccatselapply(void *Epred, long (*pred)(void* E, GEN x), void *Efun,
1852
                            GEN (*fun)(void* E, GEN x), GEN A);
1853
GEN     vecrange(GEN a, GEN b);
1854
GEN     vecrangess(long a, long b);
1855
GEN     vecselapply(void *Epred, long (*pred)(void* E, GEN x), void *Efun,
1856
                            GEN (*fun)(void* E, GEN x), GEN A);
1857
GEN     vecselect(void *E, long (*f)(void* E, GEN x), GEN A);
1858
GEN     vecslice0(GEN A, long y1, long y2);
1859
GEN     vecsum(GEN v);
1860
GEN     zv_diagonal(GEN x);
1861

1862
/* anal.c */
1863

1864
void    addhelp(const char *e, char *s);
1865
GEN     arity0(GEN C);
1866
void    alias0(const char *s, const char *old);
1867
GEN     compile_str(const char *s);
1868
long    delete_var(void);
1869
long    fetch_user_var(const char *s);
1870
long    fetch_var(void);
1871
long    fetch_var_higher(void);
1872
GEN     fetch_var_value(long vx, GEN t);
1873
char *  gp_embedded(const char *s);
1874
void    gp_embedded_init(long rsize, long vsize);
1875
GEN     gp_read_str(const char *t);
1876
GEN     gp_read_str_bitprec(const char *s, long bitprec);
1877
GEN     gp_read_str_prec(const char *s, long prec);
1878
entree* install(void *f, const char *name, const char *code);
1879
entree* is_entry(const char *s);
1880
void    kill0(const char *e);
1881
void    pari_var_close(void);
1882
void    pari_var_init(void);
1883
long    pari_var_next(void);
1884
long    pari_var_next_temp(void);
1885
long    pari_var_create(entree *ep);
1886
void    name_var(long n, const char *s);
1887
GEN     readseq(char *t);
1888
GEN*    safegel(GEN x, long l);
1889
long*   safeel(GEN x, long l);
1890
GEN*    safelistel(GEN x, long l);
1891
GEN*    safegcoeff(GEN x, long a, long b);
1892
GEN     strtoi(const char *s);
1893
GEN     strtor(const char *s, long prec);
1894
GEN     varhigher(const char *s, long v);
1895
GEN     varlower(const char *s, long v);
1896

1897
/* aprcl.c */
1898

1899
GEN     divisorslenstra(GEN N, GEN r, GEN s);
1900
long    isprimeAPRCL(GEN N);
1901

1902
/* Qfb.c */
1903

1904
GEN     Qfb0(GEN x, GEN y, GEN z);
1905
void    check_quaddisc(GEN x, long *s, long *r, const char *f);
1906
void    check_quaddisc_imag(GEN x, long *r, const char *f);
1907
void    check_quaddisc_real(GEN x, long *r, const char *f);
1908
long    cornacchia(GEN d, GEN p, GEN *px, GEN *py);
1909
long    cornacchia2(GEN d, GEN p, GEN *px, GEN *py);
1910
long    cornacchia2_sqrt(GEN d, GEN p, GEN b, GEN *px, GEN *py);
1911
GEN     nucomp(GEN x, GEN y, GEN L);
1912
GEN     nudupl(GEN x, GEN L);
1913
GEN     nupow(GEN x, GEN n, GEN L);
1914
GEN     primeform(GEN x, GEN p);
1915
GEN     primeform_u(GEN x, ulong p);
1916
GEN     qfb_1(GEN x);
1917
int     qfb_equal1(GEN f);
1918
GEN     qfbcomp(GEN x, GEN y);
1919
GEN     qfbcomp_i(GEN x, GEN y);
1920
GEN     qfbcompraw(GEN x, GEN y);
1921
GEN     qfbcompraw_i(GEN x, GEN y);
1922
GEN     qfbpow(GEN x, GEN n);
1923
GEN     qfbpow_i(GEN x, GEN n);
1924
GEN     qfbpowraw(GEN x, long n);
1925
GEN     qfbred(GEN x);
1926
GEN     qfbred_i(GEN x);
1927
GEN     qfbred0(GEN x, long flag, GEN isqrtD, GEN sqrtD);
1928
GEN     qfbredsl2(GEN q, GEN isD);
1929
GEN     qfbsolve(GEN Q, GEN n, long flag);
1930
GEN     qfbsqr(GEN x);
1931
GEN     qfbsqr_i(GEN x);
1932
GEN     qfi_Shanks(GEN a, GEN g, long n);
1933
GEN     qfi_log(GEN a, GEN g, GEN o);
1934
GEN     qfi_order(GEN q, GEN o);
1935
GEN     qfisolvep(GEN Q, GEN p);
1936
GEN     qfr3_comp(GEN x, GEN y, struct qfr_data *S);
1937
GEN     qfr3_compraw(GEN x, GEN y);
1938
GEN     qfr3_pow(GEN x, GEN n, struct qfr_data *S);
1939
GEN     qfr3_red(GEN x, struct qfr_data *S);
1940
GEN     qfr3_rho(GEN x, struct qfr_data *S);
1941
GEN     qfr3_to_qfr(GEN x, GEN D);
1942
GEN     qfr5_comp(GEN x, GEN y, struct qfr_data *S);
1943
GEN     qfr5_compraw(GEN x, GEN y);
1944
GEN     qfr5_dist(GEN e, GEN d, long prec);
1945
GEN     qfr5_pow(GEN x, GEN n, struct qfr_data *S);
1946
GEN     qfr5_red(GEN x, struct qfr_data *S);
1947
GEN     qfr5_rho(GEN x, struct qfr_data *S);
1948
GEN     qfr5_to_qfr(GEN x, GEN D, GEN d0);
1949
void    qfr_data_init(GEN D, long prec, struct qfr_data *S);
1950
GEN     qfr_to_qfr5(GEN x, long prec);
1951
GEN     qfrsolvep(GEN Q, GEN p);
1952
GEN     quadgen(GEN x);
1953
GEN     quadgen0(GEN x, long v);
1954
GEN     quadpoly(GEN x);
1955
GEN     quadpoly_i(GEN D);
1956
GEN     quadpoly0(GEN x, long v);
1957

1958
/* arith1.c */
1959

1960
ulong   Fl_2gener_pre(ulong p, ulong pi);
1961
ulong   Fl_log(ulong a, ulong g, ulong ord, ulong p);
1962
ulong   Fl_log_pre(ulong a, ulong g, ulong ord, ulong p, ulong pi);
1963
ulong   Fl_order(ulong a, ulong o, ulong p);
1964
GEN     Fl_powers(ulong x, long n, ulong p);
1965
GEN     Fl_powers_pre(ulong x, long n, ulong p, ulong pi);
1966
ulong   Fl_powu(ulong x, ulong n, ulong p);
1967
ulong   Fl_powu_pre(ulong x, ulong n, ulong p, ulong pi);
1968
ulong   Fl_sqrt(ulong a, ulong p);
1969
ulong   Fl_sqrt_pre(ulong a, ulong p, ulong pi);
1970
ulong   Fl_sqrt_pre_i(ulong a, ulong s2, ulong p, ulong pi);
1971
ulong   Fl_sqrtl(ulong a, ulong l, ulong p);
1972
ulong   Fl_sqrtl_pre(ulong a, ulong l, ulong p, ulong pi);
1973
ulong   Fl_sqrtn(ulong a, long n, ulong p, ulong *zetan);
1974
ulong   Fl_sqrtn_pre(ulong a, long n, ulong p, ulong pi, ulong *zetan);
1975
GEN     Fp_2gener(GEN p);
1976
GEN     Fp_factored_order(GEN a, GEN o, GEN p);
1977
int     Fp_ispower(GEN x, GEN K, GEN p);
1978
GEN     Fp_log(GEN a, GEN g, GEN ord, GEN p);
1979
GEN     Fp_order(GEN a, GEN o, GEN p);
1980
GEN     Fp_pow(GEN a, GEN n, GEN m);
1981
GEN     Fp_pow_init(GEN x, GEN n, long k, GEN p);
1982
GEN     Fp_pow_table(GEN R, GEN n, GEN p);
1983
GEN     Fp_powers(GEN x, long n, GEN p);
1984
GEN     Fp_pows(GEN A, long k, GEN N);
1985
GEN     Fp_powu(GEN x, ulong k, GEN p);
1986
GEN     Fp_sqrt(GEN a, GEN p);
1987
GEN     Fp_sqrt_i(GEN a, GEN y, GEN p);
1988
GEN     Fp_sqrtn(GEN a, GEN n, GEN p, GEN *zetan);
1989
GEN     FpV_prod(GEN V, GEN p);
1990
GEN     Z_ZV_mod(GEN P, GEN xa);
1991
GEN     Z_ZV_mod_tree(GEN P, GEN xa, GEN T);
1992
GEN     Z_chinese(GEN a, GEN b, GEN A, GEN B);
1993
GEN     Z_chinese_all(GEN a, GEN b, GEN A, GEN B, GEN *pC);
1994
GEN     Z_chinese_coprime(GEN a, GEN b, GEN A, GEN B, GEN C);
1995
GEN     Z_chinese_post(GEN a, GEN b, GEN C, GEN U, GEN d);
1996
void    Z_chinese_pre(GEN A, GEN B, GEN *pC, GEN *pU, GEN *pd);
1997
GEN     Z_factor_listP(GEN N, GEN L);
1998
long    Z_isanypower(GEN x, GEN *y);
1999
long    Z_isfundamental(GEN x);
2000
long    Z_ispow2(GEN x);
2001
long    Z_ispowerall(GEN x, ulong k, GEN *pt);
2002
long    Z_issquareall(GEN x, GEN *pt);
2003
GEN     Z_nv_mod(GEN P, GEN xa);
2004
GEN     ZM_nv_mod_tree(GEN M, GEN xa, GEN T);
2005
GEN     ZV_allpnqn(GEN x);
2006
GEN     ZV_chinese(GEN A, GEN P, GEN *pt_mod);
2007
GEN     ZV_chinese_tree(GEN A, GEN P, GEN T, GEN R);
2008
GEN     ZV_chinesetree(GEN P, GEN T);
2009
GEN     ZV_nv_mod_tree(GEN V, GEN xa, GEN T);
2010
GEN     ZV_producttree(GEN xa);
2011
GEN     ZX_nv_mod_tree(GEN P, GEN xa, GEN T);
2012
GEN     ZXC_nv_mod_tree(GEN P, GEN xa, GEN T, long w);
2013
GEN     ZXM_nv_mod_tree(GEN M, GEN xa, GEN T, long w);
2014
GEN     ZXX_nv_mod_tree(GEN P, GEN xa, GEN T, long w);
2015
GEN     Zideallog(GEN bid, GEN x);
2016
long    Zp_issquare(GEN a, GEN p);
2017
GEN     bestappr(GEN x, GEN k);
2018
GEN     bestapprPade(GEN x, long B);
2019
GEN     chinese(GEN x, GEN y);
2020
GEN     chinese1(GEN x);
2021
GEN     chinese1_coprime_Z(GEN x);
2022
GEN     classno(GEN x);
2023
GEN     classno2(GEN x);
2024
GEN     contfrac0(GEN x, GEN b, long flag);
2025
GEN     contfracpnqn(GEN x, long n);
2026
GEN     fibo(long n);
2027
GEN     gboundcf(GEN x, long k);
2028
GEN     gcf(GEN x);
2029
GEN     gcf2(GEN b, GEN x);
2030
const struct bb_field *get_Fp_field(void **E, GEN p);
2031
long    gisanypower(GEN x, GEN *pty);
2032
GEN     gissquare(GEN x);
2033
GEN     gissquareall(GEN x, GEN *pt);
2034
GEN     hclassno(GEN x);
2035
GEN     hclassno6(GEN x);
2036
long    hilbert(GEN x, GEN y, GEN p);
2037
long    hilbertii(GEN x, GEN y, GEN p);
2038
long    isfundamental(GEN x);
2039
long    ispolygonal(GEN x, GEN S, GEN *N);
2040
long    ispower(GEN x, GEN k, GEN *pty);
2041
long    isprimepower(GEN x, GEN *pty);
2042
long    ispseudoprimepower(GEN n, GEN *pt);
2043
long    issquare(GEN x);
2044
long    issquareall(GEN x, GEN *pt);
2045
long    krois(GEN x, long y);
2046
long    kroiu(GEN x, ulong y);
2047
long    kronecker(GEN x, GEN y);
2048
long    krosi(long s, GEN x);
2049
long    kross(long x, long y);
2050
long    kroui(ulong x, GEN y);
2051
long    krouu(ulong x, ulong y);
2052
GEN     lcmii(GEN a, GEN b);
2053
GEN     Fp_invgen(GEN x, GEN N, GEN *pd);
2054
long    logint0(GEN B, GEN y, GEN *ptq);
2055
long    logintall(GEN B, GEN y, GEN *ptq);
2056
GEN     mpfact(long n);
2057
ulong   factorial_Fl(long n, ulong p);
2058
GEN     factorial_Fp(long n, GEN p);
2059
GEN     muls_interval(long a, long b);
2060
GEN     mulu_interval(ulong a, ulong b);
2061
GEN     mulu_interval_step(ulong a, ulong b, ulong step);
2062
GEN     ncV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2063
GEN     ncV_chinese_center_tree(GEN A, GEN P, GEN T, GEN R);
2064
GEN     nmV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2065
GEN     nmV_chinese_center_tree(GEN A, GEN P, GEN T, GEN R);
2066
ulong   nonsquare_Fl(ulong p);
2067
GEN     nxCV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2068
GEN     nxCV_chinese_center_tree(GEN A, GEN P, GEN T, GEN R);
2069
GEN     nxMV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2070
GEN     nxV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2071
GEN     nxV_chinese_center_tree(GEN A, GEN P, GEN T, GEN R);
2072
GEN     ZV_chinese_center(GEN A, GEN P, GEN *pt_mod);
2073
GEN     odd_prime_divisors(GEN q);
2074
GEN     order(GEN x);
2075
ulong   pgener_Fl(ulong p);
2076
ulong   pgener_Fl_local(ulong p, GEN L);
2077
GEN     pgener_Fp(GEN p);
2078
GEN     pgener_Fp_local(GEN p, GEN L);
2079
ulong   pgener_Zl(ulong p);
2080
GEN     pgener_Zp(GEN p);
2081
GEN     pnqn(GEN x);
2082
GEN     qfbclassno0(GEN x,long flag);
2083
GEN     quadclassno(GEN x);
2084
GEN     quaddisc(GEN x);
2085
GEN     quadregulator(GEN x, long prec);
2086
GEN     quadunit(GEN x);
2087
GEN     quadunit0(GEN x, long v);
2088
GEN     ramanujantau(GEN n, long ell);
2089
ulong   rootsof1_Fl(ulong n, ulong p);
2090
GEN     rootsof1_Fp(GEN n, GEN p);
2091
GEN     rootsof1u_Fp(ulong n, GEN p);
2092
long    sisfundamental(long x);
2093
GEN     sqrtint(GEN a);
2094
GEN     sqrtint0(GEN a, GEN *r);
2095
ulong   u_chinese_coprime(ulong a, ulong b, ulong A, ulong B, ulong C);
2096
long    uisprimepower(ulong n, ulong *p);
2097
long    uissquare(ulong A);
2098
long    uissquareall(ulong A, ulong *sqrtA);
2099
long    ulogintall(ulong B, ulong y, ulong *ptq);
2100
long    unegisfundamental(ulong x);
2101
long    uposisfundamental(ulong x);
2102
GEN     znlog(GEN x, GEN g, GEN o);
2103
GEN     znorder(GEN x, GEN o);
2104
GEN     znprimroot(GEN m);
2105
GEN     znstar(GEN x);
2106
GEN     znstar0(GEN N, long flag);
2107
GEN     Zn_quad_roots(GEN N, GEN B, GEN C);
2108

2109
/* arith2.c */
2110

2111
int     RgV_is_ZVpos(GEN v);
2112
int     RgV_is_ZVnon0(GEN v);
2113
GEN     Z_lsmoothen(GEN N, GEN L, GEN *pP, GEN *pe);
2114
GEN     Z_smoothen(GEN N, GEN L, GEN *pP, GEN *pe);
2115
GEN     boundfact(GEN n, ulong lim);
2116
GEN     check_arith_pos(GEN n, const char *f);
2117
GEN     check_arith_non0(GEN n, const char *f);
2118
GEN     check_arith_all(GEN n, const char *f);
2119
GEN     clean_Z_factor(GEN f);
2120
GEN     corepartial(GEN n, long l);
2121
GEN     core0(GEN n,long flag);
2122
GEN     core2(GEN n);
2123
GEN     core2partial(GEN n, long l);
2124
GEN     coredisc(GEN n);
2125
GEN     coredisc0(GEN n,long flag);
2126
GEN     coredisc2(GEN n);
2127
long    corediscs(long D, ulong *f);
2128
GEN     digits(GEN N, GEN B);
2129
GEN     divisors(GEN n);
2130
GEN     divisors_factored(GEN N);
2131
GEN     divisors0(GEN N, long flag);
2132
GEN     divisorsu(ulong n);
2133
GEN     divisorsu_moebius(GEN P);
2134
GEN     divisorsu_fact(GEN fa);
2135
GEN     divisorsu_fact_factored(GEN fa);
2136
GEN     factor_pn_1(GEN p, ulong n);
2137
GEN     factor_pn_1_limit(GEN p, long n, ulong lim);
2138
GEN     factoru_pow(ulong n);
2139
GEN     fromdigits(GEN x, GEN B);
2140
GEN     fromdigitsu(GEN x, GEN B);
2141
GEN     fuse_Z_factor(GEN f, GEN B);
2142
GEN     gen_digits(GEN x, GEN B, long n, void *E, struct bb_ring *r,
2143
                          GEN (*div)(void *E, GEN x, GEN y, GEN *r));
2144
GEN     gen_fromdigits(GEN x, GEN B, void *E, struct bb_ring *r);
2145
int     is_Z_factor(GEN f);
2146
int     is_Z_factornon0(GEN f);
2147
int     is_Z_factorpos(GEN f);
2148
int     is_nf_factor(GEN F);
2149
int     is_nf_extfactor(GEN F);
2150
GEN     sumdigits(GEN n);
2151
GEN     sumdigits0(GEN n, GEN B);
2152
ulong   sumdigitsu(ulong n);
2153
GEN     usumdiv_fact(GEN f);
2154
GEN     usumdivk_fact(GEN f, ulong k);
2155

2156
/* base1.c */
2157

2158
GEN     FpX_FpC_nfpoleval(GEN nf, GEN pol, GEN a, GEN p);
2159
GEN     embed_T2(GEN x, long r1);
2160
GEN     embednorm_T2(GEN x, long r1);
2161
GEN     embed_norm(GEN x, long r1);
2162
void    check_ZKmodule(GEN x, const char *s);
2163
void    checkbid(GEN bid);
2164
GEN     checkbid_i(GEN bid);
2165
GEN     checkbnf(GEN bnf);
2166
GEN     checkbnf_i(GEN bnf);
2167
void    checkbnr(GEN bnr);
2168
GEN     checkbnr_i(GEN bnr);
2169
void    checkabgrp(GEN v);
2170
void    checksqmat(GEN x, long N);
2171
GEN     checknf(GEN nf);
2172
GEN     checknf_i(GEN nf);
2173
GEN     checknfelt_mod(GEN nf, GEN x, const char *s);
2174
void    checkprid(GEN bid);
2175
int     checkprid_i(GEN x);
2176
void    checkrnf(GEN rnf);
2177
int     checkrnf_i(GEN rnf);
2178
GEN     factoredpolred(GEN x, GEN fa);
2179
GEN     factoredpolred2(GEN x, GEN fa);
2180
GEN     galoisapply(GEN nf, GEN aut, GEN x);
2181
GEN     get_bnf(GEN x, long *t);
2182
GEN     get_bnfpol(GEN x, GEN *bnf, GEN *nf);
2183
GEN     get_nf(GEN x, long *t);
2184
GEN     get_nfpol(GEN x, GEN *nf);
2185
GEN     get_prid(GEN x);
2186
GEN     idealfrobenius(GEN nf, GEN gal, GEN pr);
2187
GEN     idealfrobenius_aut(GEN nf, GEN gal, GEN pr, GEN aut);
2188
GEN     idealramfrobenius(GEN nf, GEN gal, GEN pr, GEN ram);
2189
GEN     idealramfrobenius_aut(GEN nf, GEN gal, GEN pr, GEN ram, GEN aut);
2190
GEN     idealramgroups(GEN nf, GEN gal, GEN pr);
2191
GEN     idealramgroups_aut(GEN nf, GEN gal, GEN pr, GEN aut);
2192
GEN     nf_get_allroots(GEN nf);
2193
long    nf_get_prec(GEN x);
2194
GEN     nfmaxord_to_nf(nfmaxord_t *T, GEN ro, long prec);
2195
GEN     nfcertify(GEN x);
2196
GEN     nfgaloismatrix(GEN nf, GEN s);
2197
GEN     nfgaloismatrixapply(GEN nf, GEN M, GEN x);
2198
GEN     nfgaloispermtobasis(GEN nf, GEN gal);
2199
void    nfinit_basic(nfmaxord_t *T, GEN x);
2200
GEN     nfinit_complete(nfmaxord_t *T, long flag, long prec);
2201
GEN     nfinit(GEN x, long prec);
2202
GEN     nfinit0(GEN x, long flag, long prec);
2203
GEN     nfinitall(GEN x, long flag, long prec);
2204
GEN     nfinitred(GEN x, long prec);
2205
GEN     nfinitred2(GEN x, long prec);
2206
GEN     nfisincl(GEN a, GEN b);
2207
GEN     nfisincl0(GEN fa, GEN fb, long flag);
2208
GEN     nfisisom(GEN a, GEN b);
2209
GEN     nfnewprec(GEN nf, long prec);
2210
GEN     nfnewprec_shallow(GEN nf, long prec);
2211
GEN     nfpoleval(GEN nf, GEN pol, GEN a);
2212
GEN     nfsplitting(GEN T, GEN D);
2213
GEN     nfsplitting_gp(GEN T, GEN D, long flag);
2214
GEN     nfsplitting0(GEN T, GEN D, long flag);
2215
long    nftyp(GEN x);
2216
GEN     polredord(GEN x);
2217
GEN     polred(GEN x);
2218
GEN     polred0(GEN x, long flag, GEN fa);
2219
GEN     polred2(GEN x);
2220
GEN     polredabs(GEN x);
2221
GEN     polredabs0(GEN x, long flag);
2222
GEN     polredabs2(GEN x);
2223
GEN     polredabsall(GEN x, long flun);
2224
GEN     polredbest(GEN x, long flag);
2225
GEN     rnfpolredabs(GEN nf, GEN pol, long flag);
2226
GEN     rnfpolredbest(GEN nf, GEN R, long flag);
2227
GEN     smallpolred(GEN x);
2228
GEN     smallpolred2(GEN x);
2229
GEN     tschirnhaus(GEN x);
2230
GEN     ZX_Q_mul(GEN A, GEN z);
2231
GEN     ZX_Q_normalize(GEN pol, GEN *ptlc);
2232
GEN     ZX_Z_normalize(GEN pol, GEN *ptk);
2233
GEN     ZX_to_monic(GEN pol, GEN *lead);
2234
GEN     ZX_primitive_to_monic(GEN pol, GEN *lead);
2235
GEN     ZXX_Q_mul(GEN A, GEN z);
2236

2237
/* base2.c */
2238

2239
GEN     Fq_to_nf(GEN x, GEN modpr);
2240
GEN     FqM_to_nfM(GEN z, GEN modpr);
2241
GEN     FqV_to_nfV(GEN z, GEN modpr);
2242
GEN     FqX_to_nfX(GEN x, GEN modpr);
2243
GEN     Rg_nffix(const char *f, GEN T, GEN c, int lift);
2244
GEN     RgV_nffix(const char *f, GEN T, GEN P, int lift);
2245
GEN     RgX_nffix(const char *s, GEN nf, GEN x, int lift);
2246
GEN     ZX_compositum_disjoint(GEN A, GEN B);
2247
GEN     ZX_compositum(GEN A, GEN B, long *lambda);
2248
long    ZpX_disc_val(GEN f, GEN p);
2249
GEN     ZpX_gcd(GEN f1,GEN f2,GEN p, GEN pm);
2250
GEN     ZpX_monic_factor(GEN f, GEN p, long prec);
2251
GEN     ZpX_primedec(GEN T, GEN p);
2252
GEN     ZpX_reduced_resultant(GEN x, GEN y, GEN p, GEN pm);
2253
GEN     ZpX_reduced_resultant_fast(GEN f, GEN g, GEN p, long M);
2254
long    ZpX_resultant_val(GEN f, GEN g, GEN p, long M);
2255
void    checkmodpr(GEN modpr);
2256
GEN     compositum(GEN P, GEN Q);
2257
GEN     compositum2(GEN P, GEN Q);
2258
GEN     nfdisc(GEN x);
2259
GEN     get_modpr(GEN x);
2260
GEN     indexpartial(GEN P, GEN DP);
2261
GEN     modpr_genFq(GEN modpr);
2262
GEN     nf_to_Fq_init(GEN nf, GEN *pr, GEN *T, GEN *p);
2263
GEN     nf_to_Fq(GEN nf, GEN x, GEN modpr);
2264
GEN     nfM_to_FqM(GEN z, GEN nf,GEN modpr);
2265
GEN     nfV_to_FqV(GEN z, GEN nf,GEN modpr);
2266
GEN     nfX_to_FqX(GEN x, GEN nf,GEN modpr);
2267
GEN     nfX_to_monic(GEN nf, GEN T, GEN *pL);
2268
GEN     nfbasis(GEN x, GEN *y);
2269
GEN     nfcompositum(GEN nf, GEN A, GEN B, long flag);
2270
GEN     nfdiscfactors(GEN x);
2271
void    nfmaxord(nfmaxord_t *S, GEN T, long flag);
2272
GEN     nfmodpr(GEN nf, GEN x, GEN pr);
2273
GEN     nfmodprinit(GEN nf, GEN pr);
2274
GEN     nfmodprinit0(GEN nf, GEN pr, long v);
2275
GEN     nfmodprlift(GEN nf, GEN x, GEN pr);
2276
GEN     nfreducemodpr(GEN nf, GEN x, GEN modpr);
2277
GEN     polcompositum0(GEN P, GEN Q,long flag);
2278
GEN     idealprimedec(GEN nf,GEN p);
2279
GEN     idealprimedec_galois(GEN nf, GEN p);
2280
GEN     idealprimedec_degrees(GEN nf, GEN p);
2281
GEN     idealprimedec_kummer(GEN nf,GEN pol,long e,GEN p);
2282
GEN     idealprimedec_limit_f(GEN nf, GEN p, long f);
2283
GEN     idealprimedec_limit_norm(GEN nf, GEN p, GEN B);
2284
GEN     poldiscfactors(GEN T, long flag);
2285
GEN     rnfbasis(GEN bnf, GEN order);
2286
GEN     rnfdedekind(GEN nf, GEN T, GEN pr, long flag);
2287
GEN     rnfdet(GEN nf, GEN order);
2288
GEN     rnfdisc_factored(GEN nf, GEN pol, GEN *pd);
2289
GEN     rnfdiscf(GEN nf, GEN pol);
2290
GEN     rnfequation(GEN nf, GEN pol);
2291
GEN     rnfequation0(GEN nf, GEN pol, long flall);
2292
GEN     rnfequation2(GEN nf, GEN pol);
2293
GEN     nf_pV_to_prV(GEN nf, GEN P);
2294
GEN     nf_rnfeq(GEN nf, GEN R);
2295
GEN     nf_rnfeqsimple(GEN nf, GEN R);
2296
GEN     rnfequationall(GEN A, GEN B, long *pk, GEN *pLPRS);
2297
GEN     rnfhnfbasis(GEN bnf, GEN order);
2298
long    rnfisfree(GEN bnf, GEN order);
2299
GEN     rnflllgram(GEN nf, GEN pol, GEN order,long prec);
2300
GEN     rnfpolred(GEN nf, GEN pol, long prec);
2301
GEN     rnfpseudobasis(GEN nf, GEN pol);
2302
GEN     rnfsimplifybasis(GEN bnf, GEN order);
2303
GEN     rnfsteinitz(GEN nf, GEN order);
2304
long    factorial_lval(ulong n, ulong p);
2305
GEN     zk_to_Fq_init(GEN nf, GEN *pr, GEN *T, GEN *p);
2306
GEN     zk_to_Fq(GEN x, GEN modpr);
2307
GEN     QXQV_to_FpM(GEN basis, GEN T, GEN p);
2308
GEN     zkmodprinit(GEN nf, GEN pr);
2309

2310
/* base3.c */
2311

2312
GEN     Idealstar(GEN nf, GEN x,long flun);
2313
GEN     Idealstarmod(GEN nf, GEN ideal, long flag, GEN MOD);
2314
GEN     Idealstarprk(GEN nf, GEN pr, long k, long flag);
2315
GEN     RgC_to_nfC(GEN nf,GEN x);
2316
GEN     RgM_RgX_mul(GEN A, GEN x);
2317
GEN     RgM_to_nfM(GEN nf,GEN x);
2318
GEN     RgX_to_nfX(GEN nf,GEN pol);
2319
long    ZC_nfval(GEN x, GEN P);
2320
long    ZC_nfvalrem(GEN x, GEN P, GEN *t);
2321
int     ZC_prdvd(GEN x, GEN P);
2322
GEN     ZM_ZX_mul(GEN A, GEN x);
2323
GEN     ZV_snf_gcd(GEN x, GEN mod);
2324
GEN     algtobasis(GEN nf, GEN x);
2325
GEN     basistoalg(GEN nf, GEN x);
2326
GEN     ei_multable(GEN nf, long i);
2327
const struct bb_field *get_nf_field(void **E, GEN nf);
2328
GEN     famat_nfvalrem(GEN nf, GEN x, GEN pr, GEN *py);
2329
GEN     gpnfvalrem(GEN nf, GEN x, GEN pr, GEN *py);
2330
GEN     ideallist(GEN nf,long bound);
2331
GEN     ideallist0(GEN nf,long bound, long flag);
2332
GEN     gideallist(GEN nf, GEN bound, long flag);
2333
GEN     ideallistarch(GEN nf, GEN list, GEN arch);
2334
GEN     ideallog(GEN nf,GEN x,GEN bid);
2335
GEN     ideallogmod(GEN nf,GEN x,GEN bid, GEN mod);
2336
GEN     ideallog_units(GEN bnf, GEN bid);
2337
GEN     ideallog_units0(GEN bnf, GEN bid, GEN MOD);
2338
GEN     idealprincipalunits(GEN nf, GEN pr, long e);
2339
GEN     idealstar0(GEN nf, GEN x,long flag);
2340
GEN     idealstarmod(GEN nf, GEN ideal, long flag, GEN MOD);
2341
GEN     indices_to_vec01(GEN archp, long r);
2342
GEN     matalgtobasis(GEN nf, GEN x);
2343
GEN     matbasistoalg(GEN nf, GEN x);
2344
GEN     multable(GEN nf, GEN x);
2345
GEN     nf_to_scalar_or_alg(GEN nf, GEN x);
2346
GEN     nf_to_scalar_or_basis(GEN nf, GEN x);
2347
GEN     nf_cxlog(GEN nf, GEN x, long prec);
2348
GEN     nfV_cxlog(GEN nf, GEN x, long prec);
2349
GEN     nfadd(GEN nf, GEN x, GEN y);
2350
int     nfchecksigns(GEN nf, GEN x, GEN pl);
2351
GEN     nfdiv(GEN nf, GEN x, GEN y);
2352
GEN     nfdiveuc(GEN nf, GEN a, GEN b);
2353
GEN     nfdivrem(GEN nf, GEN a, GEN b);
2354
GEN     nfembed(GEN nf, GEN x, long k);
2355
GEN     nfeltembed(GEN nf, GEN x, GEN ind0, long prec);
2356
GEN     nfeltsign(GEN nf, GEN x, GEN ind0);
2357
GEN     nfinv(GEN nf, GEN x);
2358
GEN     nfinvmodideal(GEN nf, GEN x, GEN ideal);
2359
GEN     nflogembed(GEN nf, GEN x, GEN *emb, long prec);
2360
GEN     nfM_det(GEN nf, GEN M);
2361
GEN     nfM_inv(GEN nf, GEN M);
2362
GEN     nfM_mul(GEN nf, GEN A, GEN B);
2363
GEN     nfM_nfC_mul(GEN nf, GEN A, GEN B);
2364
GEN     nfmod(GEN nf, GEN a, GEN b);
2365
GEN     nfmul(GEN nf,GEN x,GEN y);
2366
GEN     nfmuli(GEN nf,GEN x,GEN y);
2367
GEN     nfnorm(GEN nf, GEN x);
2368
GEN     nfpolsturm(GEN nf, GEN f, GEN ind0);
2369
GEN     nfpow(GEN nf,GEN x,GEN k);
2370
GEN     nfpow_u(GEN nf, GEN z, ulong n);
2371
GEN     nfpowmodideal(GEN nf,GEN x,GEN k,GEN ideal);
2372
GEN     nfsign(GEN nf,GEN alpha);
2373
GEN     nfsign_arch(GEN nf,GEN alpha,GEN arch);
2374
GEN     nfsign_from_logarch(GEN Larch, GEN invpi, GEN archp);
2375
GEN     nfsqr(GEN nf,GEN x);
2376
GEN     nfsqri(GEN nf, GEN x);
2377
GEN     nfsub(GEN nf, GEN x, GEN y);
2378
GEN     nftrace(GEN nf, GEN x);
2379
long    nfval(GEN nf, GEN x, GEN vp);
2380
long    nfvalrem(GEN nf, GEN x, GEN pr, GEN *py);
2381
GEN     polmod_nffix(const char *f, GEN rnf, GEN x,int lift);
2382
GEN     polmod_nffix2(const char *f, GEN T, GEN R, GEN x, int lift);
2383
GEN     pr_basis_perm(GEN nf, GEN pr);
2384
int     pr_equal(GEN P, GEN Q);
2385
GEN     rnfalgtobasis(GEN rnf, GEN x);
2386
GEN     rnfbasistoalg(GEN rnf, GEN x);
2387
GEN     rnfeltnorm(GEN rnf, GEN x);
2388
GEN     rnfelttrace(GEN rnf, GEN x);
2389
GEN     set_sign_mod_divisor(GEN nf, GEN x, GEN y, GEN sarch);
2390
GEN     tablemul(GEN TAB, GEN x, GEN y);
2391
GEN     tablemul_ei(GEN M, GEN x, long i);
2392
GEN     tablemul_ei_ej(GEN M, long i, long j);
2393
GEN     tablemulvec(GEN M, GEN x, GEN v);
2394
GEN     tablesqr(GEN tab, GEN x);
2395
GEN     vec01_to_indices(GEN arch);
2396
GEN     vecmodii(GEN a, GEN b);
2397
GEN     vecmoduu(GEN a, GEN b);
2398
GEN     vecsmall01_to_indices(GEN v);
2399
GEN     zk_inv(GEN nf, GEN x);
2400
GEN     zk_multable(GEN nf, GEN x);
2401
GEN     zk_scalar_or_multable(GEN, GEN x);
2402
GEN     zkchinese(GEN zkc, GEN x, GEN y);
2403
GEN     zkchinese1(GEN zkc, GEN x);
2404
GEN     zkchineseinit(GEN nf, GEN A, GEN B, GEN AB);
2405
GEN     zkmultable_capZ(GEN mx);
2406
GEN     zkmultable_inv(GEN mx);
2407

2408
/* base4.c */
2409

2410
ulong   Fl_invgen(ulong x, ulong p, ulong *pg);
2411
GEN     Z_cba(GEN a, GEN b);
2412
GEN     Z_ppgle(GEN a, GEN b);
2413
GEN     Z_ppio(GEN a, GEN b);
2414
GEN     Z_ppo(GEN x, GEN f);
2415
GEN     ZV_cba_extend(GEN P, GEN b);
2416
GEN     ZV_cba(GEN v);
2417
GEN     RM_round_maxrank(GEN G);
2418
GEN     ZM_famat_limit(GEN fa, GEN limit);
2419
GEN     famat_Z_gcd(GEN M, GEN n);
2420
GEN     famat_div_shallow(GEN f, GEN g);
2421
GEN     famat_div(GEN f, GEN g);
2422
GEN     famat_idealfactor(GEN nf, GEN x);
2423
GEN     famat_inv(GEN f);
2424
GEN     famat_inv_shallow(GEN f);
2425
GEN     famat_makecoprime(GEN nf, GEN g, GEN e, GEN pr, GEN prk, GEN EX);
2426
GEN     famat_mul(GEN f, GEN g);
2427
GEN     famat_mul_shallow(GEN f, GEN g);
2428
GEN     famat_mulpow_shallow(GEN f, GEN g, GEN e);
2429
GEN     famat_mulpows_shallow(GEN f, GEN g, long e);
2430
GEN     famat_pow(GEN f, GEN n);
2431
GEN     famat_pow_shallow(GEN f, GEN n);
2432
GEN     famat_pows_shallow(GEN f, long n);
2433
GEN     famat_sqr(GEN f);
2434
GEN     famat_reduce(GEN fa);
2435
GEN     famat_remove_trivial(GEN fa);
2436
GEN     famat_to_nf(GEN nf, GEN f);
2437
GEN     famat_to_nf_modideal_coprime(GEN nf, GEN g, GEN e, GEN id, GEN EX);
2438
GEN     famat_to_nf_moddivisor(GEN nf, GEN g, GEN e, GEN bid);
2439
GEN     famatV_factorback(GEN v, GEN e);
2440
GEN     famatV_zv_factorback(GEN v, GEN e);
2441
GEN     famatsmall_reduce(GEN fa);
2442
GEN     gpidealval(GEN nf, GEN ix, GEN P);
2443
GEN     gpidealfactor(GEN nf, GEN x, GEN lim);
2444
GEN     idealHNF_Z_factor(GEN x, GEN *pvN, GEN *pvZ);
2445
GEN     idealHNF_Z_factor_i(GEN x, GEN f, GEN *pvN, GEN *pvZ);
2446
GEN     idealtwoelt(GEN nf, GEN ix);
2447
GEN     idealtwoelt0(GEN nf, GEN ix, GEN a);
2448
GEN     idealtwoelt2(GEN nf, GEN x, GEN a);
2449
GEN     idealadd(GEN nf, GEN x, GEN y);
2450
GEN     idealaddmultoone(GEN nf, GEN list);
2451
GEN     idealaddtoone(GEN nf, GEN x, GEN y);
2452
GEN     idealaddtoone_i(GEN nf, GEN x, GEN y);
2453
GEN     idealaddtoone_raw(GEN nf, GEN x, GEN y);
2454
GEN     idealaddtoone0(GEN nf, GEN x, GEN y);
2455
GEN     idealappr(GEN nf, GEN x);
2456
GEN     idealappr0(GEN nf, GEN x, long fl);
2457
GEN     idealapprfact(GEN nf, GEN x);
2458
GEN     idealchinese(GEN nf, GEN x, GEN y);
2459
GEN     idealcoprime(GEN nf, GEN x, GEN y);
2460
GEN     idealcoprimefact(GEN nf, GEN x, GEN fy);
2461
GEN     idealdiv(GEN nf, GEN x, GEN y);
2462
GEN     idealdiv0(GEN nf, GEN x, GEN y,long flag);
2463
GEN     idealdivexact(GEN nf, GEN x, GEN y);
2464
GEN     idealdivpowprime(GEN nf, GEN x, GEN vp, GEN n);
2465
GEN     idealdown(GEN nf, GEN x);
2466
GEN     idealismaximal(GEN nf, GEN x);
2467
GEN     idealmulpowprime(GEN nf, GEN x, GEN vp, GEN n);
2468
GEN     idealfactor(GEN nf, GEN x);
2469
GEN     idealfactor_limit(GEN nf, GEN x, ulong lim);
2470
GEN     idealfactor_partial(GEN nf, GEN x, GEN L);
2471
GEN     idealhnf(GEN nf, GEN x);
2472
GEN     idealhnf_principal(GEN nf, GEN x);
2473
GEN     idealhnf_shallow(GEN nf, GEN x);
2474
GEN     idealhnf_two(GEN nf, GEN vp);
2475
GEN     idealhnf0(GEN nf, GEN a, GEN b);
2476
GEN     idealintersect(GEN nf, GEN x, GEN y);
2477
GEN     idealinv(GEN nf, GEN ix);
2478
GEN     idealHNF_inv(GEN nf, GEN I);
2479
GEN     idealHNF_inv_Z(GEN nf, GEN I);
2480
long    idealispower(GEN nf, GEN A, long n, GEN *pB);
2481
GEN     idealred0(GEN nf, GEN I,GEN vdir);
2482
GEN     idealmul(GEN nf, GEN ix, GEN iy);
2483
GEN     idealmul0(GEN nf, GEN ix, GEN iy, long flag);
2484
GEN     idealHNF_mul(GEN nf, GEN ix, GEN iy);
2485
GEN     idealmulred(GEN nf, GEN ix, GEN iy);
2486
GEN     idealnorm(GEN nf, GEN x);
2487
GEN     idealnumden(GEN nf, GEN x);
2488
GEN     idealpow(GEN nf, GEN ix, GEN n);
2489
GEN     idealpow0(GEN nf, GEN ix, GEN n, long flag);
2490
GEN     idealpowred(GEN nf, GEN ix, GEN n);
2491
GEN     idealpows(GEN nf, GEN ideal, long iexp);
2492
long    idealprodval(GEN nf, GEN I, GEN pr);
2493
GEN     idealprodprime(GEN nf, GEN L);
2494
GEN     idealsqr(GEN nf, GEN x);
2495
long    idealtyp(GEN *ideal, GEN *arch);
2496
long    idealval(GEN nf,GEN ix,GEN vp);
2497
GEN     idealprod(GEN nf, GEN I);
2498
long    isideal(GEN nf,GEN x);
2499
GEN     idealmin(GEN nf,GEN ix,GEN vdir);
2500
GEN     matreduce(GEN fa);
2501
GEN     nf_get_Gtwist(GEN nf, GEN vdir);
2502
GEN     nf_get_Gtwist1(GEN nf, long i);
2503
GEN     nf_to_Fp_coprime(GEN nf, GEN x, GEN modpr);
2504
GEN     nfC_multable_mul(GEN v, GEN x);
2505
GEN     nfC_nf_mul(GEN nf, GEN v, GEN x);
2506
GEN     nfdetint(GEN nf,GEN pseudo);
2507
GEN     nfdivmodpr(GEN nf, GEN x, GEN y, GEN modpr);
2508
GEN     idealredmodpower(GEN nf, GEN x, ulong k, ulong B);
2509
GEN     nfhnf(GEN nf, GEN x);
2510
GEN     nfhnf0(GEN nf, GEN x, long flag);
2511
GEN     nfhnfmod(GEN nf, GEN x, GEN d);
2512
GEN     nfkermodpr(GEN nf, GEN x, GEN modpr);
2513
GEN     nfmulmodpr(GEN nf, GEN x, GEN y, GEN modpr);
2514
GEN     nfpowmodpr(GEN nf, GEN x, GEN k, GEN modpr);
2515
GEN     nfreduce(GEN nf, GEN x, GEN ideal);
2516
GEN     nfsnf(GEN nf, GEN x);
2517
GEN     nfsnf0(GEN nf, GEN x, long flag);
2518
GEN     nfsolvemodpr(GEN nf, GEN a, GEN b, GEN modpr);
2519
GEN     pr_hnf(GEN nf, GEN pr);
2520
GEN     pr_inv(GEN pr);
2521
GEN     pr_inv_p(GEN pr);
2522
GEN     pr_uniformizer(GEN pr, GEN F);
2523
GEN     prV_lcm_capZ(GEN L);
2524
GEN     sunits_makecoprime(GEN X, GEN pr, GEN prk);
2525
GEN     to_famat(GEN x, GEN y);
2526
GEN     to_famat_shallow(GEN x, GEN y);
2527
ulong   u_ppo(ulong x, ulong f);
2528
GEN     vecdiv(GEN x, GEN y);
2529
GEN     vecinv(GEN x);
2530
GEN     vecmul(GEN x, GEN y);
2531
GEN     vecpow(GEN x, GEN n);
2532
GEN     zkC_multable_mul(GEN v, GEN x);
2533

2534
/* base5.c */
2535

2536
GEN     eltreltoabs(GEN rnfeq, GEN x);
2537
GEN     eltabstorel(GEN eq, GEN P);
2538
GEN     eltabstorel_lift(GEN rnfeq, GEN P);
2539
GEN     nf_nfzk(GEN nf, GEN rnfeq);
2540
GEN     rnf_build_nfabs(GEN rnf, long prec);
2541
GEN     rnf_zkabs(GEN rnf);
2542
GEN     nfeltup(GEN nf, GEN x, GEN zknf);
2543
void    rnfcomplete(GEN rnf);
2544
GEN     rnfeltabstorel(GEN rnf, GEN x);
2545
GEN     rnfeltdown(GEN rnf, GEN x);
2546
GEN     rnfeltdown0(GEN rnf, GEN x, long flag);
2547
GEN     rnfeltreltoabs(GEN rnf, GEN x);
2548
GEN     rnfeltup(GEN rnf, GEN x);
2549
GEN     rnfeltup0(GEN rnf, GEN x, long flag);
2550
GEN     rnfidealabstorel(GEN rnf, GEN x);
2551
GEN     rnfidealdown(GEN rnf, GEN x);
2552
GEN     rnfidealfactor(GEN rnf, GEN x);
2553
GEN     rnfidealhnf(GEN rnf, GEN x);
2554
GEN     rnfidealmul(GEN rnf,GEN x,GEN y);
2555
GEN     rnfidealnormabs(GEN rnf, GEN x);
2556
GEN     rnfidealnormrel(GEN rnf, GEN x);
2557
GEN     rnfidealprimedec(GEN rnf, GEN pr);
2558
GEN     rnfidealreltoabs(GEN rnf, GEN x);
2559
GEN     rnfidealreltoabs0(GEN rnf, GEN x, long flag);
2560
GEN     rnfidealtwoelement(GEN rnf,GEN x);
2561
GEN     rnfidealup(GEN rnf, GEN x);
2562
GEN     rnfidealup0(GEN rnf,GEN x, long flag);
2563
GEN     rnfinit(GEN nf,GEN pol);
2564
GEN     rnfinit0(GEN nf,GEN pol,long flag);
2565

2566
/* bb_group.c */
2567

2568
GEN get_arith_ZZM(GEN o);
2569
GEN get_arith_Z(GEN o);
2570
GEN gen_PH_log(GEN a, GEN g, GEN ord, void *E, const struct bb_group *grp);
2571
GEN gen_Shanks_init(GEN g, long n, void *E, const struct bb_group *grp);
2572
GEN gen_Shanks(GEN T, GEN x, ulong N, void *E, const struct bb_group *grp);
2573
GEN gen_Shanks_sqrtn(GEN a, GEN n, GEN q, GEN *zetan, void *E, const struct bb_group *grp);
2574
GEN gen_gener(GEN o, void *E, const struct bb_group *grp);
2575
GEN gen_ellgens(GEN d1, GEN d2, GEN m, void *E, const struct bb_group *grp,
2576
                 GEN pairorder(void *E, GEN P, GEN Q, GEN m, GEN F));
2577
GEN gen_ellgroup(GEN N, GEN F, GEN *pt_m, void *E, const struct bb_group *grp,
2578
                 GEN pairorder(void *E, GEN P, GEN Q, GEN m, GEN F));
2579
GEN gen_factored_order(GEN a, GEN o, void *E, const struct bb_group *grp);
2580
GEN gen_order(GEN x, GEN o, void *E, const struct bb_group *grp);
2581
GEN gen_select_order(GEN o, void *E, const struct bb_group *grp);
2582

2583
GEN gen_plog(GEN x,GEN g0,GEN q, void *E, const struct bb_group *grp);
2584
GEN gen_pow(GEN x, GEN n, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN));
2585
GEN gen_pow_fold(GEN x, GEN n, void *E, GEN (*sqr)(void*,GEN), GEN (*msqr)(void*,GEN));
2586
GEN gen_pow_fold_i(GEN x, GEN n, void *E, GEN (*sqr)(void*,GEN), GEN (*msqr)(void*,GEN));
2587
GEN gen_pow_i(GEN x, GEN n, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN));
2588
GEN gen_pow_init(GEN x, GEN n, long k, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN));
2589
GEN gen_pow_table(GEN R, GEN n, void *E, GEN (*one)(void*), GEN (*mul)(void*,GEN,GEN));
2590
GEN gen_powers(GEN x, long l, int use_sqr, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN), GEN (*one)(void*));
2591
GEN gen_powu(GEN x, ulong n, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN));
2592
GEN gen_powu_fold(GEN x, ulong n, void *E, GEN (*sqr)(void*,GEN), GEN (*msqr)(void*,GEN));
2593
GEN gen_powu_fold_i(GEN x, ulong n, void *E, GEN  (*sqr)(void*,GEN), GEN (*msqr)(void*,GEN));
2594
GEN gen_powu_i(GEN x, ulong n, void *E, GEN (*sqr)(void*,GEN), GEN (*mul)(void*,GEN,GEN));
2595
GEN gen_product(GEN x, void *data, GEN (*mul)(void*,GEN,GEN));
2596

2597
/* bb_hnf.c */
2598

2599
GEN     matdetmod(GEN A, GEN d);
2600
GEN     matimagemod(GEN A, GEN d, GEN* U);
2601
GEN     matinvmod(GEN A, GEN d);
2602
GEN     matkermod(GEN A, GEN d, GEN* im);
2603
GEN     matsolvemod(GEN M, GEN D, GEN Y, long flag);
2604

2605
/* bern.c */
2606

2607
GEN     bernfrac(long n);
2608
GEN     bernpol(long k, long v);
2609
GEN     bernreal(long n, long prec);
2610
GEN     bernvec(long nomb);
2611
void    constbern(long n);
2612
GEN     eulerfrac(long k);
2613
GEN     eulerpol(long k, long v);
2614
GEN     eulerreal(long n, long prec);
2615
GEN     eulervec(long n);
2616

2617
/* bibli1.c */
2618

2619
int     QR_init(GEN x, GEN *pB, GEN *pQ, GEN *pL, long prec);
2620
GEN     R_from_QR(GEN x, long prec);
2621
GEN     RgM_Babai(GEN B, GEN t);
2622
int     RgM_QR_init(GEN x, GEN *pB, GEN *pQ, GEN *pL, long prec);
2623
GEN     RgM_gram_schmidt(GEN e, GEN *ptB);
2624
GEN     algdep(GEN x, long n);
2625
GEN     algdep0(GEN x, long n, long bit);
2626
GEN     bestapprnf(GEN x, GEN T, GEN rootsT, long prec);
2627
void    forqfvec(void *E, long (*fun)(void *, GEN, GEN, double), GEN a, GEN BORNE);
2628
void    forqfvec0(GEN a, GEN BORNE, GEN code);
2629
void    forqfvec1(void *E, long (*fun)(void *, GEN), GEN a, GEN BORNE);
2630
GEN     gaussred_from_QR(GEN x, long prec);
2631
GEN     lindep(GEN x);
2632
GEN     lindep_Xadic(GEN x);
2633
GEN     lindep_bit(GEN x, long bit);
2634
GEN     lindep_padic(GEN x);
2635
GEN     lindep0(GEN x, long flag);
2636
GEN     lindep2(GEN x, long bit);
2637
GEN     lindepfull_bit(GEN x, long bit);
2638
GEN     mathouseholder(GEN Q, GEN v);
2639
GEN     matqr(GEN x, long flag, long prec);
2640
GEN     minim(GEN a, GEN borne, GEN stockmax);
2641
GEN     minim_raw(GEN a, GEN borne, GEN stockmax);
2642
GEN     minim_zm(GEN a, GEN borne, GEN stockmax);
2643
GEN     minim2(GEN a, GEN borne, GEN stockmax);
2644
GEN     qfminim0(GEN a, GEN borne, GEN stockmax,long flag, long prec);
2645
GEN     qfperfection(GEN a);
2646
GEN     qfrep0(GEN a, GEN borne, long flag);
2647
GEN     seralgdep(GEN s, long p, long r);
2648
GEN     vandermondeinverse(GEN L, GEN T, GEN den, GEN prep);
2649
GEN     vandermondeinverseinit(GEN L);
2650
GEN     zncoppersmith(GEN P0, GEN N, GEN X, GEN B);
2651

2652
/* bibli2.c */
2653

2654
GEN     QXQ_reverse(GEN a, GEN T);
2655
GEN     vec_equiv(GEN F);
2656
GEN     RgV_polint(GEN X, GEN Y, long v);
2657
GEN     vec_reduce(GEN v, GEN *pE);
2658
GEN     RgXQ_reverse(GEN a, GEN T);
2659
GEN     ZC_union_shallow(GEN x, GEN y);
2660
GEN     ZV_indexsort(GEN L);
2661
long    ZV_search(GEN x, GEN y);
2662
GEN     ZV_sort(GEN L);
2663
void    ZV_sort_inplace(GEN L);
2664
GEN     ZV_sort_uniq(GEN L);
2665
GEN     ZV_union_shallow(GEN x, GEN y);
2666
GEN     binomial(GEN x, long k);
2667
GEN     binomial0(GEN x, GEN k);
2668
GEN     binomialuu(ulong n, ulong k);
2669
int     cmp_Flx(GEN x, GEN y);
2670
int     cmp_RgX(GEN x, GEN y);
2671
int     cmp_nodata(void *data, GEN x, GEN y);
2672
int     cmp_prime_ideal(GEN x, GEN y);
2673
int     cmp_prime_over_p(GEN x, GEN y);
2674
int     cmp_universal(GEN x, GEN y);
2675
GEN     convol(GEN x, GEN y);
2676
int     gen_cmp_RgX(void *data, GEN x, GEN y);
2677
GEN     polcyclo(long n, long v);
2678
GEN     polcyclo_eval(long n, GEN x);
2679
GEN     dirdiv(GEN x, GEN y);
2680
GEN     dirmul(GEN x, GEN y);
2681
GEN     eulerianpol(long N, long v);
2682
GEN     gprec_wensure(GEN x, long pr);
2683
GEN     gen_indexsort(GEN x, void *E, int (*cmp)(void*,GEN,GEN));
2684
GEN     gen_indexsort_uniq(GEN x, void *E, int (*cmp)(void*,GEN,GEN));
2685
long    gen_search(GEN x, GEN y, void *data, int (*cmp)(void*,GEN,GEN));
2686
GEN     gen_setminus(GEN set1, GEN set2, int (*cmp)(GEN,GEN));
2687
GEN     gen_sort(GEN x, void *E, int (*cmp)(void*,GEN,GEN));
2688
void    gen_sort_inplace(GEN x, void *E, int (*cmp)(void*,GEN,GEN), GEN *perm);
2689
GEN     gen_sort_shallow(GEN x, void *E, int (*cmp)(void*,GEN,GEN));
2690
GEN     gen_sort_uniq(GEN x, void *E, int (*cmp)(void*,GEN,GEN));
2691
long    getstack(void);
2692
long    gettime(void);
2693
long    getabstime(void);
2694
GEN     getwalltime(void);
2695
GEN     gprec(GEN x, long l);
2696
GEN     gprec_wtrunc(GEN x, long pr);
2697
GEN     gprec_w(GEN x, long pr);
2698
GEN     gtoset(GEN x);
2699
GEN     indexlexsort(GEN x);
2700
GEN     indexsort(GEN x);
2701
GEN     indexvecsort(GEN x, GEN k);
2702
GEN     laplace(GEN x);
2703
GEN     lexsort(GEN x);
2704
GEN     mathilbert(long n);
2705
GEN     matqpascal(long n, GEN q);
2706
GEN     merge_factor(GEN fx, GEN fy, void *data, int (*cmp)(void *,GEN,GEN));
2707
GEN     merge_sort_uniq(GEN x, GEN y, void *data, int (*cmp)(void *,GEN,GEN));
2708
GEN     modreverse(GEN x);
2709
GEN     polhermite(long n, long v);
2710
GEN     polhermite_eval0(long n, GEN x, long flag);
2711
GEN     polhermite_eval(long n, GEN x);
2712
GEN     pollaguerre(long n, GEN a, long v);
2713
GEN     pollaguerre_eval(long n, GEN a, GEN x);
2714
GEN     pollaguerre_eval0(long n, GEN a, GEN x, long flag);
2715
GEN     pollegendre(long n, long v);
2716
GEN     pollegendre_reduced(long n, long v);
2717
GEN     pollegendre_eval(long n, GEN x);
2718
GEN     pollegendre_eval0(long n, GEN x, long flag);
2719
GEN     polint(GEN xa, GEN ya, GEN x, GEN *pe);
2720
GEN     polint_i(GEN X, GEN Y, GEN t, long *pe);
2721
GEN     polintspec(GEN xa, GEN ya, GEN x, long n, long *pe);
2722
GEN     polchebyshev(long n, long kind, long v);
2723
GEN     polchebyshev_eval(long n, long kind, GEN x);
2724
GEN     polchebyshev1(long n, long v);
2725
GEN     polchebyshev2(long n, long v);
2726
GEN     polrecip(GEN x);
2727
GEN     setbinop(GEN f, GEN x, GEN y);
2728
GEN     setintersect(GEN x, GEN y);
2729
long    setisset(GEN x);
2730
GEN     setminus(GEN x, GEN y);
2731
long    setsearch(GEN x, GEN y, long flag);
2732
GEN     setunion(GEN x, GEN y);
2733
GEN     setunion_i(GEN x, GEN y);
2734
GEN     sort(GEN x);
2735
GEN     sort_factor(GEN y, void *data, int (*cmp)(void*,GEN,GEN));
2736
GEN     stirling(long n, long m, long flag);
2737
GEN     stirling1(ulong n, ulong m);
2738
GEN     stirling2(ulong n, ulong m);
2739
long    tablesearch(GEN T, GEN x, int (*cmp)(GEN,GEN));
2740
GEN     vecbinomial(long n);
2741
long    vecsearch(GEN v, GEN x, GEN k);
2742
GEN     vecsort(GEN x, GEN k);
2743
GEN     vecsort0(GEN x, GEN k, long flag);
2744
long    zv_search(GEN x, long y);
2745

2746
/* bit.c */
2747

2748
GEN     bits_to_int(GEN x, long l);
2749
ulong   bits_to_u(GEN v, long l);
2750
GEN     binaire(GEN x);
2751
GEN     binary_2k(GEN x, long k);
2752
GEN     binary_2k_nv(GEN x, long k);
2753
GEN     binary_zv(GEN x);
2754
long    bittest(GEN x, long n);
2755
GEN     fromdigits_2k(GEN x, long k);
2756
GEN     gbitand(GEN x, GEN y);
2757
GEN     gbitneg(GEN x, long n);
2758
GEN     gbitnegimply(GEN x, GEN y);
2759
GEN     gbitor(GEN x, GEN y);
2760
GEN     gbittest(GEN x, long n);
2761
GEN     gbitxor(GEN x, GEN y);
2762
long    hammingl(ulong w);
2763
long    hammingweight(GEN n);
2764
GEN     ibitand(GEN x, GEN y);
2765
GEN     ibitnegimply(GEN x, GEN y);
2766
GEN     ibitor(GEN x, GEN y);
2767
GEN     ibitxor(GEN x, GEN y);
2768
GEN     nv_fromdigits_2k(GEN x, long k);
2769

2770
/* bnflog.c */
2771
GEN bnflogef(GEN bnf, GEN pr);
2772
GEN bnflog(GEN bnf, GEN l);
2773
GEN bnflogdegree(GEN bnf, GEN A, GEN ell);
2774
long nfislocalpower(GEN nf, GEN pr, GEN a, GEN n);
2775
long rnfislocalcyclo(GEN rnf);
2776

2777
/* bnfunits.c */
2778

2779
GEN     bnfisunit(GEN bnf, GEN x);
2780
GEN     bnfissunit(GEN bnf,GEN suni,GEN x);
2781
GEN     bnfsunit(GEN bnf,GEN s,long PREC);
2782
GEN     bnfunits(GEN bnf, GEN S);
2783
GEN     bnfisunit0(GEN bnf, GEN x, GEN U);
2784
GEN     sunits_mod_units(GEN bnf, GEN S);
2785

2786
/* buch1.c */
2787

2788
GEN     Buchquad(GEN D, double c1, double c2, long prec);
2789
GEN     quadclassunit0(GEN x, long flag,GEN data, long prec);
2790
GEN     quadhilbert(GEN D, long prec);
2791
GEN     quadray(GEN bnf, GEN f, long prec);
2792

2793
/* buch2.c */
2794

2795
GEN     Buchall(GEN P, long flag, long prec);
2796
GEN     Buchall_param(GEN P, double bach, double bach2, long nbrelpid, long flun, long prec);
2797
GEN     bnf_build_cheapfu(GEN bnf);
2798
GEN     bnf_build_cycgen(GEN bnf);
2799
GEN     bnf_build_matalpha(GEN bnf);
2800
GEN     bnf_build_units(GEN bnf);
2801
GEN     bnf_compactfu(GEN bnf);
2802
GEN     bnf_compactfu_mat(GEN bnf);
2803
GEN     bnf_has_fu(GEN bnf);
2804
GEN     bnfinit0(GEN P,long flag,GEN data,long prec);
2805
GEN     bnfisprincipal0(GEN bnf, GEN x,long flall);
2806
GEN     bnfnewprec(GEN nf, long prec);
2807
GEN     bnfnewprec_shallow(GEN nf, long prec);
2808
void    bnftestprimes(GEN bnf, GEN bound);
2809
GEN     bnrnewprec(GEN bnr, long prec);
2810
GEN     bnrnewprec_shallow(GEN bnr, long prec);
2811
GEN     isprincipalfact(GEN bnf, GEN C, GEN L, GEN f, long flag);
2812
GEN     isprincipalfact_or_fail(GEN bnf, GEN C, GEN P, GEN e);
2813
GEN     isprincipal(GEN bnf, GEN x);
2814
GEN     nf_cxlog_normalize(GEN nf, GEN x, long prec);
2815
GEN     nfcyclotomicunits(GEN nf, GEN zu);
2816
GEN     nfsign_units(GEN bnf, GEN archp, int add_zu);
2817
GEN     nfsign_tu(GEN bnf, GEN archp);
2818
GEN     nfsign_fu(GEN bnf, GEN archp);
2819
GEN     signunits(GEN bnf);
2820

2821
/* buch3.c */
2822

2823
GEN     Hermite_bound(long n, long prec);
2824
void    bnr_subgroup_sanitize(GEN *pbnr, GEN *pH);
2825
void    bnr_char_sanitize(GEN *pbnr, GEN *pchi);
2826
GEN     ABC_to_bnr(GEN A, GEN B, GEN C, GEN *H, int gen);
2827
GEN     Buchray(GEN bnf, GEN module, long flag);
2828
GEN     Buchraymod(GEN bnf, GEN f, long flag, GEN MOD);
2829
GEN     bnrautmatrix(GEN bnr, GEN aut);
2830
GEN     bnr_subgroup_check(GEN bnr, GEN H, GEN *pdeg);
2831
GEN     bnrchar(GEN bnr, GEN g, GEN v);
2832
GEN     bnrchar_primitive(GEN bnr, GEN chi, GEN bnrc);
2833
GEN     bnrclassno(GEN bnf,GEN ideal);
2834
GEN     bnrclassno0(GEN A,GEN B,GEN C);
2835
GEN     bnrclassnolist(GEN bnf,GEN listes);
2836
GEN     bnrchar_primitive_raw(GEN bnr, GEN bnrc, GEN chi);
2837
GEN     bnrconductor_factored(GEN bnr, GEN H);
2838
GEN     bnrconductor_raw(GEN bnr, GEN H);
2839
GEN     bnrconductormod(GEN bnr, GEN H0, GEN MOD);
2840
GEN     bnrconductor0(GEN A, GEN B, GEN C, long flag);
2841
GEN     bnrconductor(GEN bnr, GEN H0, long flag);
2842
GEN     bnrconductor_i(GEN bnr, GEN H0, long flag);
2843
GEN     bnrconductorofchar(GEN bnr,GEN chi);
2844
GEN     bnrdisc0(GEN A, GEN B, GEN C, long flag);
2845
GEN     bnrdisc(GEN bnr, GEN H, long flag);
2846
GEN     bnrdisclist0(GEN bnf,GEN borne, GEN arch);
2847
GEN     bnrgaloismatrix(GEN bnr, GEN aut);
2848
GEN     bnrgaloisapply(GEN bnr, GEN mat, GEN x);
2849
GEN     bnrinit0(GEN bnf,GEN ideal,long flag);
2850
GEN     bnrinitmod(GEN bnf, GEN ideal, long flag, GEN MOD);
2851
long    bnrisconductor0(GEN A, GEN B, GEN C);
2852
long    bnrisconductor(GEN bnr, GEN H);
2853
long    bnrisgalois(GEN bnr, GEN M, GEN H);
2854
GEN     bnrisprincipalmod(GEN bnf, GEN x, GEN mod, long flag);
2855
GEN     bnrisprincipal(GEN bnf, GEN x,long flag);
2856
GEN     bnrmap(GEN A, GEN B);
2857
GEN     bnrsurjection(GEN bnr1, GEN bnr2);
2858
GEN     bnfnarrow(GEN bnf);
2859
long    bnfcertify(GEN bnf);
2860
long    bnfcertify0(GEN bnf, long flag);
2861
GEN     decodemodule(GEN nf, GEN fa);
2862
GEN     discrayabslist(GEN bnf,GEN listes);
2863
GEN     discrayabslistarch(GEN bnf, GEN arch, ulong bound);
2864
GEN     idealmoddivisor(GEN bnr, GEN x);
2865
GEN     isprincipalray(GEN bnf, GEN x);
2866
GEN     isprincipalraygen(GEN bnf, GEN x);
2867
GEN     nf_deg1_prime(GEN nf);
2868
GEN     nfarchstar(GEN nf,GEN x,GEN arch);
2869
GEN     rnfconductor(GEN bnf, GEN polrel);
2870
GEN     rnfconductor0(GEN bnf, GEN T, long flag);
2871
long    rnfisabelian(GEN nf, GEN pol);
2872
GEN     rnfnormgroup(GEN bnr, GEN polrel);
2873
GEN     subgrouplist0(GEN bnr, GEN indexbound, long all);
2874

2875
/* buch4.c */
2876

2877
GEN     bnfisnorm(GEN bnf,GEN x,long flag);
2878
GEN     rnfisnorm(GEN S, GEN x, long flag);
2879
GEN     rnfisnorminit(GEN bnf, GEN R, int galois);
2880

2881
/* char.c */
2882

2883
GEN     coprimes_zv(ulong N);
2884
int     char_check(GEN cyc, GEN chi);
2885
GEN     charconj(GEN cyc, GEN chi);
2886
GEN     charconj0(GEN cyc, GEN chi);
2887
GEN     chardiv(GEN x, GEN a, GEN b);
2888
GEN     chardiv0(GEN x, GEN a, GEN b);
2889
GEN     chareval(GEN G, GEN chi, GEN n, GEN z);
2890
GEN     chargalois(GEN G, GEN ORD);
2891
GEN     charker(GEN cyc, GEN chi);
2892
GEN     charker0(GEN cyc, GEN chi);
2893
GEN     charmul(GEN x, GEN a, GEN b);
2894
GEN     charmul0(GEN x, GEN a, GEN b);
2895
GEN     charorder(GEN cyc, GEN x);
2896
GEN     charorder0(GEN x, GEN chi);
2897
GEN     charpow(GEN cyc, GEN a, GEN N);
2898
GEN     charpow0(GEN x, GEN a, GEN N);
2899
GEN     char_denormalize(GEN cyc, GEN D, GEN chic);
2900
GEN     char_normalize(GEN chi, GEN ncyc);
2901
GEN     char_simplify(GEN D, GEN C);
2902
int     checkznstar_i(GEN G);
2903
GEN     cyc_normalize(GEN c);
2904
GEN     ncharvecexpo(GEN G, GEN nchi);
2905
GEN     znchar(GEN D);
2906
GEN     znchar_quad(GEN G, GEN D);
2907
int     zncharcheck(GEN G, GEN chi);
2908
GEN     zncharconductor(GEN G, GEN chi);
2909
GEN     zncharconj(GEN G, GEN chi);
2910
GEN     znchardecompose(GEN G, GEN chi, GEN Q);
2911
GEN     znchardiv(GEN G, GEN a, GEN b);
2912
GEN     znchareval(GEN G, GEN chi, GEN n, GEN z);
2913
GEN     zncharinduce(GEN G, GEN chi, GEN N);
2914
long    zncharisodd(GEN G, GEN chi);
2915
GEN     zncharker(GEN G, GEN chi);
2916
GEN     zncharmul(GEN G, GEN a, GEN b);
2917
GEN     zncharorder(GEN G,  GEN chi);
2918
GEN     zncharpow(GEN G, GEN a, GEN n);
2919
GEN     znchartokronecker(GEN G, GEN chi, long flag);
2920
GEN     znchartoprimitive(GEN G, GEN chi);
2921
int     znconrey_check(GEN cyc, GEN chi);
2922
GEN     znconrey_normalized(GEN G, GEN chi);
2923
GEN     znconreychar(GEN bid, GEN m);
2924
GEN     znconreyfromchar_normalized(GEN bid, GEN chi);
2925
GEN     znconreyconductor(GEN bid, GEN co, GEN *pm);
2926
GEN     znconreyexp(GEN bid, GEN x);
2927
GEN     znconreyfromchar(GEN bid, GEN chi);
2928
GEN     znconreylog(GEN bid, GEN x);
2929
GEN     znconreylog_normalize(GEN G, GEN m);
2930
GEN     znlog0(GEN h, GEN g, GEN o);
2931
long    zv_cyc_minimal(GEN cyc, GEN g, GEN coprime);
2932
long    zv_cyc_minimize(GEN cyc, GEN g, GEN coprime);
2933

2934
/* compile.c */
2935

2936
GEN     closure_deriv(GEN G);
2937
GEN     closure_derivn(GEN G, long k);
2938
long    localvars_find(GEN pack, entree *ep);
2939
GEN     localvars_read_str(const char *str, GEN pack);
2940
GEN     snm_closure(entree *ep, GEN data);
2941
GEN     strtoclosure(const char *s, long n, ...);
2942
GEN     strtofunction(const char *s);
2943

2944
/* concat.c */
2945

2946
GEN     gconcat(GEN x, GEN y);
2947
GEN     gconcat1(GEN x);
2948
GEN     matconcat(GEN v);
2949
GEN     shallowconcat(GEN x, GEN y);
2950
GEN     shallowconcat1(GEN x);
2951
GEN     shallowmatconcat(GEN v);
2952
GEN     vconcat(GEN A, GEN B);
2953

2954
/* default.c */
2955
enum { d_SILENT = 0, d_ACKNOWLEDGE, d_INITRC, d_RETURN };
2956

2957
GEN default0(const char *a, const char *b);
2958
long getrealprecision(void);
2959
entree *pari_is_default(const char *s);
2960
GEN sd_TeXstyle(const char *v, long flag);
2961
GEN sd_colors(const char *v, long flag);
2962
GEN sd_compatible(const char *v, long flag);
2963
GEN sd_datadir(const char *v, long flag);
2964
GEN sd_debug(const char *v, long flag);
2965
GEN sd_debugfiles(const char *v, long flag);
2966
GEN sd_debugmem(const char *v, long flag);
2967
GEN sd_factor_add_primes(const char *v, long flag);
2968
GEN sd_factor_proven(const char *v, long flag);
2969
GEN sd_format(const char *v, long flag);
2970
GEN sd_histsize(const char *v, long flag);
2971
GEN sd_log(const char *v, long flag);
2972
GEN sd_logfile(const char *v, long flag);
2973
GEN sd_nbthreads(const char *v, long flag);
2974
GEN sd_new_galois_format(const char *v, long flag);
2975
GEN sd_output(const char *v, long flag);
2976
GEN sd_parisize(const char *v, long flag);
2977
GEN sd_parisizemax(const char *v, long flag);
2978
GEN sd_path(const char *v, long flag);
2979
GEN sd_plothsizes(const char *v, long flag);
2980
GEN sd_prettyprinter(const char *v, long flag);
2981
GEN sd_primelimit(const char *v, long flag);
2982
GEN sd_realbitprecision(const char *v, long flag);
2983
GEN sd_realprecision(const char *v, long flag);
2984
GEN sd_secure(const char *v, long flag);
2985
GEN sd_seriesprecision(const char *v, long flag);
2986
GEN sd_simplify(const char *v, long flag);
2987
GEN sd_sopath(char *v, int flag);
2988
GEN sd_strictargs(const char *v, long flag);
2989
GEN sd_strictmatch(const char *v, long flag);
2990
GEN sd_string(const char *v, long flag, const char *s, char **f);
2991
GEN sd_threadsize(const char *v, long flag);
2992
GEN sd_threadsizemax(const char *v, long flag);
2993
GEN sd_intarray(const char *v, long flag, GEN *pz, const char *s);
2994
GEN sd_toggle(const char *v, long flag, const char *s, int *ptn);
2995
GEN sd_ulong(const char *v, long flag, const char *s, ulong *ptn, ulong Min, ulong Max, const char **msg);
2996
GEN setdefault(const char *s, const char *v, long flag);
2997
long setrealprecision(long n, long *prec);
2998

2999
/* ecpp.c */
3000

3001
GEN     ecpp(GEN N);
3002
GEN     ecpp0(GEN N, long stopat);
3003
GEN     ecppexport(GEN cert, long flag);
3004
long    ecppisvalid(GEN cert);
3005
long    isprimeECPP(GEN N);
3006

3007
/* gplib.c */
3008

3009
GEN sd_breakloop(const char *v, long flag);
3010
GEN sd_echo(const char *v, long flag);
3011
GEN sd_graphcolormap(const char *v, long flag);
3012
GEN sd_graphcolors(const char *v, long flag);
3013
GEN sd_help(const char *v, long flag);
3014
GEN sd_histfile(const char *v, long flag);
3015
GEN sd_lines(const char *v, long flag);
3016
GEN sd_linewrap(const char *v, long flag);
3017
GEN sd_prompt(const char *v, long flag);
3018
GEN sd_prompt_cont(const char *v, long flag);
3019
GEN sd_psfile(const char *v, long flag);
3020
GEN sd_readline(const char *v, long flag);
3021
GEN sd_recover(const char *v, long flag);
3022
GEN sd_timer(const char *v, long flag);
3023
void pari_hit_return(void);
3024
void gp_load_gprc(void);
3025
int  gp_meta(const char *buf, int ismain);
3026
const char **gphelp_keyword_list(void);
3027
void pari_center(const char *s);
3028
long pari_community(void);
3029
void pari_print_version(void);
3030
const char *gp_format_time(long delay);
3031
const char *gp_format_prompt(const char *p);
3032
void pari_alarm(long s);
3033
GEN  gp_alarm(long s, GEN code);
3034
GEN  gp_input(void);
3035
void gp_allocatemem(GEN z);
3036
int  gp_handle_exception(long numerr);
3037
void gp_alarm_handler(int sig);
3038
void gp_sigint_fun(void);
3039
enum { h_REGULAR=0, h_LONG=1, h_APROPOS=2, h_RL=4 };
3040
void gp_help(const char *s, long flag);
3041
void gp_echo_and_log(const char *prompt, const char *s);
3042
void print_fun_list(char **list, long nbli);
3043
GEN  strtime(long t);
3044

3045
/* dirichlet.c */
3046

3047
GEN     direuler(void *E, GEN (*eval)(void *, GEN), GEN a, GEN b, GEN c);
3048
GEN     dirpowers(long n, GEN x, long prec);
3049
GEN     dirpowerssum0(GEN N, GEN s, GEN f, long prec);
3050
GEN     dirpowerssum(ulong N, GEN s, long prec);
3051
GEN     dirpowerssumfun(ulong N, GEN s, void *E, GEN (*f)(void *,ulong,long), long prec);
3052
GEN     vecpowuu(long N, ulong B);
3053
GEN     vecpowug(long N, GEN B, long prec);
3054

3055
/* ellanal.c */
3056

3057
GEN     ellanalyticrank(GEN e, GEN eps, long prec);
3058
GEN     ellanalyticrank_bitprec(GEN e, GEN eps, long bitprec);
3059
GEN     ellanal_globalred_all(GEN e, GEN *N, GEN *cb, GEN *tam);
3060
GEN     ellheegner(GEN e);
3061
GEN     ellL1(GEN E, long r, long prec);
3062
GEN     ellL1_bitprec(GEN E, long r, long bitprec);
3063

3064
/* elldata.c */
3065

3066
GEN     ellconvertname(GEN s);
3067
GEN     elldatagenerators(GEN E);
3068
GEN     ellidentify(GEN E);
3069
GEN     ellsearch(GEN A);
3070
GEN     ellsearchcurve(GEN name);
3071
void    forell(void *E, long call(void*, GEN), long a, long b, long flag);
3072

3073
/* ellfromeqn.c */
3074

3075
GEN     ellfromeqn(GEN s);
3076

3077
/* elliptic.c */
3078
enum { t_ELL_Rg = 0, t_ELL_Q, t_ELL_Qp, t_ELL_Fp, t_ELL_Fq, t_ELL_NF };
3079
long    ellQ_get_CM(GEN e);
3080
void    ellQ_setprec(long prec);
3081
int     ell_is_integral(GEN E);
3082
GEN     ellbasechar(GEN E);
3083
GEN     akell(GEN e, GEN n);
3084
GEN     ellan(GEN e, long n);
3085
GEN     ellanQ_zv(GEN e, long n);
3086
GEN     bilhell(GEN e, GEN z1, GEN z2, long prec);
3087
void    checkell(GEN e);
3088
void    checkell_Fq(GEN e);
3089
void    checkell_Q(GEN e);
3090
void    checkell_Qp(GEN e);
3091
void    checkellisog(GEN v);
3092
void    checkellpt(GEN z);
3093
void    checkell5(GEN e);
3094
GEN     cxredsl2(GEN t, GEN *U);
3095
GEN     cxredsl2_i(GEN z, GEN *pU, GEN *czd);
3096
GEN     ec_2divpol_evalx(GEN E, GEN x);
3097
GEN     ec_3divpol_evalx(GEN E, GEN x);
3098
GEN     ec_bmodel(GEN e);
3099
GEN     ec_f_evalx(GEN E, GEN x);
3100
GEN     ec_h_evalx(GEN e, GEN x);
3101
GEN     ec_dFdx_evalQ(GEN E, GEN Q);
3102
GEN     ec_dFdy_evalQ(GEN E, GEN Q);
3103
GEN     ec_dmFdy_evalQ(GEN e, GEN Q);
3104
GEN     ec_half_deriv_2divpol_evalx(GEN E, GEN x);
3105
GEN     ec_phi2(GEN e);
3106
GEN     ellanal_globalred(GEN e, GEN *gr);
3107
GEN     ellQ_get_N(GEN e);
3108
void    ellQ_get_Nfa(GEN e, GEN *N, GEN *faN);
3109
GEN     ellQp_Tate_uniformization(GEN E, long prec);
3110
GEN     ellQp_AGM(GEN E, long prec);
3111
GEN     ellQp_u(GEN E, long prec);
3112
GEN     ellQp_u2(GEN E, long prec);
3113
GEN     ellQp_q(GEN E, long prec);
3114
GEN     ellQp_ab(GEN E, long prec);
3115
GEN     ellQp_L(GEN E, long prec);
3116
GEN     ellQp_root(GEN E, long prec);
3117
GEN     ellQtwist_bsdperiod(GEN E, long s);
3118
GEN     ellR_area(GEN E, long prec);
3119
GEN     ellR_ab(GEN E, long prec);
3120
GEN     ellR_eta(GEN E, long prec);
3121
GEN     ellR_omega(GEN x, long prec);
3122
GEN     ellR_roots(GEN E, long prec);
3123
GEN     elladd(GEN e, GEN z1, GEN z2);
3124
GEN     ellap(GEN e, GEN p);
3125
long    ellap_CM_fast(GEN E, ulong p, long CM);
3126
GEN     ellbsd(GEN e, long prec);
3127
GEN     ellcard(GEN E, GEN p);
3128
GEN     ellchangecurve(GEN e, GEN ch);
3129
GEN     ellchangeinvert(GEN w);
3130
GEN     ellchangepoint(GEN x, GEN ch);
3131
GEN     ellchangepointinv(GEN x, GEN ch);
3132
GEN     elldivpol(GEN e, long n, long v);
3133
GEN     elleisnum(GEN om, long k, long flag, long prec);
3134
GEN     elleta(GEN om, long prec);
3135
GEN     ellff_get_card(GEN E);
3136
GEN     ellff_get_gens(GEN E);
3137
GEN     ellff_get_group(GEN E);
3138
GEN     ellff_get_o(GEN x);
3139
GEN     ellff_get_p(GEN E);
3140
GEN     ellff_get_m(GEN E);
3141
GEN     ellff_get_D(GEN E);
3142
GEN     ellfromj(GEN j);
3143
GEN     ellgenerators(GEN E);
3144
GEN     ellglobalred(GEN e1);
3145
GEN     ellgroup(GEN E, GEN p);
3146
GEN     ellgroup0(GEN E, GEN p, long flag);
3147
GEN     ellheight0(GEN e, GEN a, GEN b, long prec);
3148
GEN     ellheight(GEN e, GEN a, long prec);
3149
GEN     ellheightmatrix(GEN E, GEN x, long n);
3150
GEN     ellheightoo(GEN e, GEN z, long prec);
3151
GEN     ellinit(GEN x, GEN p, long prec);
3152
GEN     ellintegralmodel(GEN e, GEN *pv);
3153
GEN     ellintegralmodel_i(GEN e, GEN *pv);
3154
GEN     ellisoncurve(GEN e, GEN z);
3155
GEN     ellisotree(GEN e);
3156
int     ellissupersingular(GEN x, GEN p);
3157
int     elljissupersingular(GEN x);
3158
GEN     elllseries(GEN e, GEN s, GEN A, long prec);
3159
GEN     elllocalred(GEN e, GEN p1);
3160
GEN     elllog(GEN e, GEN a, GEN g, GEN o);
3161
GEN     ellminimaldisc(GEN E);
3162
GEN     ellminimalmodel(GEN E, GEN *ptv);
3163
GEN     ellminimaltwist(GEN e);
3164
GEN     ellminimaltwist0(GEN e, long fl);
3165
GEN     ellminimaltwistcond(GEN e);
3166
GEN     ellmul(GEN e, GEN z, GEN n);
3167
GEN     ellnf_vecarea(GEN E, long prec);
3168
GEN     ellnf_veceta(GEN E, long prec);
3169
GEN     ellnf_vecomega(GEN E, long prec);
3170
GEN     ellneg(GEN e, GEN z);
3171
GEN     ellorder(GEN e, GEN p, GEN o);
3172
long    ellorder_Q(GEN E, GEN P);
3173
GEN     ellordinate(GEN e, GEN x, long prec);
3174
GEN     ellpadicheight0(GEN e, GEN p, long n, GEN P, GEN Q);
3175
GEN     ellpadicheightmatrix(GEN e, GEN p, long n, GEN P);
3176
GEN     ellperiods(GEN w, long flag, long prec);
3177
GEN     ellrandom(GEN e);
3178
long    ellrootno(GEN e, GEN p);
3179
long    ellrootno_global(GEN e);
3180
GEN     ellsaturation(GEN E, GEN P, long B, long prec);
3181
GEN     ellsea(GEN E, long smallfact);
3182
GEN     ellsigma(GEN om, GEN z, long flag, long prec);
3183
GEN     ellsub(GEN e, GEN z1, GEN z2);
3184
GEN     elltamagawa(GEN e);
3185
GEN     elltaniyama(GEN e, long prec);
3186
GEN     elltatepairing(GEN E, GEN t, GEN s, GEN m);
3187
GEN     elltors(GEN e);
3188
GEN     elltors0(GEN e, long flag);
3189
GEN     elltors_psylow(GEN e, ulong p);
3190
GEN     elltwist(GEN E, GEN D);
3191
GEN     ellweilpairing(GEN E, GEN t, GEN s, GEN m);
3192
GEN     ellwp(GEN w, GEN z, long prec);
3193
GEN     ellwp0(GEN w, GEN z, long flag, long prec);
3194
GEN     ellwpseries(GEN e, long v, long PRECDL);
3195
GEN     ellxn(GEN e, long n, long v);
3196
GEN     ellzeta(GEN om, GEN z, long prec);
3197
int     oncurve(GEN e, GEN z);
3198
GEN     orderell(GEN e, GEN p);
3199
GEN     pointell(GEN e, GEN z, long prec);
3200
GEN     point_to_a4a6(GEN E, GEN P, GEN p, GEN *pa4);
3201
GEN     point_to_a4a6_Fl(GEN E, GEN P, ulong p, ulong *pa4);
3202
GEN     zell(GEN e, GEN z, long prec);
3203

3204
/* ellpadic.c */
3205
GEN     Qp_agm2_sequence(GEN a1, GEN b1);
3206
void    Qp_ascending_Landen(GEN AB, GEN *ptx, GEN *pty);
3207
void    Qp_descending_Landen(GEN AB, GEN *ptx, GEN *pty);
3208
GEN     ellformaldifferential(GEN e, long n, long v);
3209
GEN     ellformalexp(GEN e, long n, long v);
3210
GEN     ellformallog(GEN e, long n, long v);
3211
GEN     ellformalpoint(GEN e, long n, long v);
3212
GEN     ellformalw(GEN e, long n, long v);
3213
GEN     ellnonsingularmultiple(GEN e, GEN P);
3214
GEN     ellpadicL(GEN E, GEN p, long n, GEN s, long r, GEN D);
3215
GEN     ellpadicbsd(GEN E, GEN p, long n, GEN D);
3216
GEN     ellpadicfrobenius(GEN E, ulong p, long n);
3217
GEN     ellpadicheight(GEN e, GEN p, long n, GEN P);
3218
GEN     ellpadiclog(GEN E, GEN p, long n, GEN P);
3219
GEN     ellpadicregulator(GEN E, GEN p, long n, GEN S);
3220
GEN     ellpadics2(GEN E, GEN p, long n);
3221

3222
/* ellrank.c*/
3223

3224
GEN     ell2cover(GEN ell, long prec);
3225
GEN     ellrank(GEN ell, long effort, GEN help, long prec);
3226
GEN     ellrankinit(GEN ell, long prec);
3227
long    hyperell_locally_soluble(GEN pol,GEN p);
3228
long    nf_hyperell_locally_soluble(GEN nf,GEN pol,GEN p);
3229
long    nfhilbert(GEN bnf,GEN a,GEN b);
3230
long    nfhilbert0(GEN bnf,GEN a,GEN b,GEN p);
3231

3232
/* elltors.c */
3233

3234
long    ellisdivisible(GEN E, GEN P, GEN n, GEN *Q);
3235

3236
/* ellisog.c */
3237

3238
GEN     ellisogenyapply(GEN f, GEN P);
3239
GEN     ellisogeny(GEN e, GEN G, long only_image, long vx, long vy);
3240
GEN     ellisomat(GEN E, long p, long flag);
3241
GEN     ellweilcurve(GEN E, GEN *pm);
3242

3243
/* ellsea.c */
3244

3245
GEN     Fp_ellcard_SEA(GEN a4, GEN a6, GEN p, long smallfact);
3246
GEN     Fq_ellcard_SEA(GEN a4, GEN a6, GEN q, GEN T, GEN p, long smallfact);
3247
GEN     ellmodulareqn(long l, long vx, long vy);
3248

3249
/* es.c */
3250

3251
GEN     externstr(const char *cmd);
3252
char    *gp_filter(const char *s);
3253
GEN     gpextern(const char *cmd);
3254
void    gpsystem(const char *s);
3255
GEN     readstr(const char *s);
3256
GEN     GENtoGENstr_nospace(GEN x);
3257
GEN     GENtoGENstr(GEN x);
3258
char*   GENtoTeXstr(GEN x);
3259
char*   GENtostr(GEN x);
3260
char*   GENtostr_raw(GEN x);
3261
char*   GENtostr_unquoted(GEN x);
3262
GEN     Str(GEN g);
3263
GEN     strexpand(GEN g);
3264
GEN     strtex(GEN g);
3265
void    brute(GEN g, char format, long dec);
3266
void    dbgGEN(GEN x, long nb);
3267
void    error0(GEN g);
3268
void    dbg_pari_heap(void);
3269
int     file_is_binary(FILE *f);
3270
void    err_flush(void);
3271
void    err_printf(const char* pat, ...);
3272
GEN     gp_getenv(const char *s);
3273
void    gp_fileclose(long n);
3274
long    gp_fileextern(char *s);
3275
void    gp_fileflush(long n);
3276
void    gp_fileflush0(GEN n);
3277
long    gp_fileopen(char *s, char *mode);
3278
GEN     gp_fileread(long n);
3279
GEN     gp_filereadstr(long n);
3280
void    gp_filewrite(long n, const char *s);
3281
void    gp_filewrite1(long n, const char *s);
3282
GEN     gp_read_file(const char *s);
3283
GEN     gp_read_str_multiline(const char *s, char *last);
3284
GEN     gp_read_stream(FILE *f);
3285
GEN     gp_readvec_file(char *s);
3286
GEN     gp_readvec_stream(FILE *f);
3287
void    gpinstall(const char *s, const char *code,
3288
                  const char *gpname, const char *lib);
3289
GEN     gsprintf(const char *fmt, ...);
3290
GEN     gvsprintf(const char *fmt, va_list ap);
3291
char*   itostr(GEN x);
3292
void    matbrute(GEN g, char format, long dec);
3293
char*   os_getenv(const char *s);
3294
char*   uordinal(ulong i);
3295
void    outmat(GEN x);
3296
void    output(GEN x);
3297
char*   RgV_to_str(GEN g, long flag);
3298
void    pari_add_hist(GEN z, long t, long r);
3299
void    pari_ask_confirm(const char *s);
3300
void    pari_fclose(pariFILE *f);
3301
void    pari_flush(void);
3302
pariFILE* pari_fopen(const char *s, const char *mode);
3303
pariFILE* pari_fopen_or_fail(const char *s, const char *mode);
3304
pariFILE* pari_fopengz(const char *s);
3305
void    pari_fprintf(FILE *file, const char *fmt, ...);
3306
void    pari_fread_chars(void *b, size_t n, FILE *f);
3307
GEN     pari_get_hist(long p);
3308
long    pari_get_histrtime(long p);
3309
long    pari_get_histtime(long p);
3310
char*   pari_get_homedir(const char *user);
3311
GEN     pari_histtime(long p);
3312
int     pari_is_dir(const char *name);
3313
int     pari_is_file(const char *name);
3314
int     pari_last_was_newline(void);
3315
void    pari_set_last_newline(int last);
3316
ulong   pari_nb_hist(void);
3317
void    pari_printf(const char *fmt, ...);
3318
void    pari_putc(char c);
3319
void    pari_puts(const char *s);
3320
pariFILE* pari_safefopen(const char *s, const char *mode);
3321
char*   pari_sprintf(const char *fmt, ...);
3322
int     pari_stdin_isatty(void);
3323
char*   pari_unique_dir(const char *s);
3324
char*   pari_unique_filename(const char *s);
3325
char*   pari_unique_filename_suffix(const char *s, const char *suf);
3326
void    pari_unlink(const char *s);
3327
void    pari_vfprintf(FILE *file, const char *fmt, va_list ap);
3328
void    pari_vprintf(const char *fmt, va_list ap);
3329
char*   pari_vsprintf(const char *fmt, va_list ap);
3330
char*   path_expand(const char *s);
3331
void    out_print0(PariOUT *out, const char *sep, GEN g, long flag);
3332
void    out_printf(PariOUT *out, const char *fmt, ...);
3333
void    out_putc(PariOUT *out, char c);
3334
void    out_puts(PariOUT *out, const char *s);
3335
void    out_term_color(PariOUT *out, long c);
3336
void    out_vprintf(PariOUT *out, const char *fmt, va_list ap);
3337
char*   pari_sprint0(const char *msg, GEN g, long flag);
3338
void    print(GEN g);
3339
void    printp(GEN g);
3340
enum { f_RAW = 0, f_PRETTYMAT = 1, f_PRETTY = 3, f_TEX = 4 };
3341
void    print0(GEN g, long flag);
3342
void    print1(GEN g);
3343
void    printf0(const char *fmt, GEN args);
3344
void    printsep(const char *s, GEN g);
3345
void    printsep1(const char *s, GEN g);
3346
void    printtex(GEN g);
3347
char*   stack_sprintf(const char *fmt, ...);
3348
void    str_init(pari_str *S, int use_stack);
3349
void    str_printf(pari_str *S, const char *fmt, ...);
3350
void    str_putc(pari_str *S, char c);
3351
void    str_puts(pari_str *S, const char *s);
3352
void    strftime_expand(const char *s, char *buf, long max);
3353
GEN     strprintf(const char *fmt, GEN args);
3354
FILE*   switchin(const char *name);
3355
void    switchout(const char *name);
3356
void    term_color(long c);
3357
char*   term_get_color(char *s, long c);
3358
void    texe(GEN g, char format, long dec);
3359
void    warning0(GEN g);
3360
void    write0(const char *s, GEN g);
3361
void    write1(const char *s, GEN g);
3362
void    writebin(const char *name, GEN x);
3363
void    writetex(const char *s, GEN g);
3364

3365
/* eval.c */
3366

3367
enum { br_NONE = 0, br_BREAK, br_NEXT, br_MULTINEXT, br_RETURN };
3368
void    bincopy_relink(GEN C, GEN vi);
3369
GEN     bitprecision0(GEN x,long n);
3370
GEN     bitprecision00(GEN x,GEN n);
3371
GEN     break0(long n);
3372
GEN     call0(GEN fun, GEN args);
3373
GEN     closure_callgen0prec(GEN C, long prec);
3374
GEN     closure_callgen1(GEN C, GEN x);
3375
GEN     closure_callgen1prec(GEN C, GEN x, long prec);
3376
GEN     closure_callgen2(GEN C, GEN x, GEN y);
3377
GEN     closure_callgenall(GEN C, long n, ...);
3378
GEN     closure_callgenvec(GEN C, GEN args);
3379
GEN     closure_callgenvecdef(GEN C, GEN args, GEN def);
3380
GEN     closure_callgenvecdefprec(GEN C, GEN args, GEN def, long prec);
3381
GEN     closure_callgenvecprec(GEN C, GEN args, long prec);
3382
void    closure_callvoid1(GEN C, GEN x);
3383
long    closure_context(long start, long level);
3384
void    closure_disassemble(GEN n);
3385
void    closure_err(long level);
3386
GEN     closure_evalbrk(GEN C, long *status);
3387
GEN     closure_evalgen(GEN C);
3388
GEN     closure_evalnobrk(GEN C);
3389
GEN     closure_evalres(GEN C);
3390
void    closure_evalvoid(GEN C);
3391
const char * closure_func_err(void);
3392
GEN     closure_trapgen(GEN C, long numerr);
3393
GEN     copybin_unlink(GEN C);
3394
long    getlocalprec(long prec);
3395
long    getlocalbitprec(long bit);
3396
GEN     get_lex(long vn);
3397
long    get_localprec(void);
3398
long    get_localbitprec(void);
3399
GEN     gp_call(void *E, GEN x);
3400
GEN     gp_callprec(void *E, GEN x, long prec);
3401
GEN     gp_call2(void *E, GEN x, GEN y);
3402
long    gp_callbool(void *E, GEN x);
3403
long    gp_callvoid(void *E, GEN x);
3404
GEN     gp_eval(void *E, GEN x);
3405
long    gp_evalbool(void *E, GEN x);
3406
GEN     gp_evalprec(void *E, GEN x, long prec);
3407
GEN     gp_evalupto(void *E, GEN x);
3408
long    gp_evalvoid(void *E, GEN x);
3409
void    localprec(GEN p);
3410
void    localbitprec(GEN p);
3411
long    loop_break(void);
3412
GEN     next0(long n);
3413
GEN     pareval(GEN C);
3414
GEN     pari_self(void);
3415
GEN     parsum(GEN a, GEN b, GEN code);
3416
GEN     parvector(long n, GEN code);
3417
void    pop_lex(long n);
3418
void    pop_localprec(void);
3419
GEN     precision0(GEN x,long n);
3420
GEN     precision00(GEN x, GEN n);
3421
void    push_lex(GEN a, GEN C);
3422
void    push_localbitprec(long p);
3423
void    push_localprec(long p);
3424
GEN     return0(GEN x);
3425
void    set_lex(long vn, GEN x);
3426

3427
/* forprime.c */
3428

3429
int     forcomposite_init(forcomposite_t *C, GEN a, GEN b);
3430
GEN     forcomposite_next(forcomposite_t *C);
3431
GEN     forprime_next(forprime_t *T);
3432
int     forprime_init(forprime_t *T, GEN a, GEN b);
3433
int     forprimestep_init(forprime_t *T, GEN a, GEN b, GEN q);
3434
byteptr initprimes(ulong maxnum, long *lenp, ulong *lastp);
3435
void    initprimetable(ulong maxnum);
3436
ulong   init_primepointer_geq(ulong a, byteptr *pd);
3437
ulong   init_primepointer_gt(ulong a, byteptr *pd);
3438
ulong   init_primepointer_leq(ulong a, byteptr *pd);
3439
ulong   init_primepointer_lt(ulong a, byteptr *pd);
3440
ulong   maxprime(void);
3441
ulong   maxprimeN(void);
3442
void    maxprime_check(ulong c);
3443
void    pari_init_primes(ulong maxprime);
3444
ulong   u_forprime_next(forprime_t *T);
3445
int     u_forprime_init(forprime_t *T, ulong a, ulong b);
3446
void    u_forprime_restrict(forprime_t *T, ulong c);
3447
int     u_forprime_arith_init(forprime_t *T, ulong a, ulong b, ulong c, ulong q);
3448

3449
/* FF.c */
3450

3451
GEN     FF_1(GEN a);
3452
GEN     FF_Frobenius(GEN x, long e);
3453
GEN     FF_Z_Z_muldiv(GEN x, GEN y, GEN z);
3454
GEN     FF_Q_add(GEN x, GEN y);
3455
GEN     FF_Z_add(GEN a, GEN b);
3456
GEN     FF_Z_mul(GEN a, GEN b);
3457
GEN     FF_add(GEN a, GEN b);
3458
GEN     FF_charpoly(GEN x);
3459
GEN     FF_conjvec(GEN x);
3460
GEN     FF_div(GEN a, GEN b);
3461
GEN     FF_ellcard(GEN E);
3462
GEN     FF_ellcard_SEA(GEN E, long smallfact);
3463
GEN     FF_ellgens(GEN E);
3464
GEN     FF_ellgroup(GEN E, GEN *m);
3465
GEN     FF_elllog(GEN E, GEN P, GEN Q, GEN o);
3466
GEN     FF_ellmul(GEN E, GEN P, GEN n);
3467
GEN     FF_ellorder(GEN E, GEN P, GEN o);
3468
GEN     FF_elltwist(GEN E);
3469
GEN     FF_ellrandom(GEN E);
3470
GEN     FF_elltatepairing(GEN E, GEN P, GEN Q, GEN m);
3471
GEN     FF_ellweilpairing(GEN E, GEN P, GEN Q, GEN m);
3472
int     FF_equal(GEN a, GEN b);
3473
int     FF_equal0(GEN x);
3474
int     FF_equal1(GEN x);
3475
int     FF_equalm1(GEN x);
3476
long    FF_f(GEN x);
3477
GEN     FF_gen(GEN x);
3478
GEN     FF_inv(GEN a);
3479
long    FF_issquare(GEN x);
3480
long    FF_issquareall(GEN x, GEN *pt);
3481
long    FF_ispower(GEN x, GEN K, GEN *pt);
3482
GEN     FF_log(GEN a, GEN b, GEN o);
3483
GEN     FF_map(GEN m, GEN x);
3484
GEN     FF_minpoly(GEN x);
3485
GEN     FF_mod(GEN x);
3486
GEN     FF_mul(GEN a, GEN b);
3487
GEN     FF_mul2n(GEN a, long n);
3488
GEN     FF_neg(GEN a);
3489
GEN     FF_neg_i(GEN a);
3490
GEN     FF_norm(GEN x);
3491
GEN     FF_order(GEN x, GEN o);
3492
GEN     FF_p(GEN x);
3493
GEN     FF_p_i(GEN x);
3494
GEN     FF_pow(GEN x, GEN n);
3495
GEN     FF_primroot(GEN x, GEN *o);
3496
GEN     FF_q(GEN x);
3497
int     FF_samefield(GEN x, GEN y);
3498
GEN     FF_sqr(GEN a);
3499
GEN     FF_sqrt(GEN a);
3500
GEN     FF_sqrtn(GEN x, GEN n, GEN *zetan);
3501
GEN     FF_sub(GEN x, GEN y);
3502
GEN     FF_to_F2xq(GEN x);
3503
GEN     FF_to_F2xq_i(GEN x);
3504
GEN     FF_to_Flxq(GEN x);
3505
GEN     FF_to_Flxq_i(GEN x);
3506
GEN     FF_to_FpXQ(GEN x);
3507
GEN     FF_to_FpXQ_i(GEN x);
3508
GEN     FF_trace(GEN x);
3509
long    FF_var(GEN x);
3510
GEN     FF_zero(GEN a);
3511
GEN     FFM_FFC_invimage(GEN M, GEN C, GEN ff);
3512
GEN     FFM_FFC_gauss(GEN M, GEN C, GEN ff);
3513
GEN     FFM_FFC_mul(GEN M, GEN C, GEN ff);
3514
GEN     FFM_deplin(GEN M, GEN ff);
3515
GEN     FFM_det(GEN M, GEN ff);
3516
GEN     FFM_gauss(GEN M, GEN N, GEN ff);
3517
GEN     FFM_image(GEN M, GEN ff);
3518
GEN     FFM_indexrank(GEN M, GEN ff);
3519
GEN     FFM_inv(GEN M, GEN ff);
3520
GEN     FFM_invimage(GEN M, GEN N, GEN ff);
3521
GEN     FFM_ker(GEN M, GEN ff);
3522
GEN     FFM_mul(GEN M, GEN N, GEN ff);
3523
long    FFM_rank(GEN M, GEN ff);
3524
GEN     FFM_suppl(GEN M, GEN ff);
3525
GEN     FFX_add(GEN Pf, GEN Qf, GEN ff);
3526
GEN     FFX_ddf(GEN f, GEN x);
3527
GEN     FFX_degfact(GEN Pf, GEN ff);
3528
GEN     FFX_disc(GEN Pf, GEN ff);
3529
GEN     FFX_extgcd(GEN Pf, GEN Qf, GEN ff, GEN *pt_Uf, GEN *pt_Vf);
3530
GEN     FFX_factor(GEN f, GEN x);
3531
GEN     FFX_factor_squarefree(GEN f, GEN x);
3532
GEN     FFX_gcd(GEN Pf, GEN Qf, GEN ff);
3533
GEN     FFX_halfgcd(GEN Pf, GEN Qf, GEN ff);
3534
long    FFX_ispower(GEN Pf, long k, GEN ff, GEN *pt_r);
3535
GEN     FFX_mul(GEN Pf, GEN Qf, GEN ff);
3536
GEN     FFX_preimage(GEN x, GEN F, GEN y);
3537
GEN     FFX_preimagerel(GEN x, GEN F, GEN y);
3538
GEN     FFX_rem(GEN Pf, GEN Qf, GEN ff);
3539
GEN     FFX_resultant(GEN Pf, GEN Qf, GEN ff);
3540
GEN     FFX_roots(GEN f, GEN x);
3541
GEN     FFX_sqr(GEN Pf, GEN ff);
3542
GEN     FFXQ_inv(GEN Pf, GEN Qf, GEN ff);
3543
GEN     FFXQ_minpoly(GEN Pf, GEN Qf, GEN ff);
3544
GEN     FFXQ_mul(GEN Pf, GEN Qf, GEN Sf, GEN ff);
3545
GEN     FFXQ_sqr(GEN Pf, GEN Qf, GEN ff);
3546
GEN     FqX_to_FFX(GEN x, GEN ff);
3547
GEN     Fq_to_FF(GEN x, GEN ff);
3548
GEN     Z_FF_div(GEN a, GEN b);
3549
GEN     ffembed(GEN a, GEN b);
3550
GEN     ffextend(GEN a, GEN P, long v);
3551
GEN     fffrobenius(GEN m, long n);
3552
GEN     ffgen(GEN T, long v);
3553
GEN     ffinvmap(GEN m);
3554
GEN     fflog(GEN x, GEN g, GEN o);
3555
GEN     ffmap(GEN m, GEN x);
3556
GEN     ffmaprel(GEN m, GEN x);
3557
GEN     ffcompomap(GEN m, GEN n);
3558
GEN     fforder(GEN x, GEN o);
3559
GEN     ffprimroot(GEN x, GEN *o);
3560
GEN     ffrandom(GEN ff);
3561
int     Rg_is_FF(GEN c, GEN *ff);
3562
int     RgC_is_FFC(GEN x, GEN *ff);
3563
int     RgM_is_FFM(GEN x, GEN *ff);
3564
GEN     p_to_FF(GEN p, long v);
3565
GEN     Tp_to_FF(GEN T, GEN p);
3566

3567
/* galconj.c */
3568

3569
GEN     checkgal(GEN gal);
3570
GEN     checkgroup(GEN g, GEN *S);
3571
GEN     checkgroupelts(GEN gal);
3572
GEN     embed_disc(GEN r, long r1, long prec);
3573
GEN     embed_roots(GEN r, long r1);
3574
GEN     galois_group(GEN gal);
3575
GEN     galoisconj(GEN nf, GEN d);
3576
GEN     galoisconj0(GEN nf, long flag, GEN d, long prec);
3577
GEN     galoisconjclasses(GEN gal);
3578
GEN     galoisexport(GEN gal, long format);
3579
GEN     galoisfixedfield(GEN gal, GEN v, long flag, long y);
3580
GEN     galoisidentify(GEN gal);
3581
GEN     galoisinit(GEN nf, GEN den);
3582
GEN     galoisisabelian(GEN gal, long flag);
3583
long    galoisisnormal(GEN gal, GEN sub);
3584
GEN     galoispermtopol(GEN gal, GEN perm);
3585
GEN     galoissplittinginit(GEN nf, GEN deg);
3586
GEN     galoissubgroups(GEN G);
3587
GEN     galoissubfields(GEN G, long flag, long v);
3588
long    numberofconjugates(GEN T, long pdepart);
3589

3590
/* galois.c */
3591

3592
GEN     polgalois(GEN x, long prec);
3593

3594
/* galpol.c */
3595

3596
GEN     galoisnbpol(long a);
3597
GEN     galoisgetgroup(long a, long b);
3598
GEN     galoisgetname(long a, long b);
3599
GEN     galoisgetpol(long a, long b, long s);
3600

3601
/* gen1.c */
3602
GEN     conj_i(GEN x);
3603
GEN     conjvec(GEN x,long prec);
3604
GEN     gadd(GEN x, GEN y);
3605
GEN     gaddsg(long x, GEN y);
3606
GEN     gconj(GEN x);
3607
GEN     gdiv(GEN x, GEN y);
3608
GEN     gdivgs(GEN x, long s);
3609
GEN     ginv(GEN x);
3610
GEN     gmul(GEN x, GEN y);
3611
GEN     gmul2n(GEN x, long n);
3612
GEN     gmulsg(long s, GEN y);
3613
GEN     gsqr(GEN x);
3614
GEN     gsub(GEN x, GEN y);
3615
GEN     gsubsg(long x, GEN y);
3616
GEN     mulcxI(GEN x);
3617
GEN     mulcxmI(GEN x);
3618
GEN     mulcxpowIs(GEN x, long k);
3619
GEN     Qdivii(GEN x1, GEN x2);
3620
GEN     Qdiviu(GEN x, ulong y);
3621
GEN     Qdivis(GEN x, long y);
3622
GEN     ser_normalize(GEN x);
3623

3624
/* gen2.c */
3625

3626
GEN     gassoc_proto(GEN f(GEN,GEN),GEN,GEN);
3627
GEN     map_proto_G(GEN f(GEN), GEN x);
3628
GEN     map_proto_lG(long f(GEN), GEN x);
3629
GEN     map_proto_lGL(long f(GEN,long), GEN x, long y);
3630

3631
long    Q_lval(GEN x, ulong p);
3632
long    Q_lvalrem(GEN x, ulong p, GEN *y);
3633
long    Q_pval(GEN x, GEN p);
3634
long    Q_pvalrem(GEN x, GEN p, GEN *y);
3635
long    RgX_val(GEN x);
3636
long    RgX_valrem(GEN x, GEN *z);
3637
long    RgX_valrem_inexact(GEN x, GEN *Z);
3638
long    RgXV_maxdegree(GEN x);
3639
int     ZV_Z_dvd(GEN v, GEN p);
3640
long    ZV_pval(GEN x, GEN p);
3641
long    ZV_pvalrem(GEN x, GEN p, GEN *px);
3642
long    ZV_lval(GEN x, ulong p);
3643
long    ZV_lvalrem(GEN x, ulong p, GEN *px);
3644
long    ZX_lvalrem(GEN x, ulong p, GEN *px);
3645
long    ZX_lval(GEN x, ulong p);
3646
long    ZX_pval(GEN x, GEN p);
3647
long    ZX_pvalrem(GEN x, GEN p, GEN *px);
3648
long    Z_lval(GEN n, ulong p);
3649
long    Z_lvalrem(GEN n, ulong p, GEN *py);
3650
long    Z_lvalrem_stop(GEN *n, ulong p, int *stop);
3651
long    Z_pval(GEN n, GEN p);
3652
long    Z_pvalrem(GEN x, GEN p, GEN *py);
3653
GEN     cgetp(GEN x);
3654
GEN     cvstop2(long s, GEN y);
3655
GEN     cvtop(GEN x, GEN p, long l);
3656
GEN     cvtop2(GEN x, GEN y);
3657
int     cx_approx_equal(GEN a, GEN b);
3658
GEN     gabs(GEN x, long prec);
3659
void    gaffect(GEN x, GEN y);
3660
void    gaffsg(long s, GEN x);
3661
int     gcmp(GEN x, GEN y);
3662
int     gequal0(GEN x);
3663
int     gequal1(GEN x);
3664
int     gequalX(GEN x);
3665
int     gequalm1(GEN x);
3666
int     gcmpsg(long x, GEN y);
3667
GEN     gcvtop(GEN x, GEN p, long r);
3668
int     gequal(GEN x, GEN y);
3669
int     gequalsg(long s, GEN x);
3670
long    gexpo(GEN x);
3671
long    gexpo_safe(GEN x);
3672
GEN     gpexponent(GEN x);
3673
GEN     gpvaluation(GEN x, GEN p);
3674
long    gvaluation(GEN x, GEN p);
3675
int     gidentical(GEN x, GEN y);
3676
long    glength(GEN x);
3677
GEN     gmax(GEN x, GEN y);
3678
GEN     gmaxgs(GEN x, long y);
3679
GEN     gmin(GEN x, GEN y);
3680
GEN     gmings(GEN x, long y);
3681
GEN     gneg(GEN x);
3682
GEN     gneg_i(GEN x);
3683
int     gsigne(GEN x);
3684
GEN     gtolist(GEN x);
3685
long    gtolong(GEN x);
3686
int     lexcmp(GEN x, GEN y);
3687
GEN     listinsert(GEN list, GEN object, long index);
3688
void    listpop(GEN L, long index);
3689
void    listpop0(GEN L, long index);
3690
GEN     listput(GEN list, GEN object, long index);
3691
GEN     listput0(GEN list, GEN object, long index);
3692
void    listsort(GEN list, long flag);
3693
GEN     matsize(GEN x);
3694
GEN     mklist(void);
3695
GEN     mklist_typ(long t);
3696
GEN     mklistcopy(GEN x);
3697
GEN     mkmap(void);
3698
GEN     normalize(GEN x);
3699
GEN     normalizepol(GEN x);
3700
GEN     normalizepol_approx(GEN x, long lx);
3701
GEN     normalizepol_lg(GEN x, long lx);
3702
ulong   padic_to_Fl(GEN x, ulong p);
3703
GEN     padic_to_Fp(GEN x, GEN Y);
3704
GEN     quadtofp(GEN x, long l);
3705
long    sizedigit(GEN x);
3706
long    u_lval(ulong x, ulong p);
3707
long    u_lvalrem(ulong x, ulong p, ulong *py);
3708
long    u_lvalrem_stop(ulong *n, ulong p, int *stop);
3709
long    u_pval(ulong x, GEN p);
3710
long    u_pvalrem(ulong x, GEN p, ulong *py);
3711
long    vecindexmax(GEN x);
3712
long    vecindexmin(GEN x);
3713
GEN     vecmax0(GEN x, GEN *pv);
3714
GEN     vecmax(GEN x);
3715
GEN     vecmin0(GEN x, GEN *pv);
3716
GEN     vecmin(GEN x);
3717
long    z_lval(long s, ulong p);
3718
long    z_lvalrem(long s, ulong p, long *py);
3719
long    z_pval(long n, GEN p);
3720
long    z_pvalrem(long n, GEN p, long *py);
3721
long    zx_lval(GEN f, long p);
3722

3723
/* Ser.c */
3724

3725
GEN     RgX_to_ser(GEN x, long l);
3726
GEN     RgX_to_ser_inexact(GEN x, long l);
3727
GEN     gtoser(GEN x, long v, long d);
3728
GEN     gtoser_prec(GEN x, long v, long d);
3729
GEN     rfrac_to_ser(GEN x, long l);
3730
GEN     rfracrecip_to_ser_absolute(GEN R, long l);
3731
long    rfracrecip(GEN *pn, GEN *pd);
3732
GEN     scalarser(GEN x, long v, long prec);
3733
GEN     sertoser(GEN x, long prec);
3734
GEN     toser_i(GEN x);
3735
GEN     RgV_to_ser(GEN x, long v, long l);
3736
GEN     Ser0(GEN x, long v, GEN d, long prec);
3737

3738
/* gen3.c */
3739

3740
GEN     padic_to_Q(GEN x);
3741
GEN     padic_to_Q_shallow(GEN x);
3742
GEN     QpV_to_QV(GEN v);
3743
GEN     RgC_RgV_mulrealsym(GEN x, GEN y);
3744
GEN     RgM_mulreal(GEN x, GEN y);
3745
GEN     RgX_cxeval(GEN T, GEN u, GEN ui);
3746
GEN     RgX_deflate_max(GEN x0, long *m);
3747
long    RgX_deflate_order(GEN x);
3748
long    ZX_deflate_order(GEN x);
3749
GEN     ZX_deflate_max(GEN x, long *m);
3750
long    RgX_degree(GEN x,long v);
3751
GEN     RgX_integ(GEN x);
3752
GEN     ceil_safe(GEN x);
3753
GEN     ceilr(GEN x);
3754
GEN     centerlift(GEN x);
3755
GEN     centerlift0(GEN x,long v);
3756
GEN     compo(GEN x, long n);
3757
GEN     deg1pol(GEN x1, GEN x0,long v);
3758
GEN     deg1pol_shallow(GEN x1, GEN x0,long v);
3759
GEN     deg2pol_shallow(GEN x2, GEN x1, GEN x0,long v);
3760
long    degree(GEN x);
3761
GEN     denom(GEN x);
3762
GEN     denom_i(GEN x);
3763
GEN     denominator(GEN x, GEN D);
3764
GEN     deriv(GEN x, long v);
3765
GEN     derivn(GEN x, long n, long v);
3766
GEN     derivser(GEN x);
3767
GEN     diffop(GEN x, GEN v, GEN dv);
3768
GEN     diffop0(GEN x, GEN v, GEN dv, long n);
3769
GEN     diviiround(GEN x, GEN y);
3770
GEN     divrem(GEN x, GEN y, long v);
3771
GEN     floor_safe(GEN x);
3772
GEN     gceil(GEN x);
3773
GEN     gcvtoi(GEN x, long *e);
3774
GEN     gdeflate(GEN x, long v, long d);
3775
GEN     gdivent(GEN x, GEN y);
3776
GEN     gdiventgs(GEN x, long y);
3777
GEN     gdiventsg(long x, GEN y);
3778
GEN     gdiventres(GEN x, GEN y);
3779
GEN     gdivmod(GEN x, GEN y, GEN *pr);
3780
GEN     gdivround(GEN x, GEN y);
3781
int     gdvd(GEN x, GEN y);
3782
GEN     geq(GEN x, GEN y);
3783
GEN     geval(GEN x);
3784
GEN     gfloor(GEN x);
3785
GEN     gtrunc2n(GEN x, long s);
3786
GEN     gfrac(GEN x);
3787
GEN     gge(GEN x, GEN y);
3788
GEN     ggrando(GEN x, long n);
3789
GEN     ggt(GEN x, GEN y);
3790
GEN     gimag(GEN x);
3791
GEN     gisexactzero(GEN g);
3792
GEN     gle(GEN x, GEN y);
3793
GEN     glt(GEN x, GEN y);
3794
GEN     gmod(GEN x, GEN y);
3795
GEN     gmodgs(GEN x, long y);
3796
GEN     gmodsg(long x, GEN y);
3797
GEN     gmodulo(GEN x,GEN y);
3798
GEN     gmodulsg(long x, GEN y);
3799
GEN     gmodulss(long x, long y);
3800
GEN     gne(GEN x, GEN y);
3801
GEN     gnot(GEN x);
3802
GEN     gpolvar(GEN y);
3803
GEN     gppadicprec(GEN x, GEN p);
3804
GEN     gppoldegree(GEN x, long v);
3805
long    gprecision(GEN x);
3806
GEN     gpserprec(GEN x, long v);
3807
GEN     greal(GEN x);
3808
GEN     grndtoi(GEN x, long *e);
3809
GEN     ground(GEN x);
3810
GEN     gshift(GEN x, long n);
3811
GEN     gsubst(GEN x, long v, GEN y);
3812
GEN     gsubstpol(GEN x, GEN v, GEN y);
3813
GEN     gsubstvec(GEN x, GEN v, GEN y);
3814
GEN     gtocol(GEN x);
3815
GEN     gtocol0(GEN x, long n);
3816
GEN     gtocolrev(GEN x);
3817
GEN     gtocolrev0(GEN x, long n);
3818
GEN     gtopoly(GEN x, long v);
3819
GEN     gtopolyrev(GEN x, long v);
3820
GEN     gtovec(GEN x);
3821
GEN     gtovec0(GEN x, long n);
3822
GEN     gtovecrev(GEN x);
3823
GEN     gtovecrev0(GEN x, long n);
3824
GEN     gtovecsmall(GEN x);
3825
GEN     gtovecsmall0(GEN x, long n);
3826
GEN     gtrunc(GEN x);
3827
long    gvar(GEN x);
3828
long    gvar2(GEN x);
3829
GEN     hqfeval(GEN q, GEN x);
3830
GEN     imag_i(GEN x);
3831
GEN     integ(GEN x, long v);
3832
GEN     integser(GEN x);
3833
GEN     ser_inv(GEN b);
3834
int     iscomplex(GEN x);
3835
int     isexactzero(GEN g);
3836
int     isrationalzeroscalar(GEN g);
3837
int     isinexact(GEN x);
3838
int     isinexactreal(GEN x);
3839
int     isint(GEN n, GEN *ptk);
3840
int     isrationalzero(GEN g);
3841
int     issmall(GEN n, long *ptk);
3842
GEN     lift(GEN x);
3843
GEN     lift_shallow(GEN x);
3844
GEN     lift0(GEN x,long v);
3845
GEN     liftall(GEN x);
3846
GEN     liftall_shallow(GEN x);
3847
GEN     liftint(GEN x);
3848
GEN     liftint_shallow(GEN x);
3849
GEN     liftpol(GEN x);
3850
GEN     liftpol_shallow(GEN x);
3851
GEN     mkcoln(long n, ...);
3852
GEN     mkintn(long n, ...);
3853
GEN     mkpoln(long n, ...);
3854
GEN     mkvecn(long n, ...);
3855
GEN     mkvecsmalln(long n, ...);
3856
GEN     modRr_safe(GEN x, GEN y);
3857
GEN     mulreal(GEN x, GEN y);
3858
GEN     numer(GEN x);
3859
GEN     numer_i(GEN x);
3860
GEN     numerator(GEN x, GEN D);
3861
long    padicprec(GEN x, GEN p);
3862
long    padicprec_relative(GEN x);
3863
GEN     polcoef(GEN x, long n, long v);
3864
GEN     polcoef_i(GEN x, long n, long v);
3865
long    poldegree(GEN x,long v);
3866
GEN     poleval(GEN x, GEN y);
3867
GEN     pollead(GEN x,long v);
3868
long    precision(GEN x);
3869
GEN     qf_apply_RgM(GEN q, GEN M);
3870
GEN     qf_apply_ZM(GEN q, GEN M);
3871
GEN     qfb_apply_ZM(GEN q, GEN M);
3872
GEN     qfbil(GEN x, GEN y, GEN q);
3873
GEN     qfeval(GEN q, GEN x);
3874
GEN     qfeval0(GEN q, GEN x, GEN y);
3875
GEN     qfevalb(GEN q, GEN x, GEN y);
3876
GEN     qfnorm(GEN x, GEN q);
3877
GEN     real_i(GEN x);
3878
GEN     round0(GEN x, GEN *pte);
3879
GEN     roundr(GEN x);
3880
GEN     roundr_safe(GEN x);
3881
GEN     scalarpol(GEN x, long v);
3882
GEN     scalarpol_shallow(GEN x, long v);
3883
GEN     ser_unscale(GEN P, GEN h);
3884
long    serprec(GEN x, long v);
3885
GEN     serreverse(GEN x);
3886
GEN     simplify(GEN x);
3887
GEN     simplify_shallow(GEN x);
3888
GEN     tayl(GEN x, long v, long precdl);
3889
GEN     trunc0(GEN x, GEN *pte);
3890
GEN     uu32toi(ulong a, ulong b);
3891
GEN     uu32toineg(ulong a, ulong b);
3892
GEN     vars_sort_inplace(GEN z);
3893
GEN     vars_to_RgXV(GEN h);
3894
GEN     variables_vecsmall(GEN x);
3895
GEN     variables_vec(GEN x);
3896

3897
/* genus2red.c */
3898

3899
GEN     genus2red(GEN PQ, GEN p);
3900

3901
/* groupid.c */
3902

3903
long    group_ident(GEN G, GEN S);
3904
long    group_ident_trans(GEN G, GEN S);
3905

3906
/* hash.c */
3907

3908
hashtable *hash_create_ulong(ulong s, long stack);
3909
hashtable *hash_create_str(ulong s, long stack);
3910
hashtable *hash_create(ulong minsize, ulong (*hash)(void*), int (*eq)(void*,void*), int use_stack);
3911
void    hash_dbg(hashtable *h);
3912
GEN     hash_haskey_GEN(hashtable *h, void *k);
3913
int     hash_haskey_long(hashtable *h, void *k, long *v);
3914
void    hash_init(hashtable *h, ulong minsize, ulong (*hash)(void*),
3915
                                int (*eq)(void*,void*), int use_stack);
3916
void    hash_init_GEN(hashtable *h, ulong minsize, int (*eq)(GEN,GEN), int use_stack);
3917
void    hash_init_ulong(hashtable *h, ulong minsize, int use_stack);
3918
void    hash_insert(hashtable *h, void *k, void *v);
3919
void    hash_insert_long(hashtable *h, void *k, long v);
3920
void    hash_insert2(hashtable *h, void *k, void *v, ulong hash);
3921
GEN     hash_keys(hashtable *h);
3922
GEN     hash_values(hashtable *h);
3923
hashentry *hash_search(hashtable *h, void *k);
3924
hashentry *hash_search2(hashtable *h, void *k, ulong hash);
3925
hashentry *hash_select(hashtable *h, void *k, void *E,int(*select)(void *,hashentry *));
3926
hashentry *hash_remove(hashtable *h, void *k);
3927
hashentry *hash_remove_select(hashtable *h, void *k, void *E, int (*select)(void*,hashentry*));
3928
void    hash_destroy(hashtable *h);
3929
ulong   hash_GEN(GEN x);
3930
ulong   hash_zv(GEN x);
3931

3932
/* hyperell.c */
3933

3934
GEN     hyperellpadicfrobenius0(GEN x, GEN p, long e);
3935
GEN     hyperellpadicfrobenius(GEN x, ulong p, long e);
3936
GEN     hyperellcharpoly(GEN x);
3937
GEN     nfhyperellpadicfrobenius(GEN H, GEN T, ulong p, long n);
3938

3939
/* hypergeom.c */
3940
GEN     hypergeom(GEN vnum, GEN vden, GEN z, long prec);
3941
GEN     airy(GEN z, long prec);
3942

3943
/* hnf_snf.c */
3944

3945
GEN     RgM_hnfall(GEN A, GEN *pB, long remove);
3946
GEN     ZM_hnf(GEN x);
3947
GEN     ZM_hnf_knapsack(GEN x);
3948
GEN     ZM_hnfall(GEN A, GEN *ptB, long remove);
3949
GEN     ZM_hnfall_i(GEN A, GEN *ptB, long remove);
3950
GEN     ZM_hnfcenter(GEN M);
3951
GEN     ZM_hnflll(GEN A, GEN *ptB, int remove);
3952
GEN     ZV_extgcd(GEN A);
3953
GEN     ZV_snfall(GEN D, GEN *pU, GEN *pV);
3954
GEN     ZV_snf_group(GEN d, GEN *newU, GEN *newUi);
3955
void    ZV_snf_trunc(GEN D);
3956
GEN     ZM_hnfmod(GEN x, GEN d);
3957
GEN     ZM_hnfmodall(GEN x, GEN dm, long flag);
3958
GEN     ZM_hnfmodall_i(GEN x, GEN dm, long flag);
3959
GEN     ZM_hnfmodid(GEN x, GEN d);
3960
GEN     ZM_hnfmodprime(GEN x, GEN p);
3961
GEN     ZM_hnfperm(GEN A, GEN *ptU, GEN *ptperm);
3962
void    ZM_snfclean(GEN d, GEN u, GEN v);
3963
GEN     ZM_snf(GEN x);
3964
GEN     ZM_snf_group(GEN H, GEN *newU, GEN *newUi);
3965
GEN     ZM_snfall(GEN x, GEN *ptU, GEN *ptV);
3966
GEN     ZM_snfall_i(GEN x, GEN *ptU, GEN *ptV, long flag);
3967
GEN     zlm_echelon(GEN x, long early_abort, ulong p, ulong pm);
3968
GEN     ZpM_echelon(GEN x, long early_abort, GEN p, GEN pm);
3969
GEN     gsmith(GEN x);
3970
GEN     gsmithall(GEN x);
3971
GEN     hnf(GEN x);
3972
GEN     hnf_divscale(GEN A, GEN B,GEN t);
3973
GEN     hnf_invscale(GEN A, GEN t);
3974
GEN     hnf_solve(GEN A, GEN B);
3975
GEN     hnf_invimage(GEN A, GEN b);
3976
GEN     hnfall(GEN x);
3977
int     hnfdivide(GEN A, GEN B);
3978
GEN     hnflll(GEN x);
3979
GEN     hnfmerge_get_1(GEN A, GEN B);
3980
GEN     hnfmod(GEN x, GEN d);
3981
GEN     hnfmodid(GEN x,GEN p);
3982
GEN     hnfperm(GEN x);
3983
GEN     matfrobenius(GEN M, long flag, long v);
3984
GEN     mathnf0(GEN x, long flag);
3985
GEN     matsnf0(GEN x, long flag);
3986
GEN     smith(GEN x);
3987
GEN     smithall(GEN x);
3988
GEN     smithclean(GEN z);
3989

3990
/* ifactor1.c */
3991

3992
GEN     Z_ECM(GEN N, long rounds, long seed, ulong B1);
3993
GEN     Z_factor(GEN n);
3994
GEN     Z_factor_limit(GEN n, ulong all);
3995
GEN     Z_factor_until(GEN n, GEN limit);
3996
long    Z_issmooth(GEN m, ulong lim);
3997
GEN     Z_issmooth_fact(GEN m, ulong lim);
3998
long    Z_issquarefree(GEN x);
3999
GEN     Z_pollardbrent(GEN n, long rounds, long seed);
4000
GEN     absZ_factor(GEN n);
4001
GEN     absZ_factor_limit(GEN n, ulong all);
4002
GEN     absZ_factor_limit_strict(GEN n, ulong all, GEN *pU);
4003
long    bigomega(GEN n);
4004
long    bigomegau(ulong n);
4005
GEN     core(GEN n);
4006
ulong   coreu(ulong n);
4007
ulong   coreu_fact(GEN f);
4008
GEN     eulerphi(GEN n);
4009
ulong   eulerphiu(ulong n);
4010
ulong   eulerphiu_fact(GEN f);
4011
GEN     factorint(GEN n, long flag);
4012
GEN     factoru(ulong n);
4013
int     ifac_isprime(GEN x);
4014
int     ifac_next(GEN *part, GEN *p, long *e);
4015
int     ifac_read(GEN part, GEN *p, long *e);
4016
void    ifac_skip(GEN part);
4017
GEN     ifac_start(GEN n, int moebius);
4018
int     is_357_power(GEN x, GEN *pt, ulong *mask);
4019
int     is_pth_power(GEN x, GEN *pt, forprime_t *T, ulong cutoffbits);
4020
long    ispowerful(GEN n);
4021
long    issquarefree(GEN x);
4022
long    istotient(GEN n, GEN *px);
4023
long    moebius(GEN n);
4024
long    moebiusu(ulong n);
4025
long    moebiusu_fact(GEN f);
4026
GEN     nextprime(GEN n);
4027
GEN     numdiv(GEN n);
4028
long    numdivu(long N);
4029
long    numdivu_fact(GEN fa);
4030
long    omega(GEN n);
4031
long    omegau(ulong n);
4032
GEN     precprime(GEN n);
4033
ulong   radicalu(ulong n);
4034
GEN     sumdiv(GEN n);
4035
GEN     sumdivk(GEN n,long k);
4036
ulong   tridiv_bound(GEN n);
4037
int     uis_357_power(ulong x, ulong *pt, ulong *mask);
4038
int     uis_357_powermod(ulong x, ulong *mask);
4039
long    uissquarefree(ulong n);
4040
long    uissquarefree_fact(GEN f);
4041
ulong   unextprime(ulong n);
4042
ulong   uprecprime(ulong n);
4043
GEN     vecfactorsquarefreeu(ulong a, ulong b);
4044
GEN     vecfactorsquarefreeu_coprime(ulong a, ulong b, GEN P);
4045
GEN     vecfactoru_i(ulong a, ulong b);
4046
GEN     vecfactoru(ulong a, ulong b);
4047
GEN     vecfactoroddu_i(ulong a, ulong b);
4048
GEN     vecfactoroddu(ulong a, ulong b);
4049
GEN     vecsquarefreeu(ulong a, ulong b);
4050

4051
/* init.c */
4052

4053
int     chk_gerepileupto(GEN x);
4054
GENbin* copy_bin(GEN x);
4055
GENbin* copy_bin_canon(GEN x);
4056
void    dbg_gerepile(pari_sp av);
4057
void    dbg_gerepileupto(GEN q);
4058
GEN     errname(GEN err);
4059
GEN     gclone(GEN x);
4060
GEN     gcloneref(GEN x);
4061
void    gclone_refc(GEN x);
4062
GEN     gcopy(GEN x);
4063
GEN     gcopy_avma(GEN x, pari_sp *AVMA);
4064
GEN     gcopy_lg(GEN x, long lx);
4065
GEN     gerepile(pari_sp ltop, pari_sp lbot, GEN q);
4066
void    gerepileallsp(pari_sp av, pari_sp tetpil, int n, ...);
4067
void    gerepilecoeffssp(pari_sp av, pari_sp tetpil, long *g, int n);
4068
void    gerepilemanysp(pari_sp av, pari_sp tetpil, GEN* g[], int n);
4069
GEN     getheap(void);
4070
void    gp_context_save(struct gp_context* rec);
4071
void    gp_context_restore(struct gp_context* rec);
4072
long    gsizeword(GEN x);
4073
long    gsizebyte(GEN x);
4074
void    gunclone(GEN x);
4075
void    gunclone_deep(GEN x);
4076
GEN     listcopy(GEN x);
4077
GEN     listinit(GEN x);
4078
void    msgtimer(const char *format, ...);
4079
long    name_numerr(const char *s);
4080
void    new_chunk_resize(size_t x);
4081
GEN     newblock(size_t n);
4082
const char * numerr_name(long errnum);
4083
GEN     obj_check(GEN S, long K);
4084
GEN     obj_checkbuild(GEN S, long tag, GEN (*build)(GEN));
4085
GEN     obj_checkbuild_padicprec(GEN S, long tag, GEN (*build)(GEN,long), long prec);
4086
GEN     obj_checkbuild_realprec(GEN S, long tag, GEN (*build)(GEN,long), long prec);
4087
GEN     obj_checkbuild_prec(GEN S, long tag, GEN (*build)(GEN,long), long (*pr)(GEN), long prec);
4088
void    obj_free(GEN S);
4089
GEN     obj_init(long d, long n);
4090
GEN     obj_insert(GEN S, long K, GEN O);
4091
GEN     obj_insert_shallow(GEN S, long K, GEN O);
4092
GEN     obj_reinit(GEN S);
4093
void    (*os_signal(int sig, void (*f)(int)))(int);
4094
void    pari_add_function(entree *ep);
4095
void    pari_add_module(entree *ep);
4096
void    pari_add_defaults_module(entree *ep);
4097
void    pari_close(void);
4098
void    pari_close_opts(ulong init_opts);
4099
GEN     pari_compile_str(const char *lex);
4100
int     pari_daemon(void);
4101
void    pari_err(int numerr, ...);
4102
GEN     pari_err_last(void);
4103
char *  pari_err2str(GEN err);
4104
void    pari_init_opts(size_t parisize, ulong maxprime, ulong init_opts);
4105
void    pari_init(size_t parisize, ulong maxprime);
4106
void    pari_stackcheck_init(void *pari_stack_base);
4107
void    pari_sighandler(int sig);
4108
void    pari_sig_init(void (*f)(int));
4109
void    pari_thread_alloc(struct pari_thread *t, size_t s, GEN arg);
4110
void    pari_thread_close(void);
4111
void    pari_thread_free(struct pari_thread *t);
4112
void    pari_thread_init(void);
4113
GEN     pari_thread_start(struct pari_thread *t);
4114
void    pari_thread_valloc(struct pari_thread *t, size_t s, size_t v, GEN arg);
4115
GEN     pari_version(void);
4116
void    pari_warn(int numerr, ...);
4117
void    paristack_newrsize(ulong newsize);
4118
void    paristack_resize(ulong newsize);
4119
void    paristack_setsize(size_t rsize, size_t vsize);
4120
void    parivstack_resize(ulong newsize);
4121
void    parivstack_reset(void);
4122
void    setalldebug(long lvl);
4123
GEN     setdebug(const char *s, long lvl);
4124
void    shiftaddress(GEN x, long dec);
4125
void    shiftaddress_canon(GEN x, long dec);
4126
long    timer(void);
4127
long    timer_delay(pari_timer *T);
4128
long    timer_get(pari_timer *T);
4129
void    timer_printf(pari_timer *T, const char *format, ...);
4130
void    timer_start(pari_timer *T);
4131
long    timer2(void);
4132
GEN     trap0(const char *e, GEN f, GEN r);
4133
void    traverseheap( void(*f)(GEN, void *), void *data );
4134
void    walltimer_start(pari_timer *ti);
4135
long    walltimer_delay(pari_timer *ti);
4136
long    walltimer_get(pari_timer *ti);
4137

4138
/* intnum.c */
4139

4140
GEN     contfraceval(GEN CF, GEN t, long nlim);
4141
GEN     contfracinit(GEN M, long lim);
4142
GEN     intcirc(void *E, GEN (*eval) (void *, GEN), GEN a, GEN R, GEN tab, long prec);
4143
GEN     intfuncinit(void *E, GEN (*eval) (void *, GEN), GEN a, GEN b, long m, long prec);
4144
GEN     intnum(void *E, GEN (*eval) (void *, GEN), GEN a, GEN b, GEN tab, long prec);
4145
GEN     intnumgauss(void *E, GEN (*eval)(void*, GEN), GEN a, GEN b, GEN tab, long prec);
4146
GEN     intnumgaussinit(long n, long prec);
4147
GEN     intnuminit(GEN a, GEN b, long m, long prec);
4148
GEN     intnumromb(void *E, GEN (*eval)(void *, GEN), GEN a, GEN b, long flag, long prec);
4149
GEN     intnumromb_bitprec(void *E, GEN (*eval)(void *, GEN), GEN a, GEN b, long flag, long bit);
4150
GEN     prodeulerrat(GEN F, GEN s, long a, long prec);
4151
GEN     prodnumrat(GEN F, long a, long prec);
4152
GEN     quodif(GEN M, long n);
4153
GEN     sumeulerrat(GEN F, GEN s, long a, long prec);
4154
GEN     sumnum(void *E, GEN (*eval)(void*, GEN), GEN a, GEN tab, long prec);
4155
GEN     sumnumap(void *E, GEN (*eval)(void*,GEN), GEN a, GEN tab, long prec);
4156
GEN     sumnumapinit(GEN fast, long prec);
4157
GEN     sumnuminit(GEN fast, long prec);
4158
GEN     sumnumlagrangeinit(GEN al, GEN c1, long prec);
4159
GEN     sumnumlagrange(void *E, GEN (*eval)(void*,GEN,long), GEN a, GEN tab, long prec);
4160
GEN     sumnummonien(void *E, GEN (*eval)(void*, GEN), GEN a, GEN tab, long prec);
4161
GEN     sumnummonieninit(GEN asymp, GEN w, GEN n0, long prec);
4162
GEN     sumnumrat(GEN F, GEN a, long prec);
4163

4164
/* krasner.c */
4165

4166
GEN     padicfields0(GEN p, GEN n, long flag);
4167
GEN     padicfields(GEN p, long m, long d, long flag);
4168

4169
/* kummer.c */
4170

4171
GEN     bnrclassfield(GEN bnr, GEN subgroup, long flag, long prec);
4172
GEN     rnfkummer(GEN bnr, GEN subgroup, long prec);
4173

4174
/* lfun.c */
4175

4176
long    is_linit(GEN data);
4177
GEN     ldata_get_an(GEN ldata);
4178
GEN     ldata_get_dual(GEN ldata);
4179
GEN     ldata_get_gammavec(GEN ldata);
4180
long    ldata_get_degree(GEN ldata);
4181
GEN     ldata_get_k(GEN ldata);
4182
GEN     ldata_get_k1(GEN ldata);
4183
GEN     ldata_get_conductor(GEN ldata);
4184
GEN     ldata_get_rootno(GEN ldata);
4185
GEN     ldata_get_residue(GEN ldata);
4186
long    ldata_get_type(GEN ldata);
4187
long    ldata_isreal(GEN ldata);
4188
long    linit_get_type(GEN linit);
4189
GEN     linit_get_ldata(GEN linit);
4190
GEN     linit_get_tech(GEN linit);
4191
GEN     lfun_get_domain(GEN tech);
4192
GEN     lfun_get_dom(GEN tech);
4193
long    lfun_get_bitprec(GEN tech);
4194
GEN     lfun_get_factgammavec(GEN tech);
4195
GEN     lfun_get_step(GEN tech);
4196
GEN     lfun_get_pol(GEN tech);
4197
GEN     lfun_get_Residue(GEN tech);
4198
GEN     lfun_get_k2(GEN tech);
4199
GEN     lfun_get_w2(GEN tech);
4200
GEN     lfun_get_expot(GEN tech);
4201
long    lfun_get_bitprec(GEN tech);
4202
GEN     lfun(GEN ldata, GEN s, long bitprec);
4203
GEN     lfun0(GEN ldata, GEN s, long der, long bitprec);
4204
GEN     lfunan(GEN ldata, long L, long prec);
4205
long    lfuncheckfeq(GEN data, GEN t0, long bitprec);
4206
GEN     lfunconductor(GEN data, GEN maxcond, long flag, long bitprec);
4207
GEN     lfuncost(GEN lmisc, GEN dom, long der, long bitprec);
4208
GEN     lfuncost0(GEN L, GEN dom, long der, long bitprec);
4209
GEN     lfuncreate(GEN obj);
4210
GEN     lfundual(GEN L, long bitprec);
4211
GEN     lfunparams(GEN ldata, long prec);
4212
GEN     lfunan(GEN ldata, long L, long prec);
4213
GEN     lfunhardy(GEN ldata, GEN t, long bitprec);
4214
GEN     lfuninit(GEN ldata, GEN dom, long der, long bitprec);
4215
GEN     lfuninit0(GEN ldata, GEN dom, long der, long bitprec);
4216
GEN     lfuninit_make(long t, GEN ldata, GEN tech, GEN domain);
4217
GEN     lfunlambda(GEN ldata, GEN s, long bitprec);
4218
GEN     lfunlambda0(GEN ldata, GEN s, long der, long bitprec);
4219
GEN     lfunmisc_to_ldata(GEN ldata);
4220
GEN     lfunmisc_to_ldata_shallow(GEN ldata);
4221
GEN     lfunmisc_to_ldata_shallow_i(GEN ldata);
4222
long    lfunorderzero(GEN ldata, long m, long bitprec);
4223
GEN     lfunprod_get_fact(GEN tech);
4224
GEN     lfunrootno(GEN data, long bitprec);
4225
GEN     lfunrootres(GEN data, long bitprec);
4226
GEN     lfunrtopoles(GEN r);
4227
GEN     lfunshift(GEN ldata, GEN s, long flag, long bitprec);
4228
GEN     lfuntwist(GEN ldata1, GEN ldata2, long bitprec);
4229
GEN     lfuntheta(GEN data, GEN t, long m, long bitprec);
4230
long    lfunthetacost0(GEN L, GEN tdom, long m, long bitprec);
4231
long    lfunthetacost(GEN ldata, GEN tdom, long m, long bitprec);
4232
GEN     lfunthetainit(GEN ldata, GEN tdom, long m, long bitprec);
4233
GEN     lfunthetacheckinit(GEN data, GEN tinf, long m, long bitprec);
4234
GEN     lfunzeros(GEN ldata, GEN lim, long divz, long bitprec);
4235
int     sdomain_isincl(double k, GEN dom, GEN dom0);
4236
GEN     theta_get_an(GEN tdata);
4237
GEN     theta_get_K(GEN tdata);
4238
GEN     theta_get_R(GEN tdata);
4239
long    theta_get_bitprec(GEN tdata);
4240
long    theta_get_m(GEN tdata);
4241
GEN     theta_get_tdom(GEN tdata);
4242
GEN     theta_get_isqrtN(GEN tdata);
4243
int     Vgaeasytheta(GEN Vga);
4244
GEN     znchargauss(GEN G, GEN chi, GEN a, long bitprec);
4245

4246
/* lfunutils.c */
4247

4248
GEN     dirzetak(GEN nf, GEN b);
4249
GEN     ellmoddegree(GEN e);
4250
GEN     eta_ZXn(long v, long L);
4251
GEN     eta_product_ZXn(GEN eta, long L);
4252
long    etaquotype(GEN *eta, GEN *pN, GEN *pk, GEN *CHI, long *pv, long *sd, long *cusp);
4253
GEN     galois_get_conj(GEN G); /* TODO move somewhere else? */
4254
GEN     ldata_vecan(GEN ldata, long L, long prec);
4255
GEN     ldata_newprec(GEN ldata, long prec);
4256
GEN     lfunabelianrelinit(GEN bnfabs, GEN bnf, GEN polrel, GEN dom, long der, long bitprec);
4257
GEN     lfunartin(GEN N, GEN G, GEN M, long o, long bitprec);
4258
GEN     lfundiv(GEN ldata1, GEN ldata2, long bitprec);
4259
GEN     lfunellmfpeters(GEN E, long bitprec);
4260
GEN     lfunetaquo(GEN eta);
4261
GEN     lfungenus2(GEN PS);
4262
GEN     lfunmfspec(GEN lmisc, long bitprec);
4263
GEN     lfunmul(GEN ldata1, GEN ldata2, long bitprec);
4264
GEN     lfunqf(GEN ldata, long prec);
4265
GEN     lfunsympow(GEN E, ulong m);
4266
GEN     lfunzetakinit(GEN pol, GEN dom, long der, long bitprec);
4267
long    qfiseven(GEN M);
4268

4269
/* lfunquad */
4270

4271
GEN lfunquadneg(long D, long k);
4272

4273
/* lll.c */
4274

4275
GEN     ZM_lll_norms(GEN x, double D, long flag, GEN *B);
4276
GEN     kerint(GEN x);
4277
GEN     lll(GEN x);
4278
GEN     lllfp(GEN x, double D, long flag);
4279
GEN     lllgen(GEN x);
4280
GEN     lllgram(GEN x);
4281
GEN     lllgramgen(GEN x);
4282
GEN     lllgramint(GEN x);
4283
GEN     lllgramkerim(GEN x);
4284
GEN     lllgramkerimgen(GEN x);
4285
GEN     lllint(GEN x);
4286
GEN     lllintpartial(GEN mat);
4287
GEN     lllintpartial_inplace(GEN mat);
4288
GEN     lllkerim(GEN x);
4289
GEN     lllkerimgen(GEN x);
4290
GEN     matkerint0(GEN x,long flag);
4291
GEN     qflll0(GEN x, long flag);
4292
GEN     qflllgram0(GEN x, long flag);
4293

4294
/* map.c */
4295

4296
GEN     gtomap(GEN M);
4297
void    mapdelete(GEN T, GEN a);
4298
GEN     mapdomain(GEN T);
4299
GEN     mapdomain_shallow(GEN T);
4300
GEN     mapget(GEN T, GEN a);
4301
int     mapisdefined(GEN T, GEN a, GEN *pt_z);
4302
void    mapput(GEN T, GEN a, GEN b);
4303
GEN     maptomat(GEN T);
4304
GEN     maptomat_shallow(GEN T);
4305

4306
/* matperm.c */
4307
GEN     matpermanent(GEN M);
4308
GEN     zm_permanent(GEN M);
4309
GEN     ZM_permanent(GEN M);
4310

4311
/* mellininv.c */
4312

4313
double  dbllemma526(double a, double b, double c, double B);
4314
double  dblcoro526(double a, double c, double B);
4315
GEN     gammamellininv(GEN Vga, GEN s, long m, long bitprec);
4316
GEN     gammamellininvasymp(GEN Vga, long nlimmax, long m);
4317
GEN     gammamellininvinit(GEN Vga, long m, long bitprec);
4318
GEN     gammamellininvrt(GEN K, GEN s, long bitprec);
4319

4320
/* members.c */
4321

4322
GEN     member_a1(GEN x);
4323
GEN     member_a2(GEN x);
4324
GEN     member_a3(GEN x);
4325
GEN     member_a4(GEN x);
4326
GEN     member_a6(GEN x);
4327
GEN     member_area(GEN x);
4328
GEN     member_b2(GEN x);
4329
GEN     member_b4(GEN x);
4330
GEN     member_b6(GEN x);
4331
GEN     member_b8(GEN x);
4332
GEN     member_bid(GEN x);
4333
GEN     member_bnf(GEN x);
4334
GEN     member_c4(GEN x);
4335
GEN     member_c6(GEN x);
4336
GEN     member_clgp(GEN x);
4337
GEN     member_codiff(GEN x);
4338
GEN     member_cyc(GEN clg);
4339
GEN     member_diff(GEN x);
4340
GEN     member_disc(GEN x);
4341
GEN     member_e(GEN x);
4342
GEN     member_eta(GEN x);
4343
GEN     member_f(GEN x);
4344
GEN     member_fu(GEN x);
4345
GEN     member_gen(GEN x);
4346
GEN     member_group(GEN x);
4347
GEN     member_index(GEN x);
4348
GEN     member_j(GEN x);
4349
GEN     member_mod(GEN x);
4350
GEN     member_nf(GEN x);
4351
GEN     member_no(GEN clg);
4352
GEN     member_omega(GEN x);
4353
GEN     member_orders(GEN x);
4354
GEN     member_p(GEN x);
4355
GEN     member_pol(GEN x);
4356
GEN     member_polabs(GEN x);
4357
GEN     member_reg(GEN x);
4358
GEN     member_r1(GEN x);
4359
GEN     member_r2(GEN x);
4360
GEN     member_roots(GEN x);
4361
GEN     member_sign(GEN x);
4362
GEN     member_t2(GEN x);
4363
GEN     member_tate(GEN x);
4364
GEN     member_tu(GEN x);
4365
GEN     member_zk(GEN x);
4366
GEN     member_zkst(GEN bid);
4367

4368
/* mftrace.c */
4369
enum { mf_NEW = 0, mf_CUSP, mf_OLD, mf_EISEN, mf_FULL };
4370
enum {
4371
/*leaves*/
4372
  t_MF_CONST, t_MF_EISEN, t_MF_Ek, t_MF_DELTA, t_MF_ETAQUO, t_MF_ELL,
4373
  t_MF_DIHEDRAL, t_MF_THETA, t_MF_TRACE, t_MF_NEWTRACE,
4374
/**/
4375
  t_MF_MUL, t_MF_POW, t_MF_DIV, t_MF_BRACKET, t_MF_LINEAR, t_MF_LINEAR_BHN,
4376
  t_MF_SHIFT, t_MF_DERIV, t_MF_DERIVE2, t_MF_TWIST, t_MF_HECKE,
4377
  t_MF_BD,
4378
};
4379

4380
GEN   MF_get_CHI(GEN mf);
4381
GEN   MF_get_M(GEN mf);
4382
GEN   MF_get_Mindex(GEN mf);
4383
GEN   MF_get_Minv(GEN mf);
4384
long  MF_get_N(GEN mf);
4385
GEN   MF_get_basis(GEN mf);
4386
long  MF_get_dim(GEN mf);
4387
GEN   MF_get_E(GEN mf);
4388
GEN   MF_get_fields(GEN mf);
4389
GEN   MF_get_gN(GEN mf);
4390
GEN   MF_get_gk(GEN mf);
4391
long  MF_get_k(GEN mf);
4392
GEN   MF_get_newforms(GEN mf);
4393
long  MF_get_r(GEN mf);
4394
long  MF_get_space(GEN mf);
4395
GEN   MF_get_S(GEN mf);
4396
GEN   MFcusp_get_vMjd(GEN mf);
4397
GEN   MFnew_get_vj(GEN mf);
4398
GEN   Qab_tracerel(GEN v, long t, GEN a);
4399
GEN   QabM_tracerel(GEN v, long t, GEN x);
4400
GEN   QabV_tracerel(GEN v, long t, GEN x);
4401
GEN   Qab_trace_init(long n, long m, GEN Pn, GEN Pm);
4402
GEN   checkMF(GEN mf);
4403
GEN   checkMF_i(GEN mf);
4404
int   checkmf_i(GEN mf);
4405
GEN   getcache(void);
4406
ulong hclassno6u(ulong d);
4407
ulong hclassno6u_from_cache(ulong D);
4408
GEN   lfunmf(GEN mf, GEN F, long bitprec);
4409
GEN   mfDelta(void);
4410
GEN   mfEH(GEN gk);
4411
GEN   mfEk(long k);
4412
GEN   mfTheta(GEN psi);
4413
GEN   mf_get_CHI(GEN F);
4414
long  mf_get_N(GEN F);
4415
GEN   mf_get_NK(GEN F);
4416
GEN   mf_get_field(GEN F);
4417
GEN   mf_get_gN(GEN F);
4418
GEN   mf_get_gk(GEN F);
4419
long  mf_get_k(GEN F);
4420
long  mf_get_r(GEN F);
4421
long  mf_get_type(GEN F);
4422
GEN   mfatkin(GEN mfa, GEN F);
4423
GEN   mfatkineigenvalues(GEN mf, long Q, long prec);
4424
GEN   mfatkininit(GEN mf, long Q, long prec);
4425
GEN   mfbasis(GEN mf, long space);
4426
GEN   mfbd(GEN F, long d);
4427
GEN   mfbracket(GEN F, GEN G, long m);
4428
long  mfcharorder(GEN CHI);
4429
long  mfcharmodulus(GEN CHI);
4430
GEN   mfcharpol(GEN CHI);
4431
GEN   mfcoef(GEN F, long n);
4432
GEN   mfcoefs(GEN F, long n, long d);
4433
long  mfconductor(GEN mf, GEN F);
4434
GEN   mfcosets(GEN N);
4435
long  mfcuspdim(long N, long k, GEN CHI);
4436
long  mfcuspisregular(GEN NK, GEN cusp);
4437
GEN   mfcusps(GEN gN);
4438
GEN   mfcuspval(GEN mf, GEN F, GEN cusp, long bitprec);
4439
long  mfcuspwidth(GEN gN, GEN cusp);
4440
GEN   mfderiv(GEN F, long m);
4441
GEN   mfderivE2(GEN F, long k);
4442
GEN   mfdescribe(GEN F, GEN *PTU);
4443
GEN   mfdim(GEN NK, long codespace);
4444
GEN   mfdiv(GEN F, GEN G);
4445
GEN   mfdiv_val(GEN F, GEN G, long vG);
4446
GEN   mfeigenbasis(GEN mf);
4447
GEN   mfeigensearch(GEN nklim, GEN vmod);
4448
GEN   mfeisenstein(long k, GEN CHI1, GEN CHI2);
4449
long  mfeisensteindim(long N, long k, GEN CHI);
4450
GEN   mfembed(GEN E, GEN f);
4451
GEN   mfembed0(GEN E, GEN v, long prec);
4452
GEN   mfeval(GEN mf, GEN F, GEN vtau, long bitprec);
4453
GEN   mffields(GEN mf);
4454
GEN   mffromell(GEN E);
4455
GEN   mffrometaquo(GEN eta, long flag);
4456
GEN   mffromlfun(GEN L, long prec);
4457
GEN   mffromqf(GEN Q, GEN P);
4458
long  mffulldim(long N, long k, GEN CHI);
4459
GEN   mfgaloisprojrep(GEN mf, GEN F, long prec);
4460
GEN   mfgaloistype(GEN NK, GEN F);
4461
GEN   mfhecke(GEN mf, GEN F, long n);
4462
GEN   mfheckemat(GEN mf, GEN vecn);
4463
GEN   mfinit(GEN NK, long space);
4464
GEN   mfisCM(GEN F);
4465
long  mfiscuspidal(GEN mf, GEN F);
4466
long  mfisequal(GEN F, GEN G, long lim);
4467
GEN   mfisetaquo(GEN F, long flag);
4468
GEN   mfkohnenbasis(GEN mf);
4469
GEN   mfkohnenbijection(GEN mf);
4470
GEN   mfkohneneigenbasis(GEN mf, GEN bij);
4471
GEN   mflinear(GEN vF, GEN vla);
4472
GEN   mfmanin(GEN F, long bitprec);
4473
GEN   mfmatembed(GEN E, GEN f);
4474
GEN   mfmul(GEN F, GEN G);
4475
long  mfnewdim(long N, long k, GEN CHI);
4476
long  mfolddim(long N, long k, GEN CHI);
4477
GEN   mfparams(GEN F);
4478
GEN   mfperiodpol(GEN mf, GEN F, long flag, long prec);
4479
GEN   mfperiodpolbasis(long k, long flag);
4480
GEN   mfpetersson(GEN FS, GEN GS);
4481
GEN   mfpow(GEN F, long n);
4482
GEN   mfsearch(GEN nklim, GEN V, long space);
4483
GEN   mfshift(GEN F, long sh);
4484
GEN   mfshimura(GEN mf, GEN F, long t);
4485
GEN   mfslashexpansion(GEN mf, GEN F, GEN gamma, long n, long flrat, GEN *param, long prec);
4486
long  mfspace(GEN mf, GEN f);
4487
GEN   mfsplit(GEN mf, long dimlim, long flag);
4488
long  mfsturm(GEN A);
4489
long  mfsturmNgk(long N, GEN k);
4490
long  mfsturmNk(long N, long k);
4491
long  mfsturm_mf(GEN mf);
4492
GEN   mfsymboleval(GEN F, GEN path, GEN ga, long bitprec);
4493
GEN   mfsymbol(GEN mf, GEN F, long bitprec);
4494
GEN   mftaylor(GEN F, long n, long flreal, long prec);
4495
GEN   mftobasis(GEN mf, GEN F, long flag);
4496
GEN   mftobasisES(GEN mf, GEN F);
4497
GEN   mftocol(GEN F, long lim, long d);
4498
GEN   mftocoset(ulong N, GEN M, GEN listcosets);
4499
GEN   mftonew(GEN mf, GEN F);
4500
GEN   mftraceform(GEN NK, long coderat);
4501
GEN   mftwist(GEN F, GEN D);
4502
GEN   mfvecembed(GEN E, GEN v);
4503
GEN   mfvectomat(GEN vF, long lim, long d);
4504

4505
/* mp.c */
4506

4507
ulong   Fl_inv(ulong x, ulong p);
4508
ulong   Fl_invsafe(ulong x, ulong p);
4509
int     Fp_ratlift(GEN x, GEN m, GEN amax, GEN bmax, GEN *a, GEN *b);
4510
GEN     ZM2_mul(GEN A, GEN B);
4511
int     abscmpii(GEN x, GEN y);
4512
int     abscmprr(GEN x, GEN y);
4513
int     absequalii(GEN x, GEN y);
4514
GEN     addii_sign(GEN x, long sx, GEN y, long sy);
4515
GEN     addir_sign(GEN x, long sx, GEN y, long sy);
4516
GEN     addmulii(GEN x, GEN y, GEN z);
4517
GEN     addmulii_inplace(GEN x, GEN y, GEN z);
4518
GEN     addrr_sign(GEN x, long sx, GEN y, long sy);
4519
GEN     addsi_sign(long x, GEN y, long sy);
4520
GEN     addsr(long x, GEN y);
4521
GEN     addui_sign(ulong x, GEN y, long sy);
4522
GEN     addumului(ulong a, ulong b, GEN Y);
4523
void    affir(GEN x, GEN y);
4524
void    affrr(GEN x, GEN y);
4525
GEN     bezout(GEN a, GEN b, GEN *u, GEN *v);
4526
long    cbezout(long a,long b,long *uu,long *vv);
4527
long    cgcd(long a,long b);
4528
long    clcm(long a,long b);
4529
int     cmpii(GEN x, GEN y);
4530
int     cmprr(GEN x, GEN y);
4531
long    dblexpo(double x);
4532
ulong   dblmantissa(double x);
4533
GEN     dbltor(double x);
4534
GEN     diviiexact(GEN x, GEN y);
4535
GEN     divir(GEN x, GEN y);
4536
GEN     divis(GEN y, long x);
4537
GEN     divis_rem(GEN x, long y, long *rem);
4538
GEN     absdiviu_rem(GEN y, ulong x, ulong *rem);
4539
GEN     diviuuexact(GEN x, ulong y, ulong z);
4540
GEN     diviuexact(GEN x, ulong y);
4541
GEN     divri(GEN x, GEN y);
4542
GEN     divrr(GEN x, GEN y);
4543
GEN     divrs(GEN x, long y);
4544
GEN     divru(GEN x, ulong y);
4545
GEN     divsi(long x, GEN y);
4546
GEN     divsr(long x, GEN y);
4547
GEN     divur(ulong x, GEN y);
4548
GEN     dvmdii(GEN x, GEN y, GEN *z);
4549
int     equalii(GEN x, GEN y);
4550
int     equalrr(GEN x, GEN y);
4551
GEN     floorr(GEN x);
4552
GEN     gcdii(GEN x, GEN y);
4553
GEN     halfgcdii(GEN x, GEN y);
4554
GEN     int2n(long n);
4555
GEN     int2u(ulong n);
4556
GEN     int2um1(ulong n);
4557
GEN     int_normalize(GEN x, long known_zero_words);
4558
int     invmod(GEN a, GEN b, GEN *res);
4559
ulong   invmod2BIL(ulong b);
4560
GEN     invr(GEN b);
4561
GEN     mantissa_real(GEN x, long *e);
4562
GEN     modii(GEN x, GEN y);
4563
void    modiiz(GEN x, GEN y, GEN z);
4564
GEN     mulii(GEN x, GEN y);
4565
GEN     mulir(GEN x, GEN y);
4566
GEN     mulrr(GEN x, GEN y);
4567
GEN     mulsi(long x, GEN y);
4568
GEN     mulsr(long x, GEN y);
4569
GEN     mulss(long x, long y);
4570
GEN     mului(ulong x, GEN y);
4571
GEN     mulur(ulong x, GEN y);
4572
GEN     muluu(ulong x, ulong y);
4573
GEN     muluui(ulong x, ulong y, GEN z);
4574
void    pari_kernel_close(void);
4575
void    pari_kernel_init(void);
4576
const char * pari_kernel_version(void);
4577
GEN     remi2n(GEN x, long n);
4578
double  rtodbl(GEN x);
4579
GEN     shifti(GEN x, long n);
4580
GEN     sqri(GEN x);
4581
GEN     sqrr(GEN x);
4582
GEN     sqrs(long x);
4583
GEN     sqrtr_abs(GEN x);
4584
GEN     sqrtremi(GEN S, GEN *R);
4585
GEN     sqru(ulong x);
4586
GEN     subsr(long x, GEN y);
4587
GEN     truedvmdii(GEN x, GEN y, GEN *z);
4588
GEN     truedvmdis(GEN x, long y, GEN *z);
4589
GEN     truedvmdsi(long x, GEN y, GEN *z);
4590
GEN     trunc2nr(GEN x, long n);
4591
GEN     mantissa2nr(GEN x, long n);
4592
GEN     truncr(GEN x);
4593
ulong   ugcd(ulong a,ulong b);
4594
ulong   ulcm(ulong a, ulong b);
4595
ulong   umodiu(GEN y, ulong x);
4596
long    vals(ulong x);
4597

4598
/* nffactor.c */
4599

4600
GEN     FpC_ratlift(GEN P, GEN mod, GEN amax, GEN bmax, GEN denom);
4601
GEN     FpM_ratlift(GEN M, GEN mod, GEN amax, GEN bmax, GEN denom);
4602
GEN     FpX_ratlift(GEN P, GEN mod, GEN amax, GEN bmax, GEN denom);
4603
GEN     QXQX_gcd(GEN P, GEN Q, GEN T);
4604
GEN     ZXQX_gcd(GEN P, GEN Q, GEN T);
4605
GEN     nffactor(GEN nf,GEN x);
4606
GEN     nffactormod(GEN nf,GEN pol,GEN pr);
4607
GEN     nfgcd(GEN P, GEN Q, GEN nf, GEN den);
4608
GEN     nfgcd_all(GEN P, GEN Q, GEN T, GEN den, GEN *Pnew);
4609
int     nfissquarefree(GEN nf, GEN x);
4610
GEN     nfroots(GEN nf,GEN pol);
4611
GEN     nfroots_if_split(GEN *pnf, GEN pol);
4612
GEN     polfnf(GEN a, GEN t);
4613
GEN     nfrootsof1(GEN x);
4614

4615
/* paricfg.c */
4616

4617
extern const char *paricfg_datadir;
4618
extern const char *paricfg_version;
4619
extern const char *paricfg_buildinfo;
4620
extern const long  paricfg_version_code;
4621
extern const char *paricfg_vcsversion;
4622
extern const char *paricfg_compiledate;
4623
extern const char *paricfg_mt_engine;
4624
extern const char *paricfg_gphelp;
4625

4626
/* part.c */
4627

4628
void    forpart(void *E, long call(void*,GEN), long k, GEN nbound, GEN abound);
4629
void    forpart_init(forpart_t *T, long k, GEN abound, GEN nbound);
4630
GEN     forpart_next(forpart_t *T);
4631
GEN     forpart_prev(forpart_t *T);
4632
GEN     numbpart(GEN x);
4633
GEN     partitions(long k, GEN nbound, GEN abound);
4634

4635
/* forperm.c */
4636

4637
void    forperm(void *E, long call(void *, GEN), GEN k);
4638
void    forperm_init(forperm_t *T, GEN k);
4639
GEN     forperm_next(forperm_t *T);
4640

4641
/* forsubset.c */
4642

4643
void forallsubset_init(forsubset_t *T, long n);
4644
void forksubset_init(forsubset_t *T, long n, long k);
4645
GEN forsubset_next(forsubset_t *T);
4646
void forsubset_init(forsubset_t *T, GEN nk);
4647

4648
/* lambert.c */
4649

4650
GEN     glambertW(GEN y, long branch, long prec);
4651
GEN     mplambertW(GEN y, long prec);
4652
GEN     mplambertX(GEN y, long bit);
4653
GEN     mplambertx_logx(GEN a, GEN b, long bit);
4654
GEN     mplambertxlogx_x(GEN a, GEN b, long bit);
4655

4656
/* perm.c */
4657

4658
GEN     Z_to_perm(long n, GEN x);
4659
GEN     abelian_group(GEN G);
4660
GEN     conjclasses_repr(GEN conj, long nb);
4661
GEN     cyc_pow(GEN cyc, long exp);
4662
GEN     cyc_pow_perm(GEN cyc, long exp);
4663
GEN     cyclicgroup(GEN g, long s);
4664
GEN     dicyclicgroup(GEN g1, GEN g2, long s1, long s2);
4665
GEN     group_abelianHNF(GEN G, GEN L);
4666
GEN     group_abelianSNF(GEN G, GEN L);
4667
long    group_domain(GEN G);
4668
GEN     group_elts(GEN G, long n);
4669
GEN     group_export(GEN G, long format);
4670
GEN     group_export_GAP(GEN G);
4671
GEN     group_export_MAGMA(GEN G);
4672
long    group_isA4S4(GEN G);
4673
long    group_isabelian(GEN G);
4674
GEN     group_leftcoset(GEN G, GEN g);
4675
long    group_order(GEN G);
4676
long    group_perm_normalize(GEN N, GEN g);
4677
GEN     group_quotient(GEN G, GEN H);
4678
GEN     group_rightcoset(GEN G, GEN g);
4679
GEN     group_set(GEN G, long n);
4680
int     group_subgroup_is_faithful(GEN G, GEN H);
4681
long    group_subgroup_isnormal(GEN G, GEN H);
4682
GEN     group_subgroups(GEN G);
4683
GEN     group_to_cc(GEN G);
4684
GEN     groupelts_abelian_group(GEN S);
4685
GEN     groupelts_center(GEN S);
4686
GEN     groupelts_conj_set(GEN elts, GEN p);
4687
GEN     groupelts_conjclasses(GEN elts, long *nbcl);
4688
long    groupelts_exponent(GEN G);
4689
GEN     groupelts_quotient(GEN G, GEN H);
4690
GEN     groupelts_set(GEN G, long n);
4691
GEN     groupelts_to_group(GEN G);
4692
GEN     numtoperm(long n, GEN x);
4693
int     perm_commute(GEN p, GEN q);
4694
GEN     perm_cycles(GEN v);
4695
GEN     perm_order(GEN perm);
4696
ulong   perm_orderu(GEN perm);
4697
GEN     perm_pow(GEN perm, GEN exp);
4698
GEN     perm_powu(GEN perm, ulong exp);
4699
long    perm_sign(GEN perm);
4700
GEN     perm_to_GAP(GEN v);
4701
GEN     perm_to_Z(GEN v);
4702
GEN     permcycles(GEN perm);
4703
GEN     permorder(GEN perm);
4704
long    permsign(GEN perm);
4705
GEN     permtonum(GEN x);
4706
GEN     quotient_group(GEN C, GEN G);
4707
GEN     quotient_groupelts(GEN C);
4708
GEN     quotient_perm(GEN C, GEN p);
4709
GEN     quotient_subgroup_lift(GEN C, GEN H, GEN S);
4710
GEN     subgroups_tableset(GEN S, long n);
4711
long    tableset_find_index(GEN tbl, GEN set);
4712
GEN     trivialgroup(void);
4713
GEN     vec_insert(GEN v, long n, GEN x);
4714
int     vec_is1to1(GEN v);
4715
int     vec_isconst(GEN v);
4716
GEN     vecperm_orbits(GEN v, long n);
4717
long    vecsmall_duplicate(GEN x);
4718
long    vecsmall_duplicate_sorted(GEN x);
4719
GEN     vecsmall_indexsort(GEN V);
4720
int     vecsmall_is1to1(GEN v);
4721
int     vecsmall_isconst(GEN v);
4722
void    vecsmall_sort(GEN V);
4723
GEN     vecsmall_uniq(GEN V);
4724
GEN     vecsmall_uniq_sorted(GEN V);
4725
GEN     vecvecsmall_indexsort(GEN x);
4726
long    vecvecsmall_max(GEN x);
4727
long    vecvecsmall_search(GEN x, GEN y);
4728
GEN     vecvecsmall_sort(GEN x);
4729
void    vecvecsmall_sort_inplace(GEN x, GEN *perm);
4730
GEN     vecvecsmall_sort_shallow(GEN x);
4731
GEN     vecvecsmall_sort_uniq(GEN x);
4732

4733
/* mt.c */
4734

4735
void    mt_broadcast(GEN code);
4736
long    mt_nbthreads(void);
4737
void    mt_queue_end(struct pari_mt *pt);
4738
GEN     mt_queue_get(struct pari_mt *pt, long *jobid, long *pending);
4739
void    mt_queue_start(struct pari_mt *pt, GEN worker);
4740
void    mt_queue_start_lim(struct pari_mt *pt, GEN worker, long lim);
4741
void    mt_queue_submit(struct pari_mt *pt, long jobid, GEN work);
4742
void    mt_sigint_block(void);
4743
void    mt_sigint_unblock(void);
4744
void    pari_mt_init(void);
4745
void    pari_mt_close(void);
4746

4747
/* plotport.c */
4748

4749
void    color_to_rgb(GEN c, int *r, int *g, int *b);
4750
void    colorname_to_rgb(const char *s, int *r, int *g, int *b);
4751
void    long_to_rgb(long c, int *r, int *g, int *b);
4752
void    pari_plot_by_file(const char *env, const char *suf, const char *img);
4753
void    pari_set_plot_engine(void (*plot)(PARI_plot *));
4754
void    pari_kill_plot_engine(void);
4755
GEN     parploth(GEN a, GEN b, GEN code, long flags,long n, long prec);
4756
GEN     parplothexport(GEN fmt, GEN a, GEN b, GEN code, long flags, long n, long prec);
4757
void    plotbox(long ne, GEN gx2, GEN gy2, long fl);
4758
void    plotclip(long rect);
4759
GEN     plotcolor(long ne, GEN c);
4760
void    plotcopy(long source, long dest, GEN xoff, GEN yoff, long flag);
4761
GEN     plotcursor(long ne);
4762
void    plotdraw(GEN list, long flag);
4763
GEN     plotexport(GEN fmt, GEN wxy, long flag);
4764
GEN     ploth(void *E, GEN(*f)(void*,GEN), GEN a, GEN b, long flags,long n, long prec);
4765
GEN     plothexport(GEN fmt, void *E, GEN(*f)(void*,GEN), GEN a,GEN b, long flags, long n, long prec);
4766
GEN     plothraw(GEN listx, GEN listy, long flag);
4767
GEN     plothrawexport(GEN fmt, GEN X, GEN Y, long flags);
4768
GEN     plothsizes(long flag);
4769
void    plotinit(long ne, GEN x, GEN y, long flag);
4770
void    plotkill(long ne);
4771
void    plotline(long ne, GEN gx2, GEN gy2);
4772
void    plotlines(long ne, GEN listx, GEN listy, long flag);
4773
void    plotlinetype(long ne, long t);
4774
void    plotmove(long ne, GEN x, GEN y);
4775
void    plotpoints(long ne, GEN listx, GEN listy);
4776
void    plotpointsize(long ne, GEN size);
4777
void    plotpointtype(long ne, long t);
4778
void    plotrbox(long ne, GEN x2, GEN y2, long fl);
4779
GEN     plotrecth(void *E, GEN(*f)(void*,GEN), long ne, GEN a,GEN b, ulong flags,long n, long prec);
4780
GEN     plotrecthraw(long ne, GEN data, long flags);
4781
void    plotrline(long ne, GEN x2, GEN y2);
4782
void    plotrmove(long ne, GEN x, GEN y);
4783
void    plotrpoint(long ne, GEN x, GEN y);
4784
void    plotscale(long ne, GEN x1, GEN x2, GEN y1, GEN y2);
4785
void    plotstring(long ne, char *x, long dir);
4786
void    psdraw(GEN list, long flag);
4787
GEN     psploth(void *E, GEN(*f)(void*,GEN), GEN a, GEN b, long flags, long n, long prec);
4788
GEN     psplothraw(GEN listx, GEN listy, long flag);
4789
char*   rect2ps(GEN w, GEN x, GEN y, PARI_plot *T);
4790
char*   rect2ps_i(GEN w, GEN x, GEN y, PARI_plot *T, int plotps);
4791
char*   rect2svg(GEN w, GEN x, GEN y, PARI_plot *T);
4792

4793
/* plottty.c */
4794

4795
void    pariplot(void* E, GEN (*fun)(void *E, GEN x), GEN a, GEN b, GEN ysmlu,GEN ybigu, long prec);
4796

4797
/* polarit1.c */
4798

4799
GEN     ZX_Zp_root(GEN f, GEN a, GEN p, long prec);
4800
GEN     Zp_appr(GEN f, GEN a);
4801
int     cmp_padic(GEN x, GEN y);
4802
GEN     factorpadic(GEN x, GEN p, long r);
4803
GEN     gdeuc(GEN x, GEN y);
4804
GEN     grem(GEN x, GEN y);
4805
GEN     padicappr(GEN f, GEN a);
4806
GEN     poldivrem(GEN x, GEN y, GEN *pr);
4807
GEN     polrootspadic(GEN f, GEN p, long r);
4808

4809
/* polarit2.c */
4810

4811
ulong   Flv_factorback(GEN L, GEN e, ulong p);
4812
GEN     FlxqV_factorback(GEN L, GEN e, GEN Tp, ulong p);
4813
GEN     FpV_factorback(GEN L, GEN e, GEN p);
4814
GEN     FqV_factorback(GEN L, GEN e, GEN Tp, GEN p);
4815
GEN     Q_content(GEN x);
4816
GEN     Q_content_safe(GEN x);
4817
GEN     Q_denom(GEN x);
4818
GEN     Q_denom_safe(GEN x);
4819
GEN     Q_div_to_int(GEN x, GEN c);
4820
GEN     Q_gcd(GEN x, GEN y);
4821
GEN     Q_mul_to_int(GEN x, GEN c);
4822
GEN     Q_muli_to_int(GEN x, GEN d);
4823
GEN     Q_primitive_part(GEN x, GEN *ptc);
4824
GEN     Q_primpart(GEN x);
4825
GEN     Q_remove_denom(GEN x, GEN *ptd);
4826
GEN     Q_factor(GEN x);
4827
GEN     Q_factor_limit(GEN x, ulong lim);
4828
long    Rg_type(GEN x, GEN *ptp, GEN *ptpol, long *ptpa);
4829
long    RgM_RgC_type(GEN x, GEN y, GEN *p, GEN *pol, long *pa);
4830
GEN     RgM_rescale_to_int(GEN x);
4831
long    RgM_type(GEN x, GEN *p, GEN *pol, long *pa);
4832
long    RgM_type2(GEN x, GEN y, GEN *p, GEN *pol, long *pa);
4833
long    RgV_type(GEN x, GEN *p, GEN *pol, long *pa);
4834
long    RgV_type2(GEN x, GEN y, GEN *p, GEN *pol, long *pa);
4835
long    RgX_Rg_type(GEN x, GEN y, GEN *p, GEN *pol, long *pa);
4836
GEN     RgX_chinese_coprime(GEN x, GEN y, GEN Tx, GEN Ty, GEN Tz);
4837
GEN     RgX_disc(GEN x);
4838
GEN     RgX_extgcd(GEN x, GEN y, GEN *U, GEN *V);
4839
GEN     RgX_extgcd_simple(GEN a, GEN b, GEN *pu, GEN *pv);
4840
GEN     RgX_gcd(GEN x, GEN y);
4841
GEN     RgX_gcd_simple(GEN x, GEN y);
4842
GEN     RgX_halfgcd(GEN x, GEN y);
4843
GEN     RgX_rescale_to_int(GEN x);
4844
GEN     RgX_resultant_all(GEN P, GEN Q, GEN *sol);
4845
long    RgX_sturmpart(GEN x, GEN ab);
4846
GEN     RgX_sylvestermatrix(GEN x, GEN y);
4847
long    RgX_type(GEN x, GEN *ptp, GEN *ptpol, long *ptpa);
4848
long    RgX_type2(GEN x, GEN y, GEN *ptp, GEN *ptpol, long *ptpa);
4849
long    RgX_type3(GEN x, GEN y, GEN z, GEN *ptp, GEN *ptpol, long *ptpa);
4850
void    RgX_type_decode(long x, long *t1, long *t2);
4851
int     RgX_type_is_composite(long t);
4852
GEN     RgXQ_charpoly(GEN x, GEN T, long v);
4853
GEN     RgXQ_inv(GEN x, GEN y);
4854
GEN     RgXQ_mul(GEN x, GEN y, GEN T);
4855
int     RgXQ_ratlift(GEN y, GEN x, long amax, long bmax, GEN *P, GEN *Q);
4856
GEN     RgXQ_sqr(GEN x, GEN y);
4857
GEN     Z_content(GEN x);
4858
GEN     ZX_content(GEN x);
4859
GEN     centermod(GEN x, GEN p);
4860
GEN     centermod_i(GEN x, GEN p, GEN ps2);
4861
GEN     centermodii(GEN x, GEN p, GEN po2);
4862
GEN     content(GEN x);
4863
GEN     content0(GEN x, GEN D);
4864
GEN     deg1_from_roots(GEN L, long v);
4865
GEN     factor(GEN x);
4866
GEN     factor0(GEN x, GEN flag);
4867
GEN     factorback(GEN fa);
4868
GEN     factorback2(GEN fa,GEN e);
4869
GEN     gbezout(GEN x, GEN y, GEN *u, GEN *v);
4870
GEN     gdivexact(GEN x, GEN y);
4871
GEN     gen_factorback(GEN L, GEN e, void *E, GEN (*_mul)(void*,GEN,GEN),
4872
                                              GEN (*_pow)(void*,GEN,GEN),
4873
                                              GEN (*_one)(void*));
4874
GEN     ggcd(GEN x, GEN y);
4875
GEN     ggcd0(GEN x, GEN y);
4876
GEN     ghalfgcd(GEN x, GEN y);
4877
GEN     ginvmod(GEN x, GEN y);
4878
GEN     glcm(GEN x, GEN y);
4879
GEN     glcm0(GEN x, GEN y);
4880
GEN     idealfactorback(GEN nf, GEN L, GEN e, int red);
4881
GEN     newtonpoly(GEN x, GEN p);
4882
GEN     nffactorback(GEN nf, GEN L, GEN e);
4883
GEN     nfrootsQ(GEN x);
4884
GEN     poldisc0(GEN x, long v);
4885
long    polisirreducible(GEN x);
4886
GEN     polresultant0(GEN x, GEN y,long v,long flag);
4887
GEN     polsym(GEN x, long n);
4888
GEN     primitive_part(GEN x, GEN *c);
4889
GEN     primpart(GEN x);
4890
GEN     reduceddiscsmith(GEN pol);
4891
GEN     resultant2(GEN x, GEN y);
4892
GEN     resultant(GEN u, GEN v);
4893
GEN     rnfcharpoly(GEN nf, GEN T, GEN alpha, long v);
4894
GEN     roots_from_deg1(GEN x);
4895
GEN     roots_to_pol(GEN a, long v);
4896
GEN     roots_to_pol_r1(GEN a, long v, long r1);
4897
long    sturmpart(GEN x, GEN a, GEN b);
4898
GEN     subresext(GEN x, GEN y, GEN *U, GEN *V);
4899
GEN     sylvestermatrix(GEN x,GEN y);
4900
GEN     trivial_fact(void);
4901
GEN     gcdext0(GEN x, GEN y);
4902
GEN     polresultantext0(GEN x, GEN y, long v);
4903
GEN     polresultantext(GEN x, GEN y);
4904
GEN     prime_fact(GEN x);
4905
GEN     row_Q_primpart(GEN M);
4906
GEN     vec_Q_primpart(GEN M);
4907
GEN     vecprod(GEN v);
4908
GEN     ZV_lcm(GEN x);
4909

4910
/* polarit3.c */
4911

4912
GEN     Flx_FlxY_resultant(GEN a, GEN b, ulong p);
4913
GEN     FlxX_resultant(GEN u, GEN v, ulong p, long sx);
4914
GEN     FpX_FpXY_resultant(GEN a, GEN b0, GEN p);
4915
GEN     FpX_translate(GEN P, GEN c, GEN p);
4916
GEN     FpXQX_normalize(GEN z, GEN T, GEN p);
4917
GEN     FpXV_FpC_mul(GEN V, GEN W, GEN p);
4918
GEN     FpXY_FpXQ_evaly(GEN Q, GEN y, GEN T, GEN p, long vx);
4919
GEN     FpXC_center(GEN C, GEN p, GEN pov2);
4920
GEN     FpXM_center(GEN M, GEN p, GEN pov2);
4921
GEN     Fq_Fp_mul(GEN x, GEN y, GEN T, GEN p);
4922
GEN     Fq_add(GEN x, GEN y, GEN T/*unused*/, GEN p);
4923
GEN     Fq_div(GEN x, GEN y, GEN T, GEN p);
4924
GEN     Fq_halve(GEN x, GEN T/*unused*/, GEN p);
4925
GEN     Fq_inv(GEN x, GEN T, GEN p);
4926
GEN     Fq_invsafe(GEN x, GEN T, GEN p);
4927
GEN     Fq_mul(GEN x, GEN y, GEN T, GEN p);
4928
GEN     Fq_mulu(GEN x, ulong y, /*unused*/GEN T, GEN p);
4929
GEN     Fq_neg(GEN x, GEN T, GEN p);
4930
GEN     Fq_neg_inv(GEN x, GEN T, GEN p);
4931
GEN     Fq_pow(GEN x, GEN n, GEN T, GEN p);
4932
GEN     Fq_powu(GEN x, ulong n, GEN pol, GEN p);
4933
GEN     Fq_sqr(GEN x, GEN T, GEN p);
4934
GEN     Fq_sqrt(GEN x, GEN T, GEN p);
4935
GEN     Fq_sqrtn(GEN x, GEN n, GEN T, GEN p, GEN *zeta);
4936
GEN     Fq_sub(GEN x, GEN y, GEN T/*unused*/, GEN p);
4937
GEN     FqC_Fq_mul(GEN x, GEN y, GEN T, GEN p);
4938
GEN     FqC_FqV_mul(GEN x, GEN y, GEN T, GEN p);
4939
GEN     FqC_add(GEN x, GEN y, GEN T, GEN p);
4940
GEN     FqC_sub(GEN x, GEN y, GEN T, GEN p);
4941
GEN     FqV_red(GEN z, GEN T, GEN p);
4942
GEN     FqV_roots_to_pol(GEN V, GEN T, GEN p, long v);
4943
GEN     FqX_Fq_add(GEN y, GEN x, GEN T, GEN p);
4944
GEN     FqX_Fq_mul_to_monic(GEN P, GEN U, GEN T, GEN p);
4945
GEN     FqX_Fq_sub(GEN y, GEN x, GEN T, GEN p);
4946
GEN     FqX_eval(GEN x, GEN y, GEN T, GEN p);
4947
GEN     FqX_translate(GEN P, GEN c, GEN T, GEN p);
4948
GEN     FqXQ_matrix_pow(GEN y, long n, long m, GEN S, GEN T, GEN p);
4949
GEN     FqXQ_powers(GEN x, long l, GEN S, GEN T, GEN p);
4950
GEN     FqXY_eval(GEN Q, GEN y, GEN x, GEN T, GEN p);
4951
GEN     FqXY_evalx(GEN Q, GEN x, GEN T, GEN p);
4952
GEN     QX_disc(GEN x);
4953
GEN     QX_gcd(GEN a,GEN b);
4954
GEN     QX_resultant(GEN A, GEN B);
4955
GEN     QXQ_div(GEN A, GEN B, GEN C);
4956
GEN     QXQ_intnorm(GEN A, GEN B);
4957
GEN     QXQ_inv(GEN A, GEN B);
4958
GEN     QXQ_mul(GEN A, GEN B, GEN T);
4959
GEN     QXQ_norm(GEN A, GEN B);
4960
GEN     QXQ_sqr(GEN A, GEN B);
4961
int     Rg_is_Fp(GEN x, GEN *p);
4962
int     Rg_is_FpXQ(GEN x, GEN *pT, GEN *pp);
4963
GEN     Rg_to_Fp(GEN x, GEN p);
4964
GEN     Rg_to_FpXQ(GEN x, GEN T, GEN p);
4965
GEN     RgC_to_FpC(GEN x, GEN p);
4966
GEN     RgC_to_FqC(GEN x, GEN T, GEN p);
4967
int     RgM_is_FpM(GEN x, GEN *p);
4968
GEN     RgM_to_Flm(GEN x, ulong p);
4969
GEN     RgM_to_FpM(GEN x, GEN p);
4970
GEN     RgM_to_FqM(GEN x, GEN T, GEN p);
4971
int     RgV_is_FpV(GEN x, GEN *p);
4972
GEN     RgV_to_Flv(GEN x, ulong p);
4973
GEN     RgV_to_FpV(GEN x, GEN p);
4974
int     RgX_is_FpX(GEN x, GEN *p);
4975
GEN     RgX_to_FpX(GEN x, GEN p);
4976
int     RgX_is_FpXQX(GEN x, GEN *pT, GEN *pp);
4977
GEN     RgX_to_FpXQX(GEN x, GEN T, GEN p);
4978
GEN     RgX_to_FqX(GEN x, GEN T, GEN p);
4979
int     Z_incremental_CRT(GEN *H, ulong Hp, GEN *q, ulong p);
4980
GEN     Z_init_CRT(ulong Hp, ulong p);
4981
int     ZM_incremental_CRT(GEN *H, GEN Hp, GEN *q, ulong p);
4982
GEN     ZM_init_CRT(GEN Hp, ulong p);
4983
GEN     ZX_ZXY_resultant(GEN a, GEN b);
4984
GEN     ZX_ZXY_rnfequation(GEN A, GEN B, long *lambda);
4985
GEN     ZX_disc(GEN x);
4986
GEN     ZX_gcd(GEN A, GEN B);
4987
GEN     ZX_gcd_all(GEN A, GEN B, GEN *Anew);
4988
int     ZX_incremental_CRT(GEN *ptH, GEN Hp, GEN *q, ulong p);
4989
GEN     ZX_init_CRT(GEN Hp, ulong p, long v);
4990
int     ZX_is_squarefree(GEN x);
4991
GEN     ZX_radical(GEN A);
4992
GEN     ZX_resultant(GEN A, GEN B);
4993
int     ZXM_incremental_CRT(GEN *pH, GEN Hp, GEN *ptq, ulong p);
4994
GEN     ZXM_init_CRT(GEN Hp, long deg, ulong p);
4995
GEN     ZXQ_minpoly(GEN A, GEN T, long d, ulong b);
4996
GEN     ZXQ_charpoly(GEN A, GEN T, long v);
4997
GEN     characteristic(GEN x);
4998
GEN     ffinit(GEN p, long n, long v);
4999
GEN     ffnbirred(GEN p, long n);
5000
GEN     ffnbirred0(GEN p, long n, long flag);
5001
GEN     ffsumnbirred(GEN p, long n);
5002
const struct bb_field *get_Fq_field(void **E, GEN T, GEN p);
5003
GEN     init_Flxq(ulong p, long n, long v);
5004
GEN     init_Fq(GEN p, long n, long v);
5005
GEN     nfX_disc(GEN nf, GEN x);
5006
GEN     nfX_resultant(GEN nf, GEN x, GEN y);
5007
GEN     pol_x_powers(long N, long v);
5008
GEN     residual_characteristic(GEN x);
5009

5010
/* polclass.c */
5011

5012
GEN     polclass(GEN D, long inv, long xvar);
5013

5014
/* polmodular.c */
5015

5016
GEN     Fp_modinv_to_j(GEN x, long inv, GEN p);
5017
GEN     Fp_polmodular_evalx(long L, long inv, GEN J, GEN P, long v, int compute_derivs);
5018
void    check_modinv(long inv);
5019
long    disc_best_modinv(long D);
5020
long    modinv_height_factor(long inv);
5021
int     modinv_good_disc(long inv, long D);
5022
int     modinv_good_prime(long inv, long p);
5023
int     modinv_is_Weber(long inv);
5024
int     modinv_is_double_eta(long inv);
5025
GEN     polmodular(long L, long inv, GEN x, long yvar, long compute_derivs);
5026
GEN     polmodular_ZM(long L, long inv);
5027
GEN     polmodular_ZXX(long L, long inv, long xvar, long yvar);
5028

5029
/* prime.c */
5030

5031
long    BPSW_isprime(GEN x);
5032
long    BPSW_psp(GEN N);
5033
GEN     addprimes(GEN primes);
5034
long    check_ecppcert(GEN c);
5035
GEN     gisprime(GEN x, long flag);
5036
GEN     gispseudoprime(GEN x, long flag);
5037
GEN     gprimepi_upper_bound(GEN x);
5038
GEN     gprimepi_lower_bound(GEN x);
5039
long    isprime(GEN x);
5040
long    ispseudoprime(GEN x, long flag);
5041
long    millerrabin(GEN n, long k);
5042
GEN     prime(long n);
5043
GEN     primecert(GEN x, long flag);
5044
GEN     primecert0(GEN x, long flag, long stopat);
5045
GEN     primecertexport(GEN cert, long flag);
5046
long    primecertisvalid(GEN x);
5047
GEN     primepi(GEN x);
5048
double  primepi_upper_bound(double x);
5049
double  primepi_lower_bound(double x);
5050
GEN     primes(long n);
5051
GEN     primes_interval(GEN a, GEN b);
5052
GEN     primes_interval_zv(ulong a, ulong b);
5053
GEN     primes_upto_zv(ulong b);
5054
GEN     primes0(GEN n);
5055
GEN     primes_zv(long m);
5056
GEN     randomprime(GEN N);
5057
GEN     randomprime0(GEN N, GEN q);
5058
GEN     removeprimes(GEN primes);
5059
int     uis2psp(ulong n);
5060
int     uispsp(ulong a, ulong n);
5061
int     uislucaspsp(ulong n);
5062
int     uisprime(ulong n);
5063
int     uisprime_101(ulong n);
5064
int     uisprime_661(ulong n);
5065
ulong   uprime(long n);
5066
ulong   uprimepi(ulong n);
5067

5068
/* qfisom.c */
5069

5070
GEN     qfauto(GEN g, GEN flags);
5071
GEN     qfauto0(GEN g, GEN flags);
5072
GEN     qfautoexport(GEN g, long flag);
5073
GEN     qfisom(GEN g, GEN h, GEN flags, GEN G);
5074
GEN     qfisom0(GEN g, GEN h, GEN flags, GEN G);
5075
GEN     qfisominit(GEN g, GEN flags, GEN minvec);
5076
GEN     qfisominit0(GEN g, GEN flags, GEN minvec);
5077
GEN     qforbits(GEN G, GEN V);
5078

5079
/* qfparam.c */
5080

5081
GEN     qfsolve(GEN G);
5082
GEN     qfparam(GEN G, GEN sol, long fl);
5083

5084
/* random.c */
5085

5086
GEN     genrand(GEN N);
5087
GEN     getrand(void);
5088
ulong   pari_rand(void);
5089
GEN     randomi(GEN x);
5090
GEN     randomr(long prec);
5091
GEN     random_F2x(long d, long vs);
5092
ulong   random_Fl(ulong n);
5093
long    random_bits(long k);
5094
GEN     random_zv(long n);
5095
void    setrand(GEN seed);
5096

5097
/* ratpoints.c */
5098

5099
GEN     ellratpoints(GEN E, GEN h, long flag);
5100
GEN     hyperellratpoints(GEN P, GEN h, long flag);
5101

5102
/* rootpol.c */
5103

5104
GEN     QX_complex_roots(GEN p, long l);
5105
GEN     FFT(GEN W, GEN x);
5106
GEN     FFTinv(GEN W, GEN x);
5107
GEN     cleanroots(GEN x,long l);
5108
double  fujiwara_bound(GEN p);
5109
double  fujiwara_bound_real(GEN p, long sign);
5110
int     isrealappr(GEN x, long l);
5111
GEN     polgraeffe(GEN p);
5112
GEN     polmod_to_embed(GEN x, long prec);
5113
GEN     polrootsbound(GEN p, GEN tau);
5114
GEN     roots(GEN x,long l);
5115
GEN     realroots(GEN P, GEN ab, long prec);
5116
GEN     ZX_graeffe(GEN p);
5117
GEN     ZX_realroots_irred(GEN P, long prec);
5118
long    ZX_sturm(GEN P);
5119
long    ZX_sturm_irred(GEN P);
5120
long    ZX_sturmpart(GEN P, GEN ab);
5121
GEN     ZX_Uspensky(GEN P, GEN ab, long flag, long prec);
5122

5123
/* subcyclo.c */
5124

5125
GEN     factor_Aurifeuille(GEN p, long n);
5126
GEN     factor_Aurifeuille_prime(GEN p, long n);
5127
GEN     galoissubcyclo(GEN N, GEN sg, long flag, long v);
5128
GEN     polsubcyclo(long n, long d, long v);
5129
GEN     polsubcyclo0(GEN n, long d, long v);
5130
GEN     polsubcyclosmall(GEN n, long ell, long s, long fli);
5131

5132
/* subfield.c */
5133

5134
GEN     nfsubfields(GEN nf, long d);
5135
GEN     nfsubfields0(GEN nf, long d, long flag);
5136
GEN     nfsubfieldscm(GEN nf, long flag);
5137
GEN     nfsubfieldsmax(GEN nf, long flag);
5138

5139
/* nflist.c */
5140
GEN     nflist(GEN GP, GEN V, long s, GEN field);
5141
GEN     nfresolvent(GEN pol, long flag);
5142

5143
/* subgroup.c */
5144

5145
GEN     subgrouplist(GEN cyc, GEN bound);
5146
void    forsubgroup(void *E, long fun(void*,GEN), GEN cyc, GEN B);
5147

5148
/* stark.c */
5149

5150
GEN     ag_kernel(GEN S);
5151
GEN     ag_subgroup_image(GEN S, GEN H);
5152
GEN     bnrL1(GEN bnr, GEN sbgrp, long flag, long prec);
5153
GEN     bnrrootnumber(GEN bnr, GEN chi, long flag, long prec);
5154
GEN     bnrstark(GEN bnr, GEN subgroup, long prec);
5155
GEN     cyc2elts(GEN cyc);
5156
GEN     qfbforms(GEN D);
5157

5158
/* str.c */
5159

5160
GEN     chartoGENstr(char c);
5161
char*   pari_strdup(const char *s);
5162
char*   pari_strndup(const char *s, long n);
5163
char*   stack_strcat(const char *s, const char *t);
5164
char*   stack_strdup(const char *s);
5165
GEN     pari_strchr(GEN g);
5166
GEN     strjoin(GEN v, GEN p);
5167
GEN     strntoGENstr(const char *s, long n0);
5168
GEN     strsplit(GEN x, GEN p);
5169
GEN     strtoGENstr(const char *s);
5170
const char* type_name(long t);
5171
GEN     type0(GEN x);
5172

5173
/* sumiter.c */
5174

5175
GEN     asympnum(void *E, GEN (*f)(void *,GEN,long), GEN alpha, long prec);
5176
GEN     asympnumraw(void *E, GEN (*f)(void *,GEN,long), long LIM, GEN alpha, long prec);
5177
GEN     derivnum(void *E, GEN (*eval)(void *, GEN, long prec), GEN x, long prec);
5178
GEN     derivnumk(void *E, GEN (*eval)(void *, GEN, long), GEN x, GEN ind0, long prec);
5179
GEN     derivfun(void *E, GEN (*eval)(void *, GEN, long prec), GEN x, long prec);
5180
GEN     derivfunk(void *E, GEN (*eval)(void *, GEN, long), GEN x, GEN ind0, long prec);
5181
int     forvec_init(forvec_t *T, GEN x, long flag);
5182
GEN     forvec_next(forvec_t *T);
5183
GEN     laurentseries(void *E, GEN (*f)(void*,GEN x, long), long M, long v, long prec);
5184
GEN     limitnum(void *E, GEN (*f)(void *,GEN,long), GEN alpha, long prec);
5185
GEN     polzag(long n, long m);
5186
GEN     prodeuler(void *E, GEN (*eval)(void *, GEN), GEN ga, GEN gb, long prec);
5187
GEN     prodinf(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5188
GEN     prodinf1(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5189
GEN     solvestep(void *E, GEN (*eval)(void *, GEN), GEN a, GEN b, GEN step, long flag, long prec);
5190
GEN     sumalt(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5191
GEN     sumalt2(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5192
GEN     sumpos(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5193
GEN     sumpos2(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5194
GEN     suminf(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5195
GEN     suminf_bitprec(void *E, GEN (*eval)(void *, GEN), GEN a, long prec);
5196
GEN     sumdivmultexpr(void *D, GEN (*fun)(void*, GEN), GEN num);
5197
GEN     zbrent(void *E, GEN (*eval)(void *, GEN), GEN a, GEN b, long prec);
5198

5199
/* thue.c */
5200

5201
GEN     bnfisintnorm(GEN x, GEN y);
5202
GEN     bnfisintnormabs(GEN bnf, GEN a);
5203
GEN     ideals_by_norm(GEN nf, GEN a);
5204
GEN     thue(GEN thueres, GEN rhs, GEN ne);
5205
GEN     thueinit(GEN pol, long flag, long prec);
5206

5207
/* trans1.c */
5208

5209
GEN     Pi2n(long n, long prec);
5210
GEN     PiI2(long prec);
5211
GEN     PiI2n(long n, long prec);
5212
GEN     Qp_exp(GEN x);
5213
long    Qp_exp_prec(GEN x);
5214
GEN     Qp_log(GEN x);
5215
GEN     Qp_sqrt(GEN x);
5216
GEN     Qp_sqrtn(GEN x, GEN n, GEN *zetan);
5217
long    Zn_ispower(GEN a, GEN q, GEN K, GEN *pt);
5218
long    Zn_issquare(GEN x, GEN n);
5219
GEN     Zn_sqrt(GEN x, GEN n);
5220
GEN     Zp_teichmuller(GEN x, GEN p, long n, GEN q);
5221
GEN     agm(GEN x, GEN y, long prec);
5222
GEN     constcatalan(long prec);
5223
GEN     consteuler(long prec);
5224
GEN     constlog2(long prec);
5225
GEN     constpi(long prec);
5226
GEN     cxexpm1(GEN z, long prec);
5227
GEN     ellE(GEN k, long prec);
5228
GEN     ellK(GEN k, long prec);
5229
GEN     expIr(GEN x);
5230
GEN     exp1r_abs(GEN x);
5231
GEN     gcos(GEN x, long prec);
5232
GEN     gcotan(GEN x, long prec);
5233
GEN     gcotanh(GEN x, long prec);
5234
GEN     gexp(GEN x, long prec);
5235
GEN     gexpm1(GEN x, long prec);
5236
GEN     glog(GEN x, long prec);
5237
GEN     glog1p(GEN x, long prec);
5238
GEN     gpow(GEN x, GEN n, long prec);
5239
GEN     gpowers(GEN x, long n);
5240
GEN     gpowers0(GEN x, long n, GEN x0);
5241
GEN     gpowgs(GEN x, long n);
5242
GEN     grootsof1(long N, long prec);
5243
GEN     gsin(GEN x, long prec);
5244
GEN     gsinc(GEN x, long prec);
5245
void    gsincos(GEN x, GEN *s, GEN *c, long prec);
5246
GEN     gsqrpowers(GEN q, long n);
5247
GEN     gsqrt(GEN x, long prec);
5248
GEN     gsqrtn(GEN x, GEN n, GEN *zetan, long prec);
5249
GEN     gtan(GEN x, long prec);
5250
GEN     logr_abs(GEN x);
5251
GEN     mpcos(GEN x);
5252
GEN     mpeuler(long prec);
5253
GEN     mpcatalan(long prec);
5254
void    mpsincosm1(GEN x, GEN *s, GEN *c);
5255
GEN     mpexp(GEN x);
5256
GEN     mpexpm1(GEN x);
5257
GEN     mplog(GEN x);
5258
GEN     mplog2(long prec);
5259
GEN     mppi(long prec);
5260
GEN     mpsin(GEN x);
5261
void    mpsincos(GEN x, GEN *s, GEN *c);
5262
GEN     pow2Pis(GEN s, long prec);
5263
GEN     powPis(GEN s, long prec);
5264
GEN     powcx(GEN x, GEN logx, GEN n, long prec);
5265
long    powcx_prec(long ex, GEN n, long prec);
5266
GEN     powersr(GEN a, long n);
5267
GEN     powis(GEN x, long n);
5268
GEN     powiu(GEN p, ulong k);
5269
GEN     powrfrac(GEN x, long n, long d);
5270
GEN     powrs(GEN x, long n);
5271
GEN     powrshalf(GEN x, long s);
5272
GEN     powru(GEN x, ulong n);
5273
GEN     powruhalf(GEN x, ulong s);
5274
GEN     powuu(ulong p, ulong k);
5275
GEN     powgi(GEN x, GEN n);
5276
GEN     rootsof1_cx(GEN d, long prec);
5277
GEN     rootsof1u_cx(ulong d, long prec);
5278
GEN     rootsof1q_cx(long a, long b, long prec);
5279
GEN     rootsof1powinit(long a, long b, long prec);
5280
GEN     rootsof1pow(GEN T, long c);
5281
GEN     serchop(GEN s, long n);
5282
GEN     serchop_i(GEN s, long n);
5283
GEN     serchop0(GEN s);
5284
GEN     sqrtnint(GEN a, long n);
5285
GEN     sqrtnr_abs(GEN x, long n);
5286
GEN     teich(GEN x);
5287
GEN     teichmullerinit(long p, long n);
5288
GEN     teichmuller(GEN x, GEN tab);
5289
GEN     trans_eval(const char *fun, GEN (*f) (GEN, long), GEN x, long prec);
5290
GEN     trans_evalgen(const char *fun, void *E, GEN (*f) (void*,GEN,long), GEN x, long prec);
5291
ulong   upowuu(ulong p, ulong k);
5292
GEN     upowers(ulong x, long n);
5293
ulong   usqrtn(ulong a, ulong n);
5294
ulong   usqrt(ulong a);
5295

5296
/* trans2.c */
5297

5298
GEN     Qp_gamma(GEN x);
5299
GEN     atanhuu(ulong u, ulong v, long prec);
5300
GEN     atanhui(ulong u, GEN v, long prec);
5301
GEN     gacosh(GEN x, long prec);
5302
GEN     gacos(GEN x, long prec);
5303
GEN     garg(GEN x, long prec);
5304
GEN     gasinh(GEN x, long prec);
5305
GEN     gasin(GEN x, long prec);
5306
GEN     gatan(GEN x, long prec);
5307
GEN     gatanh(GEN x, long prec);
5308
GEN     gcosh(GEN x, long prec);
5309
GEN     ggammah(GEN x, long prec);
5310
GEN     ggamma(GEN x, long prec);
5311
GEN     ggamma1m1(GEN x, long prec);
5312
GEN     glngamma(GEN x, long prec);
5313
GEN     gpsi(GEN x, long prec);
5314
GEN     gsinh(GEN x, long prec);
5315
GEN     gtanh(GEN x, long prec);
5316
GEN     mpfactr(long n, long prec);
5317
void    mpsinhcosh(GEN x, GEN *s, GEN *c);
5318
GEN     psi1series(long n, long v, long prec);
5319
GEN     sumformal(GEN T, long v);
5320

5321
/* trans3.c */
5322

5323
int     RgV_is_arithprog(GEN v, GEN *a, GEN *b);
5324
GEN     besseljzero(GEN nu, long n, long b);
5325
GEN     besselyzero(GEN nu, long n, long b);
5326
GEN     constzeta(long n, long prec);
5327
GEN     cxEk(GEN tau, long k, long prec);
5328
double  dblmodulus(GEN x);
5329
GEN     dilog(GEN x, long prec);
5330
GEN     eint1(GEN x, long prec);
5331
GEN     expIPiR(GEN x, long prec);
5332
GEN     expIPiC(GEN z, long prec);
5333
GEN     expIxy(GEN x, GEN y, long prec);
5334
GEN     eta(GEN x, long prec);
5335
GEN     eta0(GEN x, long flag,long prec);
5336
GEN     gerfc(GEN x, long prec);
5337
GEN     gpolylog(long m, GEN x, long prec);
5338
GEN     gzeta(GEN x, long prec);
5339
GEN     hbessel1(GEN n, GEN z, long prec);
5340
GEN     hbessel2(GEN n, GEN z, long prec);
5341
GEN     hyperu(GEN a, GEN b, GEN gx, long prec);
5342
GEN     ibessel(GEN n, GEN z, long prec);
5343
GEN     incgam(GEN a, GEN x, long prec);
5344
GEN     incgam0(GEN a, GEN x, GEN z,long prec);
5345
GEN     incgamc(GEN a, GEN x, long prec);
5346
GEN     jbessel(GEN n, GEN z, long prec);
5347
GEN     jbesselh(GEN n, GEN z, long prec);
5348
GEN     jell(GEN x, long prec);
5349
GEN     kbessel(GEN nu, GEN gx, long prec);
5350
GEN     mpeint1(GEN x, GEN expx);
5351
GEN     mpveceint1(GEN C, GEN eC, long n);
5352
GEN     polylog0(long m, GEN x, long flag, long prec);
5353
GEN     sumdedekind(GEN h, GEN k);
5354
GEN     sumdedekind_coprime(GEN h, GEN k);
5355
GEN     szeta(long x, long prec);
5356
GEN     theta(GEN q, GEN z, long prec);
5357
GEN     thetanullk(GEN q, long k, long prec);
5358
GEN     trueeta(GEN x, long prec);
5359
GEN     u_sumdedekind_coprime(long h, long k);
5360
GEN     upper_to_cx(GEN x, long *prec);
5361
GEN     veceint1(GEN nmax, GEN C, long prec);
5362
GEN     vecthetanullk(GEN q, long k, long prec);
5363
GEN     vecthetanullk_tau(GEN tau, long k, long prec);
5364
GEN     veczeta(GEN a, GEN b, long N, long prec);
5365
GEN     weber0(GEN x, long flag,long prec);
5366
GEN     weberf(GEN x, long prec);
5367
GEN     weberf1(GEN x, long prec);
5368
GEN     weberf2(GEN x, long prec);
5369
GEN     ybessel(GEN n, GEN z, long prec);
5370
GEN     zetahurwitz(GEN s, GEN x, long der, long bitprec);
5371

5372
/* modsym.c */
5373
GEN     SL2_inv_shallow(GEN M);
5374
GEN     Qevproj_apply(GEN T, GEN pro);
5375
GEN     Qevproj_apply_vecei(GEN T, GEN pro, long k);
5376
GEN     Qevproj_down(GEN T, GEN pro);
5377
GEN     Qevproj_init(GEN M);
5378
GEN     RgX_act_Gl2Q(GEN g, long k);
5379
GEN     RgX_act_ZGl2Q(GEN z, long k);
5380
void    checkms(GEN W);
5381
void    checkmspadic(GEN W);
5382
GEN     ellpadiclambdamu(GEN E, long p, long D, long R);
5383
GEN     mfnumcusps(GEN n);
5384
GEN     mfnumcusps_fact(GEN fa);
5385
ulong   mfnumcuspsu_fact(GEN fa);
5386
ulong   mfnumcuspsu(ulong n);
5387
GEN     msfromcusp(GEN W, GEN c);
5388
GEN     msfromell(GEN E, long signe);
5389
GEN     msfromhecke(GEN W, GEN v, GEN H);
5390
long    msdim(GEN W);
5391
GEN     mseval2_ooQ(GEN W, GEN xpm, GEN c);
5392
long    msgetlevel(GEN W);
5393
long    msgetsign(GEN W);
5394
long    msgetweight(GEN W);
5395
GEN     msatkinlehner(GEN W, long Q, GEN);
5396
GEN     mscuspidal(GEN W, long flag);
5397
GEN     mseisenstein(GEN W);
5398
GEN     mseval(GEN W, GEN s, GEN p);
5399
GEN     mshecke(GEN W, long p, GEN H);
5400
GEN     msinit(GEN N, GEN k, long sign);
5401
GEN     msissymbol(GEN W, GEN s);
5402
GEN     mslattice(GEN M, GEN F);
5403
GEN     msomseval(GEN W, GEN phi, GEN path);
5404
void    mspadic_parse_chi(GEN s, GEN *s1, GEN *s2);
5405
GEN     mspadic_unit_eigenvalue(GEN ap, long k, GEN p, long n);
5406
GEN     mspadicinit(GEN W, long p, long n, long flag);
5407
GEN     mspadicL(GEN oms, GEN s, long r);
5408
GEN     mspadicmoments(GEN W, GEN phi, long D);
5409
GEN     mspadicseries(GEN M, long teichi);
5410
GEN     mspathgens(GEN W);
5411
GEN     mspathlog(GEN W, GEN path);
5412
GEN     msnew(GEN W);
5413
GEN     mspetersson(GEN W, GEN F1, GEN F2);
5414
GEN     mspolygon(GEN M, long flag);
5415
GEN     msstar(GEN W, GEN);
5416
GEN     msqexpansion(GEN W, GEN proV, ulong B);
5417
GEN     mssplit(GEN W, GEN H, long deglim);
5418
GEN     mstooms(GEN W, GEN phi);
5419

5420
/* mscosets.c */
5421
GEN mscosets0(GEN V, GEN code);
5422
GEN mscosets(GEN V, void *E, long (*in)(void *, GEN));
5423
GEN msfarey(GEN F, void *E, long (*in)(void *, GEN), GEN *pCM);
5424
GEN msfarey0(GEN F, GEN code, GEN *pCM);
5425
int checkfarey_i(GEN F);
5426

5427
/* zetamult.c */
5428

5429
GEN     polylogmult(GEN avec, GEN zvec, long prec);
5430
GEN     polylogmult_interpolate(GEN avec, GEN zvec, GEN t, long prec);
5431
GEN     zetamult(GEN avec, long prec);
5432
GEN     zetamultdual(GEN s);
5433
GEN     zetamult_interpolate(GEN avec, GEN t, long prec);
5434
GEN     zetamultall(long k, long flag, long prec);
5435
GEN     zetamultconvert(GEN a, long fl);
5436

5437
/* level1.h */
5438

5439
INLINE ulong  Fl_add(ulong a, ulong b, ulong p);
5440
INLINE ulong  Fl_addmul_pre(ulong x0, ulong x1, ulong y0, ulong p, ulong pi);
5441
INLINE ulong  Fl_addmulmul_pre(ulong x0, ulong y0, ulong x1, ulong y1, ulong p, ulong pi);
5442
INLINE long   Fl_center(ulong u, ulong p, ulong ps2);
5443
INLINE ulong  Fl_div(ulong a, ulong b, ulong p);
5444
INLINE ulong  Fl_double(ulong a, ulong p);
5445
INLINE ulong  Fl_ellj_pre(ulong a4, ulong a6, ulong p, ulong pi);
5446
INLINE ulong  Fl_halve(ulong y, ulong p);
5447
INLINE ulong  Fl_mul(ulong a, ulong b, ulong p);
5448
INLINE ulong  Fl_mul_pre(ulong a, ulong b, ulong p, ulong pi);
5449
INLINE ulong  Fl_neg(ulong x, ulong p);
5450
INLINE ulong  Fl_sqr(ulong a, ulong p);
5451
INLINE ulong  Fl_sqr_pre(ulong a, ulong p, ulong pi);
5452
INLINE ulong  Fl_sub(ulong a, ulong b, ulong p);
5453
INLINE ulong  Fl_triple(ulong a, ulong p);
5454
INLINE ulong  Mod2(GEN x);
5455
INLINE ulong  Mod4(GEN x);
5456
INLINE ulong  Mod8(GEN x);
5457
INLINE ulong  Mod16(GEN x);
5458
INLINE ulong  Mod32(GEN x);
5459
INLINE ulong  Mod64(GEN x);
5460
INLINE int    abscmpiu(GEN x, ulong y);
5461
INLINE int    abscmpui(ulong x, GEN y);
5462
INLINE int    absequaliu(GEN x, ulong y);
5463
INLINE GEN    absi(GEN x);
5464
INLINE GEN    absi_shallow(GEN x);
5465
INLINE GEN    absr(GEN x);
5466
INLINE int    absrnz_equal1(GEN x);
5467
INLINE int    absrnz_equal2n(GEN x);
5468
INLINE GEN    addii(GEN x, GEN y);
5469
INLINE void   addiiz(GEN x, GEN y, GEN z);
5470
INLINE GEN    addir(GEN x, GEN y);
5471
INLINE void   addirz(GEN x, GEN y, GEN z);
5472
INLINE GEN    addis(GEN x, long s);
5473
INLINE GEN    addri(GEN x, GEN y);
5474
INLINE void   addriz(GEN x, GEN y, GEN z);
5475
INLINE GEN    addrr(GEN x, GEN y);
5476
INLINE void   addrrz(GEN x, GEN y, GEN z);
5477
INLINE GEN    addrs(GEN x, long s);
5478
INLINE GEN    addsi(long x, GEN y);
5479
INLINE void   addsiz(long s, GEN y, GEN z);
5480
INLINE void   addsrz(long s, GEN y, GEN z);
5481
INLINE GEN    addss(long x, long y);
5482
INLINE void   addssz(long s, long y, GEN z);
5483
INLINE GEN    adduu(ulong x, ulong y);
5484
INLINE void   affgr(GEN x, GEN y);
5485
INLINE void   affii(GEN x, GEN y);
5486
INLINE void   affiz(GEN x, GEN y);
5487
INLINE void   affrr_fixlg(GEN y, GEN z);
5488
INLINE void   affsi(long s, GEN x);
5489
INLINE void   affsr(long s, GEN x);
5490
INLINE void   affsz(long x, GEN y);
5491
INLINE void   affui(ulong s, GEN x);
5492
INLINE void   affur(ulong s, GEN x);
5493
INLINE GEN    cgetg(long x, long y);
5494
INLINE GEN    cgetg_block(long x, long y);
5495
INLINE GEN    cgetg_copy(GEN x, long *plx);
5496
INLINE GEN    cgeti(long x);
5497
INLINE GEN    cgetineg(long x);
5498
INLINE GEN    cgetipos(long x);
5499
INLINE GEN    cgetr(long x);
5500
INLINE GEN    cgetr_block(long prec);
5501
INLINE int    cmpir(GEN x, GEN y);
5502
INLINE int    cmpis(GEN x, long y);
5503
INLINE int    cmpiu(GEN x, ulong y);
5504
INLINE int    cmpri(GEN x, GEN y);
5505
INLINE int    cmprs(GEN x, long y);
5506
INLINE int    cmpsi(long x, GEN y);
5507
INLINE int    cmpsr(long x, GEN y);
5508
INLINE int    cmpss(long a, long b);
5509
INLINE int    cmpui(ulong x, GEN y);
5510
INLINE int    cmpuu(ulong a, ulong b);
5511
INLINE GEN    cxtofp(GEN x, long prec);
5512
INLINE GEN    divii(GEN a, GEN b);
5513
INLINE void   diviiz(GEN x, GEN y, GEN z);
5514
INLINE void   divirz(GEN x, GEN y, GEN z);
5515
INLINE void   divisz(GEN x, long s, GEN z);
5516
INLINE void   divriz(GEN x, GEN y, GEN z);
5517
INLINE void   divrrz(GEN x, GEN y, GEN z);
5518
INLINE void   divrsz(GEN y, long s, GEN z);
5519
INLINE GEN    divsi_rem(long x, GEN y, long *rem);
5520
INLINE void   divsiz(long x, GEN y, GEN z);
5521
INLINE void   divsrz(long s, GEN y, GEN z);
5522
INLINE GEN    divss(long x, long y);
5523
INLINE GEN    divss_rem(long x, long y, long *rem);
5524
INLINE void   divssz(long x, long y, GEN z);
5525
INLINE int    dvdii(GEN x, GEN y);
5526
INLINE int    dvdiiz(GEN x, GEN y, GEN z);
5527
INLINE int    dvdis(GEN x, long y);
5528
INLINE int    dvdisz(GEN x, long y, GEN z);
5529
INLINE int    dvdiu(GEN x, ulong y);
5530
INLINE int    dvdiuz(GEN x, ulong y, GEN z);
5531
INLINE int    dvdsi(long x, GEN y);
5532
INLINE int    dvdui(ulong x, GEN y);
5533
INLINE void   dvmdiiz(GEN x, GEN y, GEN z, GEN t);
5534
INLINE GEN    dvmdis(GEN x, long y, GEN *z);
5535
INLINE void   dvmdisz(GEN x, long y, GEN z, GEN t);
5536
INLINE long   dvmdsBIL(long n, long *r);
5537
INLINE GEN    dvmdsi(long x, GEN y, GEN *z);
5538
INLINE void   dvmdsiz(long x, GEN y, GEN z, GEN t);
5539
INLINE GEN    dvmdss(long x, long y, GEN *z);
5540
INLINE void   dvmdssz(long x, long y, GEN z, GEN t);
5541
INLINE ulong  dvmduBIL(ulong n, ulong *r);
5542
INLINE int    equalis(GEN x, long y);
5543
INLINE int    equalsi(long x, GEN y);
5544
INLINE int    equalui(ulong x, GEN y);
5545
INLINE int    equaliu(GEN x, ulong y);
5546
INLINE int    absequalui(ulong x, GEN y);
5547
INLINE ulong  ceildivuu(ulong a, ulong b);
5548
INLINE long   evalexpo(long x);
5549
INLINE long   evallg(long x);
5550
INLINE long   evalprecp(long x);
5551
INLINE long   evalvalp(long x);
5552
INLINE long   expi(GEN x);
5553
INLINE long   expu(ulong x);
5554
INLINE void   fixlg(GEN z, long ly);
5555
INLINE GEN    fractor(GEN x, long prec);
5556
INLINE int    gc_bool(pari_sp av, int s);
5557
INLINE GEN    gc_const(pari_sp av, GEN x);
5558
INLINE double gc_double(pari_sp av, double d);
5559
INLINE int    gc_int(pari_sp av, int s);
5560
INLINE long   gc_long(pari_sp av, long s);
5561
INLINE ulong  gc_ulong(pari_sp av, ulong s);
5562
INLINE GEN    gc_NULL(pari_sp av);
5563
INLINE GEN    icopy(GEN x);
5564
INLINE GEN    icopyspec(GEN x, long nx);
5565
INLINE GEN    icopy_avma(GEN x, pari_sp av);
5566
INLINE ulong  int_bit(GEN x, long n);
5567
INLINE GEN    itor(GEN x, long prec);
5568
INLINE long   itos(GEN x);
5569
INLINE long   itos_or_0(GEN x);
5570
INLINE ulong  itou(GEN x);
5571
INLINE ulong  itou_or_0(GEN x);
5572
INLINE GEN    leafcopy(GEN x);
5573
INLINE GEN    leafcopy_avma(GEN x, pari_sp av);
5574
INLINE double maxdd(double x, double y);
5575
INLINE long   maxss(long x, long y);
5576
INLINE long   maxuu(ulong x, ulong y);
5577
INLINE double mindd(double x, double y);
5578
INLINE long   minss(long x, long y);
5579
INLINE long   minuu(ulong x, ulong y);
5580
INLINE long   mod16(GEN x);
5581
INLINE long   mod2(GEN x);
5582
INLINE ulong  mod2BIL(GEN x);
5583
INLINE long   mod32(GEN x);
5584
INLINE long   mod4(GEN x);
5585
INLINE long   mod64(GEN x);
5586
INLINE long   mod8(GEN x);
5587
INLINE GEN    modis(GEN x, long y);
5588
INLINE void   modisz(GEN y, long s, GEN z);
5589
INLINE GEN    modsi(long x, GEN y);
5590
INLINE void   modsiz(long s, GEN y, GEN z);
5591
INLINE GEN    modss(long x, long y);
5592
INLINE void   modssz(long s, long y, GEN z);
5593
INLINE GEN    mpabs(GEN x);
5594
INLINE GEN    mpabs_shallow(GEN x);
5595
INLINE GEN    mpadd(GEN x, GEN y);
5596
INLINE void   mpaddz(GEN x, GEN y, GEN z);
5597
INLINE void   mpaff(GEN x, GEN y);
5598
INLINE GEN    mpceil(GEN x);
5599
INLINE int    mpcmp(GEN x, GEN y);
5600
INLINE GEN    mpcopy(GEN x);
5601
INLINE GEN    mpdiv(GEN x, GEN y);
5602
INLINE long   mpexpo(GEN x);
5603
INLINE GEN    mpfloor(GEN x);
5604
INLINE GEN    mpmul(GEN x, GEN y);
5605
INLINE void   mpmulz(GEN x, GEN y, GEN z);
5606
INLINE GEN    mpneg(GEN x);
5607
INLINE int    mpodd(GEN x);
5608
INLINE GEN    mpround(GEN x);
5609
INLINE GEN    mpshift(GEN x,long s);
5610
INLINE GEN    mpsqr(GEN x);
5611
INLINE GEN    mpsub(GEN x, GEN y);
5612
INLINE void   mpsubz(GEN x, GEN y, GEN z);
5613
INLINE GEN    mptrunc(GEN x);
5614
INLINE void   muliiz(GEN x, GEN y, GEN z);
5615
INLINE void   mulirz(GEN x, GEN y, GEN z);
5616
INLINE GEN    mulis(GEN x, long s);
5617
INLINE GEN    muliu(GEN x, ulong s);
5618
INLINE GEN    mulri(GEN x, GEN s);
5619
INLINE void   mulriz(GEN x, GEN y, GEN z);
5620
INLINE void   mulrrz(GEN x, GEN y, GEN z);
5621
INLINE GEN    mulrs(GEN x, long s);
5622
INLINE GEN    mulru(GEN x, ulong s);
5623
INLINE void   mulsiz(long s, GEN y, GEN z);
5624
INLINE void   mulsrz(long s, GEN y, GEN z);
5625
INLINE void   mulssz(long s, long y, GEN z);
5626
INLINE GEN    negi(GEN x);
5627
INLINE GEN    negr(GEN x);
5628
INLINE GEN    new_chunk(size_t x);
5629
INLINE GEN    rcopy(GEN x);
5630
INLINE GEN    rdivii(GEN x, GEN y, long prec);
5631
INLINE void   rdiviiz(GEN x, GEN y, GEN z);
5632
INLINE GEN    rdivis(GEN x, long y, long prec);
5633
INLINE GEN    rdivsi(long x, GEN y, long prec);
5634
INLINE GEN    rdivss(long x, long y, long prec);
5635
INLINE GEN    real2n(long n, long prec);
5636
INLINE GEN    real_m2n(long n, long prec);
5637
INLINE GEN    real_0(long prec);
5638
INLINE GEN    real_0_bit(long bitprec);
5639
INLINE GEN    real_1(long prec);
5640
INLINE GEN    real_1_bit(long bit);
5641
INLINE GEN    real_m1(long prec);
5642
INLINE GEN    remii(GEN a, GEN b);
5643
INLINE void   remiiz(GEN x, GEN y, GEN z);
5644
INLINE GEN    remis(GEN x, long y);
5645
INLINE void   remisz(GEN y, long s, GEN z);
5646
INLINE ulong  remlll_pre(ulong u2, ulong u1, ulong u0, ulong p, ulong pi);
5647
INLINE GEN    remsi(long x, GEN y);
5648
INLINE void   remsiz(long s, GEN y, GEN z);
5649
INLINE GEN    remss(long x, long y);
5650
INLINE void   remssz(long s, long y, GEN z);
5651
INLINE GEN    rtor(GEN x, long prec);
5652
INLINE long   sdivsi(long x, GEN y);
5653
INLINE long   sdivsi_rem(long x, GEN y, long *rem);
5654
INLINE long   sdivss_rem(long x, long y, long *rem);
5655
INLINE void   set_avma(ulong av);
5656
INLINE ulong  uabsdiviu_rem(GEN n, ulong d, ulong *r);
5657
INLINE ulong  udivuu_rem(ulong x, ulong y, ulong *r);
5658
INLINE ulong  umodi2n(GEN x, long n);
5659
INLINE void   setabssign(GEN x);
5660
INLINE void   shift_left(GEN z2, GEN z1, long min, long M, ulong f,  ulong sh);
5661
INLINE void   shift_right(GEN z2, GEN z1, long min, long M, ulong f, ulong sh);
5662
INLINE ulong  shiftl(ulong x, ulong y);
5663
INLINE ulong  shiftlr(ulong x, ulong y);
5664
INLINE GEN    shiftr(GEN x, long n);
5665
INLINE void   shiftr_inplace(GEN z, long d);
5666
INLINE long   smodis(GEN x, long y);
5667
INLINE long   smodss(long x, long y);
5668
INLINE void   stackdummy(pari_sp av, pari_sp ltop);
5669
INLINE char  *stack_malloc(size_t N);
5670
INLINE char  *stack_malloc_align(size_t N, long k);
5671
INLINE char  *stack_calloc(size_t N);
5672
INLINE char  *stack_calloc_align(size_t N, long k);
5673
INLINE GEN    stoi(long x);
5674
INLINE GEN    stor(long x, long prec);
5675
INLINE GEN    subii(GEN x, GEN y);
5676
INLINE void   subiiz(GEN x, GEN y, GEN z);
5677
INLINE GEN    subir(GEN x, GEN y);
5678
INLINE void   subirz(GEN x, GEN y, GEN z);
5679
INLINE GEN    subis(GEN x, long y);
5680
INLINE void   subisz(GEN y, long s, GEN z);
5681
INLINE GEN    subri(GEN x, GEN y);
5682
INLINE void   subriz(GEN x, GEN y, GEN z);
5683
INLINE GEN    subrr(GEN x, GEN y);
5684
INLINE void   subrrz(GEN x, GEN y, GEN z);
5685
INLINE GEN    subrs(GEN x, long y);
5686
INLINE void   subrsz(GEN y, long s, GEN z);
5687
INLINE GEN    subsi(long x, GEN y);
5688
INLINE void   subsiz(long s, GEN y, GEN z);
5689
INLINE void   subsrz(long s, GEN y, GEN z);
5690
INLINE GEN    subss(long x, long y);
5691
INLINE void   subssz(long x, long y, GEN z);
5692
INLINE GEN    subuu(ulong x, ulong y);
5693
INLINE void   togglesign(GEN x);
5694
INLINE void   togglesign_safe(GEN *px);
5695
INLINE void   affectsign(GEN x, GEN y);
5696
INLINE void   affectsign_safe(GEN x, GEN *py);
5697
INLINE GEN    truedivii(GEN a,GEN b);
5698
INLINE GEN    truedivis(GEN a, long b);
5699
INLINE GEN    truedivsi(long a, GEN b);
5700
INLINE ulong  uabsdivui_rem(ulong x, GEN y, ulong *rem);
5701
INLINE ulong  umodsu(long x, ulong y);
5702
INLINE ulong  umodui(ulong x, GEN y);
5703
INLINE ulong  ugcdiu(GEN x, ulong y);
5704
INLINE ulong  ugcdui(ulong y, GEN x);
5705
INLINE ulong  umuluu_le(ulong x, ulong y, ulong n);
5706
INLINE ulong  umuluu_or_0(ulong x, ulong y);
5707
INLINE GEN    utoi(ulong x);
5708
INLINE GEN    utoineg(ulong x);
5709
INLINE GEN    utoipos(ulong x);
5710
INLINE GEN    utor(ulong s, long prec);
5711
INLINE GEN    uutoi(ulong x, ulong y);
5712
INLINE GEN    uutoineg(ulong x, ulong y);
5713
INLINE long   vali(GEN x);
5714
INLINE int    varncmp(long x, long y);
5715
INLINE long   varnmax(long x, long y);
5716
INLINE long   varnmin(long x, long y);
5717

5718
/* pariinl.h */
5719
INLINE GEN    abgrp_get_cyc(GEN x);
5720
INLINE GEN    abgrp_get_gen(GEN x);
5721
INLINE GEN    abgrp_get_no(GEN x);
5722
INLINE GEN    bid_get_arch(GEN bid);
5723
INLINE GEN    bid_get_archp(GEN bid);
5724
INLINE GEN    bid_get_cyc(GEN bid);
5725
INLINE GEN    bid_get_fact(GEN bid);
5726
INLINE GEN    bid_get_fact2(GEN bid);
5727
INLINE GEN    bid_get_gen(GEN bid);
5728
INLINE GEN    bid_get_gen_nocheck(GEN bid);
5729
INLINE GEN    bid_get_grp(GEN bid);
5730
INLINE GEN    bid_get_ideal(GEN bid);
5731
INLINE GEN    bid_get_mod(GEN bid);
5732
INLINE GEN    bid_get_no(GEN bid);
5733
INLINE GEN    bid_get_sarch(GEN bid);
5734
INLINE GEN    bid_get_sprk(GEN bid);
5735
INLINE GEN    bid_get_U(GEN bid);
5736
INLINE GEN    bnf_get_clgp(GEN bnf);
5737
INLINE GEN    bnf_get_cyc(GEN bnf);
5738
INLINE GEN    bnf_get_fu(GEN bnf);
5739
INLINE GEN    bnf_get_fu_nocheck(GEN bnf);
5740
INLINE GEN    bnf_get_gen(GEN bnf);
5741
INLINE GEN    bnf_get_logfu(GEN bnf);
5742
INLINE GEN    bnf_get_nf(GEN bnf);
5743
INLINE GEN    bnf_get_no(GEN bnf);
5744
INLINE GEN    bnf_get_reg(GEN bnf);
5745
INLINE GEN    bnf_get_sunits(GEN bnf);
5746
INLINE GEN    bnf_get_tuU(GEN bnf);
5747
INLINE long   bnf_get_tuN(GEN bnf);
5748
INLINE GEN    bnr_get_bnf(GEN bnr);
5749
INLINE GEN    bnr_get_clgp(GEN bnr);
5750
INLINE GEN    bnr_get_cyc(GEN bnr);
5751
INLINE GEN    bnr_get_gen(GEN bnr);
5752
INLINE GEN    bnr_get_gen_nocheck(GEN bnr);
5753
INLINE GEN    bnr_get_no(GEN bnr);
5754
INLINE GEN    bnr_get_bid(GEN bnr);
5755
INLINE GEN    bnr_get_mod(GEN bnr);
5756
INLINE GEN    bnr_get_nf(GEN bnr);
5757
INLINE int    checkell_i(GEN e);
5758
INLINE GEN    cyc_get_expo(GEN c);
5759
INLINE GEN    ell_get_a1(GEN e);
5760
INLINE GEN    ell_get_a2(GEN e);
5761
INLINE GEN    ell_get_a3(GEN e);
5762
INLINE GEN    ell_get_a4(GEN e);
5763
INLINE GEN    ell_get_a6(GEN e);
5764
INLINE GEN    ell_get_b2(GEN e);
5765
INLINE GEN    ell_get_b4(GEN e);
5766
INLINE GEN    ell_get_b6(GEN e);
5767
INLINE GEN    ell_get_b8(GEN e);
5768
INLINE GEN    ell_get_c4(GEN e);
5769
INLINE GEN    ell_get_c6(GEN e);
5770
INLINE GEN    ell_get_disc(GEN e);
5771
INLINE GEN    ell_get_j(GEN e);
5772
INLINE long   ell_get_type(GEN e);
5773
INLINE int    ell_is_inf(GEN z);
5774
INLINE GEN    ellinf(void);
5775
INLINE GEN    ellff_get_field(GEN x);
5776
INLINE GEN    ellff_get_a4a6(GEN x);
5777
INLINE GEN    ellnf_get_bnf(GEN x);
5778
INLINE GEN    ellnf_get_nf(GEN x);
5779
INLINE GEN    ellQp_get_p(GEN E);
5780
INLINE long   ellQp_get_prec(GEN E);
5781
INLINE GEN    ellQp_get_zero(GEN x);
5782
INLINE long   ellR_get_prec(GEN x);
5783
INLINE long   ellR_get_sign(GEN x);
5784
INLINE GEN    gal_get_pol(GEN gal);
5785
INLINE GEN    gal_get_p(GEN gal);
5786
INLINE GEN    gal_get_e(GEN gal);
5787
INLINE GEN    gal_get_mod(GEN gal);
5788
INLINE GEN    gal_get_roots(GEN gal);
5789
INLINE GEN    gal_get_invvdm(GEN gal);
5790
INLINE GEN    gal_get_den(GEN gal);
5791
INLINE GEN    gal_get_group(GEN gal);
5792
INLINE GEN    gal_get_gen(GEN gal);
5793
INLINE GEN    gal_get_orders(GEN gal);
5794
INLINE ulong  hash_str(const char *str);
5795
INLINE ulong  hash_str_len(const char *s, long len);
5796
INLINE GEN    idealchineseinit(GEN nf, GEN x);
5797
INLINE GEN    idealpseudomin(GEN I, GEN G);
5798
INLINE GEN    idealpseudomin_nonscalar(GEN I, GEN G);
5799
INLINE GEN    idealpseudominvec(GEN I, GEN G);
5800
INLINE GEN    idealpseudored(GEN I, GEN G);
5801
INLINE GEN    idealred_elt(GEN nf, GEN I);
5802
INLINE GEN    idealred(GEN nf, GEN I);
5803
INLINE long   logint(GEN B, GEN y);
5804
INLINE ulong  ulogint(ulong B, ulong y);
5805
INLINE GEN    modpr_get_pr(GEN x);
5806
INLINE GEN    modpr_get_p(GEN x);
5807
INLINE GEN    modpr_get_T(GEN x);
5808
INLINE GEN    nf_get_M(GEN nf);
5809
INLINE GEN    nf_get_G(GEN nf);
5810
INLINE GEN    nf_get_Tr(GEN nf);
5811
INLINE GEN    nf_get_diff(GEN nf);
5812
INLINE long   nf_get_degree(GEN nf);
5813
INLINE GEN    nf_get_disc(GEN nf);
5814
INLINE GEN    nf_get_index(GEN nf);
5815
INLINE GEN    nf_get_invzk(GEN nf);
5816
INLINE GEN    nf_get_pol(GEN nf);
5817
INLINE long   nf_get_r1(GEN nf);
5818
INLINE long   nf_get_r2(GEN nf);
5819
INLINE GEN    nf_get_ramified_primes(GEN nf);
5820
INLINE GEN    nf_get_roots(GEN nf);
5821
INLINE GEN    nf_get_roundG(GEN nf);
5822
INLINE void   nf_get_sign(GEN nf, long *r1, long *r2);
5823
INLINE long   nf_get_varn(GEN nf);
5824
INLINE GEN    nf_get_zk(GEN nf);
5825
INLINE GEN    nf_get_zkden(GEN nf);
5826
INLINE GEN    nf_get_zkprimpart(GEN nf);
5827
INLINE long   pr_get_e(GEN pr);
5828
INLINE long   pr_get_f(GEN pr);
5829
INLINE GEN    pr_get_gen(GEN pr);
5830
INLINE GEN    pr_get_p(GEN pr);
5831
INLINE GEN    pr_get_tau(GEN pr);
5832
INLINE int    pr_is_inert(GEN P);
5833
INLINE GEN    pr_norm(GEN pr);
5834
INLINE GEN    rnf_get_alpha(GEN rnf);
5835
INLINE long   rnf_get_absdegree(GEN rnf);
5836
INLINE long   rnf_get_degree(GEN rnf);
5837
INLINE GEN    rnf_get_disc(GEN rnf);
5838
INLINE GEN    rnf_get_idealdisc(GEN rnf);
5839
INLINE GEN    rnf_get_index(GEN rnf);
5840
INLINE GEN    rnf_get_invzk(GEN rnf);
5841
INLINE GEN    rnf_get_k(GEN rnf);
5842
INLINE GEN    rnf_get_map(GEN rnf);
5843
INLINE GEN    rnf_get_nf(GEN rnf);
5844
INLINE long   rnf_get_nfdegree(GEN rnf);
5845
INLINE GEN    rnf_get_nfpol(GEN rnf);
5846
INLINE long   rnf_get_nfvarn(GEN rnf);
5847
INLINE GEN    rnf_get_pol(GEN rnf);
5848
INLINE GEN    rnf_get_polabs(GEN rnf);
5849
INLINE GEN    rnf_get_ramified_primes(GEN rnf);
5850
INLINE GEN    rnf_get_zk(GEN nf);
5851
INLINE GEN    rnf_get_nfzk(GEN rnf);
5852
INLINE long   rnf_get_varn(GEN rnf);
5853
INLINE ulong  upr_norm(GEN pr);
5854
INLINE GEN    znstar_get_N(GEN G);
5855
INLINE GEN    znstar_get_conreycyc(GEN G);
5856
INLINE GEN    znstar_get_conreygen(GEN G);
5857
INLINE GEN    znstar_get_cyc(GEN G);
5858
INLINE GEN    znstar_get_faN(GEN G);
5859
INLINE GEN    znstar_get_gen(GEN G);
5860
INLINE GEN    znstar_get_no(GEN G);
5861
INLINE GEN    znstar_get_pe(GEN G);
5862
INLINE GEN    znstar_get_U(GEN G);
5863
INLINE GEN    znstar_get_Ui(GEN G);
5864

5865
INLINE long   closure_arity(GEN C);
5866
INLINE const char * closure_codestr(GEN C);
5867
INLINE GEN    closure_get_code(GEN C);
5868
INLINE GEN    closure_get_oper(GEN C);
5869
INLINE GEN    closure_get_data(GEN C);
5870
INLINE GEN    closure_get_dbg(GEN C);
5871
INLINE GEN    closure_get_text(GEN C);
5872
INLINE GEN    closure_get_frame(GEN C);
5873
INLINE long   closure_is_variadic(GEN C);
5874

5875
INLINE GEN    addmuliu(GEN x, GEN y, ulong u);
5876
INLINE GEN    addmuliu_inplace(GEN x, GEN y, ulong u);
5877
INLINE GEN    lincombii(GEN u, GEN v, GEN x, GEN y);
5878
INLINE GEN    mulsubii(GEN y, GEN z, GEN x);
5879
INLINE GEN    submulii(GEN x, GEN y, GEN z);
5880
INLINE GEN    submuliu(GEN x, GEN y, ulong u);
5881
INLINE GEN    submuliu_inplace(GEN x, GEN y, ulong u);
5882

5883
INLINE GEN    FpXQ_add(GEN x,GEN y,GEN T,GEN p);
5884
INLINE GEN    FpXQ_sub(GEN x,GEN y,GEN T,GEN p);
5885
INLINE GEN    Flxq_add(GEN x,GEN y,GEN T,ulong p);
5886
INLINE GEN    Flxq_sub(GEN x,GEN y,GEN T,ulong p);
5887

5888
INLINE GEN    FpXQX_div(GEN x, GEN y, GEN T, GEN p);
5889
INLINE GEN    FlxqX_div(GEN x, GEN y, GEN T, ulong p);
5890
INLINE GEN    F2xqX_div(GEN x, GEN y, GEN T);
5891

5892
INLINE GEN    Rg_to_Fq(GEN x, GEN T, GEN p);
5893
INLINE GEN    Fq_red(GEN x, GEN T, GEN p);
5894
INLINE GEN    Fq_to_FpXQ(GEN x, GEN T, GEN p);
5895
INLINE GEN    gener_Fq_local(GEN T, GEN p, GEN L);
5896
INLINE GEN    FpXY_Fq_evaly(GEN Q, GEN y, GEN T, GEN p, long vx);
5897
INLINE GEN    FqX_Fp_mul(GEN P, GEN U, GEN T, GEN p);
5898
INLINE GEN    FqX_Fq_mul(GEN P, GEN U, GEN T, GEN p);
5899
INLINE GEN    FqX_add(GEN x,GEN y,GEN T,GEN p);
5900
INLINE GEN    FqX_ddf(GEN f, GEN T, GEN p);
5901
INLINE GEN    FqX_degfact(GEN f, GEN T, GEN p);
5902
INLINE GEN    FqX_deriv(GEN f, GEN T, GEN p);
5903
INLINE GEN    FqX_div(GEN x, GEN y, GEN T, GEN p);
5904
INLINE GEN    FqX_div_by_X_x(GEN x, GEN y, GEN T, GEN p, GEN *z);
5905
INLINE GEN    FqX_divrem(GEN x, GEN y, GEN T, GEN p, GEN *z);
5906
INLINE GEN    FqX_extgcd(GEN P,GEN Q,GEN T,GEN p, GEN *U, GEN *V);
5907
INLINE GEN    FqX_factor(GEN f, GEN T, GEN p);
5908
INLINE GEN    FqX_factor_squarefree(GEN f, GEN T, GEN p);
5909
INLINE GEN    FqX_gcd(GEN P, GEN Q, GEN T, GEN p);
5910
INLINE GEN    FqX_get_red(GEN S, GEN T, GEN p);
5911
INLINE GEN    FqX_halfgcd(GEN P,GEN Q,GEN T,GEN p);
5912
INLINE GEN    FqX_halve(GEN x, GEN T, GEN p);
5913
INLINE GEN    FqX_integ(GEN f, GEN T, GEN p);
5914
INLINE GEN    FqX_mul(GEN x, GEN y, GEN T, GEN p);
5915
INLINE GEN    FqX_mulu(GEN x, ulong y, GEN T, GEN p);
5916
INLINE GEN    FqX_neg(GEN x, GEN T, GEN p);
5917
INLINE GEN    FqX_normalize(GEN z, GEN T, GEN p);
5918
INLINE GEN    FqX_powu(GEN x, ulong n, GEN T, GEN p);
5919
INLINE GEN    FqX_red(GEN z, GEN T, GEN p);
5920
INLINE GEN    FqX_rem(GEN x, GEN y, GEN T, GEN p);
5921
INLINE GEN    FqX_roots(GEN f, GEN T, GEN p);
5922
INLINE GEN    FqX_sqr(GEN x, GEN T, GEN p);
5923
INLINE GEN    FqX_sub(GEN x,GEN y,GEN T,GEN p);
5924
INLINE GEN    FqX_to_mod(GEN f, GEN T, GEN p);
5925

5926
INLINE GEN    FqXQ_add(GEN x, GEN y, GEN S, GEN T, GEN p);
5927
INLINE GEN    FqXQ_div(GEN x, GEN y, GEN S, GEN T, GEN p);
5928
INLINE GEN    FqXQ_inv(GEN x, GEN S, GEN T, GEN p);
5929
INLINE GEN    FqXQ_invsafe(GEN x, GEN S, GEN T, GEN p);
5930
INLINE GEN    FqXQ_mul(GEN x, GEN y, GEN S, GEN T, GEN p);
5931
INLINE GEN    FqXQ_pow(GEN x, GEN n, GEN S, GEN T, GEN p);
5932
INLINE GEN    FqXQ_sqr(GEN x, GEN S, GEN T, GEN p);
5933
INLINE GEN    FqXQ_sub(GEN x, GEN y, GEN S, GEN T, GEN p);
5934

5935
INLINE GEN    FqXn_exp(GEN x, long n, GEN T, GEN p);
5936
INLINE GEN    FqXn_expint(GEN x, long n, GEN T, GEN p);
5937
INLINE GEN    FqXn_inv(GEN x, long n, GEN T, GEN p);
5938
INLINE GEN    FqXn_mul(GEN x, GEN y, long n, GEN T, GEN p);
5939
INLINE GEN    FqXn_sqr(GEN x, long n, GEN T, GEN p);
5940

5941
INLINE long   get_F2x_degree(GEN T);
5942
INLINE GEN    get_F2x_mod(GEN T);
5943
INLINE long   get_F2x_var(GEN T);
5944
INLINE long   get_F2xqX_degree(GEN T);
5945
INLINE GEN    get_F2xqX_mod(GEN T);
5946
INLINE long   get_F2xqX_var(GEN T);
5947
INLINE long   get_Flx_degree(GEN T);
5948
INLINE GEN    get_Flx_mod(GEN T);
5949
INLINE long   get_Flx_var(GEN T);
5950
INLINE long   get_FlxqX_degree(GEN T);
5951
INLINE GEN    get_FlxqX_mod(GEN T);
5952
INLINE long   get_FlxqX_var(GEN T);
5953
INLINE long   get_FpX_degree(GEN T);
5954
INLINE GEN    get_FpX_mod(GEN T);
5955
INLINE long   get_FpX_var(GEN T);
5956
INLINE long   get_FpXQX_degree(GEN T);
5957
INLINE GEN    get_FpXQX_mod(GEN T);
5958
INLINE long   get_FpXQX_var(GEN T);
5959

5960
INLINE ulong  F2m_coeff(GEN x, long a, long b);
5961
INLINE void   F2m_clear(GEN x, long a, long b);
5962
INLINE void   F2m_flip(GEN x, long a, long b);
5963
INLINE void   F2m_set(GEN x, long a, long b);
5964
INLINE void   F2v_clear(GEN x,long v);
5965
INLINE ulong  F2v_coeff(GEN x,long v);
5966
INLINE void   F2v_flip(GEN x,long v);
5967
INLINE GEN    F2v_to_F2x(GEN x, long sv);
5968
INLINE void   F2v_set(GEN x,long v);
5969
INLINE void   F2x_clear(GEN x,long v);
5970
INLINE ulong  F2x_coeff(GEN x,long v);
5971
INLINE void   F2x_flip(GEN x,long v);
5972
INLINE void   F2x_set(GEN x,long v);
5973
INLINE int    F2x_equal1(GEN x);
5974
INLINE int    F2x_equal(GEN V, GEN W);
5975
INLINE GEN    F2x_div(GEN x, GEN y);
5976
INLINE GEN    F2x_renormalize(GEN x, long lx);
5977
INLINE GEN    F2m_copy(GEN x);
5978
INLINE GEN    F2v_copy(GEN x);
5979
INLINE GEN    F2x_copy(GEN x);
5980
INLINE GEN    F2v_ei(long n, long i);
5981
INLINE ulong  F3m_coeff(GEN x, long a, long b);
5982
INLINE void   F3m_set(GEN x, long a, long b, ulong c);
5983
INLINE GEN    F3m_copy(GEN x);
5984
INLINE GEN    Flm_copy(GEN x);
5985
INLINE GEN    Flv_copy(GEN x);
5986
INLINE int    Flx_equal1(GEN x);
5987
INLINE ulong  Flx_constant(GEN x);
5988
INLINE GEN    Flx_copy(GEN x);
5989
INLINE GEN    Flx_div(GEN x, GEN y, ulong p);
5990
INLINE ulong  Flx_lead(GEN x);
5991
INLINE GEN    Flx_mulu(GEN x, ulong a, ulong p);
5992
INLINE GEN    Fp_divu(GEN x, ulong a, GEN p);
5993
INLINE GEN    FpV_FpC_mul(GEN x, GEN y, GEN p);
5994
INLINE GEN    FpXQX_renormalize(GEN x, long lx);
5995
INLINE GEN    FpXX_renormalize(GEN x, long lx);
5996
INLINE GEN    FpX_div(GEN x, GEN y, GEN p);
5997
INLINE GEN    FpX_renormalize(GEN x, long lx);
5998
INLINE GEN    Fp_add(GEN a, GEN b, GEN m);
5999
INLINE GEN    Fp_addmul(GEN x, GEN y, GEN z, GEN p);
6000
INLINE GEN    Fp_center(GEN u, GEN p, GEN ps2);
6001
INLINE GEN    Fp_center_i(GEN u, GEN p, GEN ps2);
6002
INLINE GEN    Fp_div(GEN a, GEN b, GEN m);
6003
INLINE GEN    Fp_halve(GEN y, GEN p);
6004
INLINE GEN    Fp_inv(GEN a, GEN m);
6005
INLINE GEN    Fp_invsafe(GEN a, GEN m);
6006
INLINE GEN    Fp_mul(GEN a, GEN b, GEN m);
6007
INLINE GEN    Fp_muls(GEN a, long b, GEN m);
6008
INLINE GEN    Fp_mulu(GEN a, ulong b, GEN m);
6009
INLINE GEN    Fp_neg(GEN b, GEN m);
6010
INLINE GEN    Fp_red(GEN x, GEN p);
6011
INLINE GEN    Fp_sqr(GEN a, GEN m);
6012
INLINE GEN    Fp_sub(GEN a, GEN b, GEN m);
6013
INLINE GEN    GENbinbase(GENbin *p);
6014
INLINE GEN    Q_abs(GEN x);
6015
INLINE GEN    Q_abs_shallow(GEN x);
6016
INLINE int    QV_isscalar(GEN x);
6017
INLINE void   Qtoss(GEN q, long *n, long *d);
6018
INLINE GEN    R_abs(GEN x);
6019
INLINE GEN    R_abs_shallow(GEN x);
6020
INLINE GEN    RgC_fpnorml2(GEN x, long prec);
6021
INLINE GEN    RgC_gtofp(GEN x, long prec);
6022
INLINE GEN    RgC_gtomp(GEN x, long prec);
6023
INLINE void   RgM_dimensions(GEN x, long *m, long *n);
6024
INLINE GEN    RgM_fpnorml2(GEN x, long prec);
6025
INLINE GEN    RgM_gtofp(GEN x, long prec);
6026
INLINE GEN    RgM_gtomp(GEN x, long prec);
6027
INLINE GEN    RgM_minor(GEN a, long i, long j);
6028
INLINE GEN    RgM_shallowcopy(GEN x);
6029
INLINE GEN    RgV_gtofp(GEN x, long prec);
6030
INLINE int    RgV_isscalar(GEN x);
6031
INLINE long   RgV_isin(GEN v, GEN x);
6032
INLINE long   RgV_isin_i(GEN v, GEN x, long n);
6033
INLINE int    RgV_is_ZV(GEN x);
6034
INLINE int    RgV_is_QV(GEN x);
6035
INLINE long   RgX_equal_var(GEN x, GEN y);
6036
INLINE int    RgX_is_monomial(GEN x);
6037
INLINE int    RgX_is_rational(GEN x);
6038
INLINE int    RgX_is_QX(GEN x);
6039
INLINE int    RgX_is_ZX(GEN x);
6040
INLINE int    RgX_isscalar(GEN x);
6041
INLINE GEN    RgX_shift_inplace(GEN x, long v);
6042
INLINE void   RgX_shift_inplace_init(long v);
6043
INLINE GEN    RgX_to_RgV(GEN x, long N);
6044
INLINE GEN    RgXQX_div(GEN x, GEN y, GEN T);
6045
INLINE GEN    RgXQX_rem(GEN x, GEN y, GEN T);
6046
INLINE GEN    RgX_coeff(GEN x, long n);
6047
INLINE GEN    RgX_copy(GEN x);
6048
INLINE GEN    RgX_div(GEN x, GEN y);
6049
INLINE GEN    RgX_fpnorml2(GEN x, long prec);
6050
INLINE GEN    RgX_gtofp(GEN x, long prec);
6051
INLINE GEN    RgX_renormalize(GEN x);
6052
INLINE GEN    Rg_col_ei(GEN x, long n, long i);
6053
INLINE GEN    ZC_hnfrem(GEN x, GEN y);
6054
INLINE GEN    ZM_hnfrem(GEN x, GEN y);
6055
INLINE GEN    ZM_lll(GEN x, double D, long f);
6056
INLINE int    ZV_dvd(GEN x, GEN y);
6057
INLINE int    ZV_isscalar(GEN x);
6058
INLINE GEN    ZV_to_zv(GEN x);
6059
INLINE int    ZX_equal1(GEN x);
6060
INLINE int    ZX_is_monic(GEN x);
6061
INLINE GEN    ZX_renormalize(GEN x, long lx);
6062
INLINE GEN    ZXQ_mul(GEN x,GEN y,GEN T);
6063
INLINE GEN    ZXQ_sqr(GEN x,GEN T);
6064
INLINE long   Z_ispower(GEN x, ulong k);
6065
INLINE long   Z_issquare(GEN x);
6066
INLINE GEN    absfrac(GEN x);
6067
INLINE GEN    absfrac_shallow(GEN x);
6068
INLINE GEN    affc_fixlg(GEN x, GEN res);
6069
INLINE GEN    bin_copy(GENbin *p);
6070
INLINE long   bit_accuracy(long x);
6071
INLINE double bit_accuracy_mul(long x, double y);
6072
INLINE long   bit_prec(GEN x);
6073
INLINE int    both_odd(long x, long y);
6074
INLINE GEN    cbrtr(GEN x);
6075
INLINE GEN    cbrtr_abs(GEN x);
6076
INLINE GEN    cgetc(long x);
6077
INLINE GEN    cgetalloc(long t, size_t l);
6078
INLINE void   cgiv(GEN x);
6079
INLINE GEN    col_ei(long n, long i);
6080
INLINE GEN    const_col(long n, GEN x);
6081
INLINE GEN    const_vec(long n, GEN x);
6082
INLINE GEN    const_vecsmall(long n, long c);
6083
INLINE GEN    constant_coeff(GEN x);
6084
INLINE GEN    cxcompotor(GEN z, long prec);
6085
INLINE GEN    cxnorm(GEN x);
6086
INLINE GEN    cxtoreal(GEN q);
6087
INLINE GEN    cyclic_perm(long l, long d);
6088
INLINE double dbllog2r(GEN x);
6089
INLINE long   degpol(GEN x);
6090
INLINE long   divsBIL(long n);
6091
INLINE void   gabsz(GEN x, long prec, GEN z);
6092
INLINE GEN    gaddgs(GEN y, long s);
6093
INLINE void   gaddz(GEN x, GEN y, GEN z);
6094
INLINE int    gcmpgs(GEN y, long s);
6095
INLINE void   gdiventz(GEN x, GEN y, GEN z);
6096
INLINE GEN    gdivsg(long s, GEN y);
6097
INLINE void   gdivz(GEN x, GEN y, GEN z);
6098
INLINE GEN    gen_I(void);
6099
INLINE void   gerepileall(pari_sp av, int n, ...);
6100
INLINE void   gerepilecoeffs(pari_sp av, GEN x, int n);
6101
INLINE GEN    gerepilecopy(pari_sp av, GEN x);
6102
INLINE void   gerepilemany(pari_sp av, GEN* g[], int n);
6103
INLINE int    gequalgs(GEN y, long s);
6104
INLINE GEN    gerepileupto(pari_sp av, GEN q);
6105
INLINE GEN    gerepileuptoint(pari_sp av, GEN q);
6106
INLINE GEN    gerepileuptoleaf(pari_sp av, GEN q);
6107
INLINE int    gisdouble(GEN x, double *g);
6108
INLINE GEN    gmax_shallow(GEN x, GEN y);
6109
INLINE GEN    gmaxsg(long s, GEN y);
6110
INLINE GEN    gmin_shallow(GEN x, GEN y);
6111
INLINE GEN    gminsg(long s, GEN y);
6112
INLINE void   gmodz(GEN x, GEN y, GEN z);
6113
INLINE void   gmul2nz(GEN x, long s, GEN z);
6114
INLINE GEN    gmulgs(GEN y, long s);
6115
INLINE void   gmulz(GEN x, GEN y, GEN z);
6116
INLINE void   gnegz(GEN x, GEN z);
6117
INLINE void   gshiftz(GEN x, long s, GEN z);
6118
INLINE GEN    gsubgs(GEN y, long s);
6119
INLINE void   gsubz(GEN x, GEN y, GEN z);
6120
INLINE double gtodouble(GEN x);
6121
INLINE GEN    gtofp(GEN z, long prec);
6122
INLINE GEN    gtomp(GEN z, long prec);
6123
INLINE long   gtos(GEN x);
6124
INLINE ulong  gtou(GEN x);
6125
INLINE void   guncloneNULL(GEN x);
6126
INLINE void   guncloneNULL_deep(GEN x);
6127
INLINE long   gval(GEN x, long v);
6128
INLINE GEN    identity_perm(long l);
6129
INLINE GEN    identity_zv(long n);
6130
INLINE GEN    identity_ZV(long n);
6131
INLINE int    equali1(GEN n);
6132
INLINE int    equalim1(GEN n);
6133
INLINE long   inf_get_sign(GEN x);
6134
INLINE GEN    inv_content(GEN c);
6135
INLINE int    is_bigint(GEN n);
6136
INLINE int    is_const_t(long t);
6137
INLINE int    is_extscalar_t(long t);
6138
INLINE int    is_intreal_t(long t);
6139
INLINE int    is_matvec_t(long t);
6140
INLINE int    is_noncalc_t(long tx);
6141
INLINE int    is_pm1(GEN n);
6142
INLINE int    is_qfb_t(long t);
6143
INLINE int    is_rational_t(long t);
6144
INLINE int    is_real_t(long t);
6145
INLINE int    is_recursive_t(long t);
6146
INLINE int    is_scalar_t(long t);
6147
INLINE int    is_universal_constant(GEN x);
6148
INLINE int    is_vec_t(long t);
6149
INLINE int    isint1(GEN x);
6150
INLINE int    isintm1(GEN x);
6151
INLINE int    isintzero(GEN x);
6152
INLINE int    ismpzero(GEN x);
6153
INLINE int    isonstack(GEN x);
6154
INLINE void   killblock(GEN x);
6155
INLINE GEN    leading_coeff(GEN x);
6156
INLINE void   lg_increase(GEN x);
6157
INLINE long   lgcols(GEN x);
6158
INLINE long   lgpol(GEN x);
6159
INLINE GEN    div_content(GEN cx, GEN cy);
6160
INLINE GEN    matpascal(long n);
6161
INLINE GEN    matslice(GEN A, long x1, long x2, long y1, long y2);
6162
INLINE GEN    mkcol(GEN x);
6163
INLINE GEN    mkcol2(GEN x, GEN y);
6164
INLINE GEN    mkcol2s(long x, long y);
6165
INLINE GEN    mkcol3(GEN x, GEN y, GEN z);
6166
INLINE GEN    mkcol3s(long x, long y, long z);
6167
INLINE GEN    mkcol4(GEN x, GEN y, GEN z, GEN t);
6168
INLINE GEN    mkcol4s(long x, long y, long z, long t);
6169
INLINE GEN    mkcol5(GEN x, GEN y, GEN z, GEN t, GEN u);
6170
INLINE GEN    mkcol6(GEN x, GEN y, GEN z, GEN t, GEN u, GEN v);
6171
INLINE GEN    mkcolcopy(GEN x);
6172
INLINE GEN    mkcols(long x);
6173
INLINE GEN    mkcomplex(GEN x, GEN y);
6174
INLINE GEN    mkerr(long n);
6175
INLINE GEN    mkmoo(void);
6176
INLINE GEN    mkoo(void);
6177
INLINE GEN    mkfrac(GEN x, GEN y);
6178
INLINE GEN    mkfracss(long x, long y);
6179
INLINE GEN    mkfraccopy(GEN x, GEN y);
6180
INLINE GEN    mkintmod(GEN x, GEN y);
6181
INLINE GEN    mkintmodu(ulong x, ulong y);
6182
INLINE GEN    mkmat(GEN x);
6183
INLINE GEN    mkmat2(GEN x, GEN y);
6184
INLINE GEN    mkmat22(GEN a, GEN b, GEN c, GEN d);
6185
INLINE GEN    mkmat22s(long a, long b, long c, long d);
6186
INLINE GEN    mkmat3(GEN x, GEN y, GEN z);
6187
INLINE GEN    mkmat4(GEN x, GEN y, GEN z, GEN t);
6188
INLINE GEN    mkmat5(GEN x, GEN y, GEN z, GEN t, GEN u);
6189
INLINE GEN    mkmatcopy(GEN x);
6190
INLINE GEN    mkpolmod(GEN x, GEN y);
6191
INLINE GEN    mkqfb(GEN x, GEN y, GEN z, GEN d);
6192
INLINE GEN    mkquad(GEN n, GEN x, GEN y);
6193
INLINE GEN    mkrfrac(GEN x, GEN y);
6194
INLINE GEN    mkrfraccopy(GEN x, GEN y);
6195
INLINE GEN    mkvec(GEN x);
6196
INLINE GEN    mkvec2(GEN x, GEN y);
6197
INLINE GEN    mkvec2copy(GEN x, GEN y);
6198
INLINE GEN    mkvec2s(long x, long y);
6199
INLINE GEN    mkvec3(GEN x, GEN y, GEN z);
6200
INLINE GEN    mkvec3s(long x, long y, long z);
6201
INLINE GEN    mkvec4(GEN x, GEN y, GEN z, GEN t);
6202
INLINE GEN    mkvec4s(long x, long y, long z, long t);
6203
INLINE GEN    mkvec5(GEN x, GEN y, GEN z, GEN t, GEN u);
6204
INLINE GEN    mkveccopy(GEN x);
6205
INLINE GEN    mkvecs(long x);
6206
INLINE GEN    mkvecsmall(long x);
6207
INLINE GEN    mkvecsmall2(long x,long y);
6208
INLINE GEN    mkvecsmall3(long x,long y,long z);
6209
INLINE GEN    mkvecsmall4(long x,long y,long z,long t);
6210
INLINE GEN    mkvecsmall5(long x,long y,long z,long t,long u);
6211
INLINE void   mpcosz(GEN x, GEN z);
6212
INLINE void   mpexpz(GEN x, GEN z);
6213
INLINE void   mplogz(GEN x, GEN z);
6214
INLINE void   mpsinz(GEN x, GEN z);
6215
INLINE GEN    mul_content(GEN cx, GEN cy);
6216
INLINE GEN    mul_denom(GEN cx, GEN cy);
6217
INLINE long   nbits2nlong(long x);
6218
INLINE long   nbits2extraprec(long x);
6219
INLINE long   nbits2ndec(long x);
6220
INLINE long   nbits2prec(long x);
6221
INLINE long   nbits2lg(long x);
6222
INLINE long   nbrows(GEN x);
6223
INLINE long   nchar2nlong(long x);
6224
INLINE long   ndec2nbits(long x);
6225
INLINE long   ndec2nlong(long x);
6226
INLINE long   ndec2prec(long x);
6227
INLINE void   normalize_frac(GEN z);
6228
INLINE int    odd(long x);
6229
INLINE void   pari_free(void *pointer);
6230
INLINE void*  pari_calloc(size_t size);
6231
INLINE void*  pari_malloc(size_t bytes);
6232
INLINE void*  pari_realloc(void *pointer,size_t size);
6233
INLINE void   pari_realloc_ip(void **pointer,size_t size);
6234
INLINE GEN    perm_conj(GEN s, GEN t);
6235
INLINE GEN    perm_inv(GEN x);
6236
INLINE GEN    perm_mul(GEN s, GEN t);
6237
INLINE GEN    perm_sqr(GEN s);
6238
INLINE GEN    pol_0(long v);
6239
INLINE GEN    pol_1(long v);
6240
INLINE GEN    pol_x(long v);
6241
INLINE GEN    pol_xn(long n, long v);
6242
INLINE GEN    pol_xnall(long n, long v);
6243
INLINE GEN    pol0_F2x(long sv);
6244
INLINE GEN    pol0_Flx(long sv);
6245
INLINE GEN    pol1_F2x(long sv);
6246
INLINE GEN    pol1_Flx(long sv);
6247
INLINE GEN    polx_Flx(long sv);
6248
INLINE GEN    polx_F2x(long sv);
6249
INLINE GEN    polx_zx(long sv);
6250
INLINE GEN    polxn_Flx(long n, long sv);
6251
INLINE GEN    powii(GEN x, GEN n);
6252
INLINE GEN    powIs(long n);
6253
INLINE long   prec2nbits(long x);
6254
INLINE double prec2nbits_mul(long x, double y);
6255
INLINE long   prec2ndec(long x);
6256
INLINE long   precdbl(long x);
6257
INLINE GEN    quad_disc(GEN x);
6258
INLINE GEN    qfb_disc(GEN x);
6259
INLINE GEN    qfb_disc3(GEN x, GEN y, GEN z);
6260
INLINE GEN    quadnorm(GEN q);
6261
INLINE long   remsBIL(long n);
6262
INLINE GEN    row(GEN A, long x1);
6263
INLINE GEN    Flm_row(GEN A, long x0);
6264
INLINE GEN    row_i(GEN A, long x0, long x1, long x2);
6265
INLINE GEN    zm_row(GEN x, long i);
6266
INLINE GEN    rowcopy(GEN A, long x0);
6267
INLINE GEN    rowpermute(GEN A, GEN p);
6268
INLINE GEN    rowslice(GEN A, long x1, long x2);
6269
INLINE GEN    rowslicepermute(GEN A, GEN p, long x1, long x2);
6270
INLINE GEN    rowsplice(GEN a, long j);
6271
INLINE int    ser_isexactzero(GEN x);
6272
INLINE GEN    shallowcopy(GEN x);
6273
INLINE GEN    sqrfrac(GEN x);
6274
INLINE GEN    sqrti(GEN x);
6275
INLINE GEN    sqrtnr(GEN x, long n);
6276
INLINE GEN    sqrtr(GEN x);
6277
INLINE GEN    sstoQ(long n, long d);
6278
INLINE void   pari_stack_alloc(pari_stack *s, long nb);
6279
INLINE void** pari_stack_base(pari_stack *s);
6280
INLINE void   pari_stack_delete(pari_stack *s);
6281
INLINE void   pari_stack_init(pari_stack *s, size_t size, void **data);
6282
INLINE long   pari_stack_new(pari_stack *s);
6283
INLINE void   pari_stack_pushp(pari_stack *s, void *u);
6284
INLINE long   sturm(GEN x);
6285
INLINE GEN    truecoef(GEN x, long n);
6286
INLINE GEN    trunc_safe(GEN x);
6287
INLINE GEN    vec_ei(long n, long i);
6288
INLINE GEN    vec_append(GEN v, GEN s);
6289
INLINE GEN    vec_lengthen(GEN v, long n);
6290
INLINE GEN    vec_prepend(GEN v, GEN s);
6291
INLINE GEN    vec_setconst(GEN v, GEN x);
6292
INLINE GEN    vec_shorten(GEN v, long n);
6293
INLINE GEN    vec_to_vecsmall(GEN z);
6294
INLINE GEN    vecpermute(GEN A, GEN p);
6295
INLINE GEN    vecreverse(GEN A);
6296
INLINE void   vecreverse_inplace(GEN y);
6297
INLINE GEN    vecsmallpermute(GEN A, GEN p);
6298
INLINE GEN    vecslice(GEN A, long y1, long y2);
6299
INLINE GEN    vecslicepermute(GEN A, GEN p, long y1, long y2);
6300
INLINE GEN    vecsplice(GEN a, long j);
6301
INLINE GEN    vecsmall_append(GEN V, long s);
6302
INLINE long   vecsmall_coincidence(GEN u, GEN v);
6303
INLINE GEN    vecsmall_concat(GEN u, GEN v);
6304
INLINE GEN    vecsmall_copy(GEN x);
6305
INLINE GEN    vecsmall_ei(long n, long i);
6306
INLINE long   vecsmall_indexmax(GEN x);
6307
INLINE long   vecsmall_indexmin(GEN x);
6308
INLINE long   vecsmall_isin(GEN v, long x);
6309
INLINE GEN    vecsmall_lengthen(GEN v, long n);
6310
INLINE int    vecsmall_lexcmp(GEN x, GEN y);
6311
INLINE long   vecsmall_max(GEN v);
6312
INLINE long   vecsmall_min(GEN v);
6313
INLINE long   vecsmall_pack(GEN V, long base, long mod);
6314
INLINE int    vecsmall_prefixcmp(GEN x, GEN y);
6315
INLINE GEN    vecsmall_prepend(GEN V, long s);
6316
INLINE GEN    vecsmall_reverse(GEN A);
6317
INLINE GEN    vecsmall_shorten(GEN v, long n);
6318
INLINE GEN    vecsmall_to_col(GEN z);
6319
INLINE GEN    vecsmall_to_vec(GEN z);
6320
INLINE GEN    vecsmall_to_vec_inplace(GEN z);
6321
INLINE void   vecsmalltrunc_append(GEN x, long t);
6322
INLINE GEN    vecsmalltrunc_init(long l);
6323
INLINE void   vectrunc_append(GEN x, GEN t);
6324
INLINE void   vectrunc_append_batch(GEN x, GEN y);
6325
INLINE GEN    vectrunc_init(long l);
6326
INLINE GEN    coltrunc_init(long l);
6327
INLINE GEN    zc_to_ZC(GEN x);
6328
INLINE GEN    zero_F2m(long n, long m);
6329
INLINE GEN    zero_F2m_copy(long n, long m);
6330
INLINE GEN    zero_F2v(long m);
6331
INLINE GEN    zero_F2x(long sv);
6332
INLINE GEN    zero_Flm(long m, long n);
6333
INLINE GEN    zero_Flm_copy(long m, long n);
6334
INLINE GEN    zero_Flv(long n);
6335
INLINE GEN    zero_Flx(long sv);
6336
INLINE GEN    zero_zm(long x, long y);
6337
INLINE GEN    zero_zv(long x);
6338
INLINE GEN    zero_zx(long sv);
6339
INLINE GEN    zerocol(long n);
6340
INLINE GEN    zeromat(long m, long n);
6341
INLINE GEN    zeromatcopy(long m, long n);
6342
INLINE GEN    zeropadic(GEN p, long e);
6343
INLINE GEN    zeropadic_shallow(GEN p, long e);
6344
INLINE GEN    zeropol(long v);
6345
INLINE GEN    zeroser(long v, long e);
6346
INLINE GEN    zerovec(long n);
6347
INLINE GEN    zerovec_block(long len);
6348
INLINE GEN    zm_copy(GEN x);
6349
INLINE GEN    zm_to_zxV(GEN x, long sv);
6350
INLINE GEN    zm_transpose(GEN x);
6351
INLINE GEN    zv_copy(GEN x);
6352
INLINE GEN    zv_to_ZV(GEN x);
6353
INLINE GEN    zv_to_zx(GEN x, long sv);
6354
INLINE GEN    zx_renormalize(GEN x, long l);
6355
INLINE GEN    zx_shift(GEN x, long n);
6356
INLINE GEN    zx_to_zv(GEN x, long N);
6357

6358
INLINE GEN     err_get_compo(GEN e, long i);
6359
INLINE long    err_get_num(GEN e);
6360
INLINE void    pari_err_BUG(const char *f);
6361
INLINE void    pari_err_COMPONENT(const char *f, const char *op, GEN l, GEN x);
6362
INLINE void    pari_err_CONSTPOL(const char *f);
6363
INLINE void    pari_err_COPRIME(const char *f, GEN x, GEN y);
6364
INLINE void    pari_err_DIM(const char *f);
6365
INLINE void    pari_err_DOMAIN(const char *f, const char *v, const char *op, GEN l, GEN x);
6366
INLINE void    pari_err_FILE(const char *f, const char *g);
6367
INLINE void    pari_err_FILEDESC(const char *f, long n);
6368
INLINE void    pari_err_FLAG(const char *f);
6369
INLINE void    pari_err_IMPL(const char *f);
6370
INLINE void    pari_err_INV(const char *f, GEN x);
6371
INLINE void    pari_err_IRREDPOL(const char *f, GEN x);
6372
INLINE void    pari_err_MAXPRIME(ulong c);
6373
INLINE void    pari_err_MODULUS(const char *f, GEN x, GEN y);
6374
INLINE void    pari_err_OP(const char *f, GEN x, GEN y);
6375
INLINE void    pari_err_OVERFLOW(const char *f);
6376
INLINE void    pari_err_PACKAGE(const char *f);
6377
INLINE void    pari_err_PREC(const char *f);
6378
INLINE void    pari_err_PRIME(const char *f, GEN x);
6379
INLINE void    pari_err_PRIORITY(const char *f, GEN x, const char *op, long v);
6380
INLINE void    pari_err_SQRTN(const char *f, GEN x);
6381
INLINE void    pari_err_TYPE(const char *f, GEN x);
6382
INLINE void    pari_err_TYPE2(const char *f, GEN x, GEN y);
6383
INLINE void    pari_err_VAR(const char *f, GEN x, GEN y);
6384
INLINE void    pari_err_ROOTS0(const char *f);
6385

6386
/* pic.c */
6387
void timers_printf(const char* msg1, const char* msg2, pari_timer* pCPU, pari_timer* pW);
6388
GEN matkerpadic(GEN A, GEN T, GEN pe, GEN p, long e);
6389
GEN mateqnpadic(GEN A, GEN T, GEN pe, GEN p, long e);
6390
GEN PicCard(GEN J);
6391
GEN PicAdd(GEN J, GEN W1, GEN W2);
6392
GEN PicChord(GEN J, GEN W1, GEN W2, long flag);
6393
GEN PicMul(GEN J, GEN W, GEN n, long flag);
6394
GEN PicNeg(GEN J, GEN W, long flag);
6395
GEN PicSub(GEN J, GEN W1, GEN W2);
6396
GEN PicAut(GEN J, GEN W, ulong nAut);
6397
GEN PicFrob(GEN J, GEN W);
6398
GEN PicFrobInv(GEN J, GEN W);
6399
GEN PicFrobPoly(GEN J, GEN W, GEN F);
6400
ulong PicMember_val(GEN J, GEN W);
6401
ulong PicIsZero_val(GEN J, GEN W);
6402
ulong PicIsTors_val(GEN J, GEN W, GEN F);
6403
ulong PicEq_val(GEN J, GEN W1, GEN W2);
6404
int PicMember(GEN J, GEN W);
6405
int PicIsZero(GEN J, GEN W);
6406
int PicIsTors(GEN J, GEN W, GEN F);
6407
int PicEq(GEN J, GEN W1, GEN W2);
6408
GEN RRspaceEval(GEN L, GEN vars, GEN pts, GEN T, GEN pe, GEN p, long e);
6409
GEN PicTorsOrd(GEN J, GEN W, GEN l, long flag);
6410
GEN PicInit(GEN f, GEN Auts, ulong g, ulong d0, GEN L, GEN bad, GEN p, ulong a, long e, GEN Lp);
6411
GEN PicRand(GEN J, GEN randseed);
6412
GEN PicLiftTors(GEN J, GEN W, GEN l, long eini, long multiple_allowed);
6413
GEN PicSetPrec(GEN J, long e);
6414
GEN OnePol(GEN N, GEN D, GEN ImodF, GEN Jfrobmat, ulong l, GEN QqFrobMat, GEN T, GEN pe);
6415
GEN PicLift_worker(GEN V0j, ulong shift, GEN uv, GEN AinvB, GEN CAinv, GEN T, GEN pe21);
6416
GEN PicLiftTors_Chart_worker(GEN randseed, GEN J, GEN l, GEN U, GEN U0, GEN I, GEN KM, GEN pe1, GEN pe21, long e21, GEN c0, ulong P0, GEN P1);
6417
GEN TorsSpaceFrob_worker(GEN W1, GEN X1, GEN W2, GEN X2, GEN J);
6418
GEN PicEval_worker(GEN W, GEN J);
6419
GEN PicTorsPairingInit(GEN J, GEN l);
6420
GEN PicTorsPairing_Modl(GEN J, GEN FRparams, GEN W, GEN X);
6421
GEN PicTorsPairing(GEN J, GEN FRparams, GEN W, GEN X);
6422
GEN PicLC(GEN J, GEN C, GEN W);
6423
GEN PlaneZeta(GEN f, ulong p);
6424
GEN SuperZeta(GEN f, ulong m, ulong p);
6425
long TotalDegree(GEN F);
6426
GEN PolHomogenise(GEN f, GEN z, long D);
6427
long PtIsOnPlaneCurve(GEN F, GEN P);
6428
long PtIsOnSuperellCurve(GEN f, ulong m, GEN P);
6429
long PtIsOnHyperellCurve(GEN F, GEN P);
6430
GEN HyperPicInit(GEN f, GEN p, ulong a, long e, GEN P12);
6431
GEN SuperPicInit(GEN f, ulong m, GEN p, ulong a, long e, GEN P12);
6432
GEN SmoothPicInit(GEN f, GEN p, ulong a, long e, GEN P);
6433
GEN PicRandTors(GEN J, GEN l, GEN Chi, GEN Phi, GEN seed, long returnlpow);
6434
GEN PicTorsBasis_worker(GEN J, GEN l, GEN Chi, GEN Phi, GEN FRparams, GEN Lintests, GEN LinTestsNames, GEN seed);
6435
GEN PicTorsBasis(GEN J, GEN l, GEN Chi);
6436
GEN FpX_root_order_bound(GEN f, GEN p);
6437
GEN PicTorsGalRep(GEN J, GEN l, GEN Chi);
6438
GEN ProjGalRep(GEN R);
6439
GEN HyperGalRep(GEN f, GEN l, GEN p, ulong e, GEN P, GEN chi, ulong force_a);
6440
GEN SuperGalRep(GEN f, ulong m ,GEN l, GEN p, ulong e, GEN P, GEN chi, ulong force_a);
6441
GEN SmoothGalRep(GEN f, GEN l, GEN p, ulong e, GEN P, GEN chi, ulong force_a);
6442
GEN LMod_worker(GEN p, GEN Gchi, GEN S, long t, GEN Z, GEN zo, GEN MZ);
6443
GEN Ell_FillTors_worker(GEN Axes, GEN a4, ulong y, GEN T, GEN pe, GEN p, long e);
6444
GEN Ell_l1_worker(GEN EN, GEN a4, ulong y, GEN T, GEN pe, GEN p, long e);
6445
GEN M2_worker(GEN vw, GEN Ml1, GEN TH, GEN Mpts, GEN T, GEN pe);
6446
GEN TrE2qexp(GEN vw, ulong N, GEN H, GEN M, ulong w, GEN zpows, ulong B, GEN T, GEN pe, GEN p, long e);
6447
GEN M4qexp_worker(GEN pageV1, GEN V2gens, GEN U0, GEN T, GEN pe);
6448
GEN ModPicInit(ulong N, GEN H, GEN p, ulong a, long e, GEN Lp, long UseTp, ulong nbE, ulong qprec);
6449
GEN mfgalrep(GEN f, GEN l, GEN prange, ulong D, long UseTp, ulong nbE, ulong qprec);
6450

6451
Product

Resources

Company
