/* Returns 0 (composite), 1 (didn't find a point), 2 (found point) */
int ecpp_check_point(mpz_t x, mpz_t y, mpz_t m, mpz_t q, mpz_t a, mpz_t N,
mpz_t t, mpz_t t2)
{
struct ec_affine_point P, P1, P2;
int result = 1;
mpz_init_set(P.x, x); mpz_init_set(P.y, y);
mpz_init(P1.x); mpz_init(P1.y);
mpz_init(P2.x); mpz_init(P2.y);
mpz_tdiv_q(t, m, q);
if (!ec_affine_multiply(a, t, N, P, &P2, t2)) {
mpz_tdiv_q(t, m, q);
/* P2 should not be (0,1) */
if (!(mpz_cmp_ui(P2.x, 0) == 0 && mpz_cmp_ui(P2.y, 1) == 0)) {
mpz_set(t, q);
if (!ec_affine_multiply(a, t, N, P2, &P1, t2)) {
/* P1 should be (0,1) */
if (mpz_cmp_ui(P1.x, 0) == 0 && mpz_cmp_ui(P1.y, 1) == 0) {
result = 2;
}
} else result = 0;
}
} else result = 0;
mpz_clear(P.x); mpz_clear(P.y);
mpz_clear(P1.x); mpz_clear(P1.y);
mpz_clear(P2.x); mpz_clear(P2.y);
return result;
}
int
main (int argc, char *argv[])
{
gmp_randstate_t rs;
mpz_t x, y, z;
unsigned long int m, n, i, niter, t0, ti;
double t, f, ops_per_sec;
int decimals;
if (argc != 3)
{
fprintf (stderr, "usage: %s m n\n", argv[0]);
fprintf (stderr, " where m is number of dividend bits\n");
fprintf (stderr, " and n is number of divisor bits\n");
return -1;
}
m = atoi (argv[1]);
n = atoi (argv[2]);
gmp_randinit_default (rs);
mpz_init (x);
mpz_init (y);
mpz_init (z);
mpz_urandomb (x, rs, m);
mpz_urandomb (y, rs, n);
printf ("Calibrating CPU speed..."); fflush (stdout);
TIME (t, mpz_tdiv_q (z, x, y));
printf ("done\n");
niter = 1 + (unsigned long) (1e4 / t);
printf ("Dividing an %lu-bit number by an %lu-bit number %lu times...",
m, n, niter);
fflush (stdout);
t0 = cputime ();
for (i = niter; i > 0; i--)
{
mpz_tdiv_q (z, x, y);
}
ti = cputime () - t0;
printf ("done!\n");
ops_per_sec = 1000.0 * niter / ti;
f = 100.0;
for (decimals = 0;; decimals++)
{
if (ops_per_sec > f)
break;
f = f * 0.1;
}
printf ("RESULT: %.*f operations per second\n", decimals, ops_per_sec);
return 0;
}
void decryption(){
mpz_powm(tmpI, c/*base*/, lambda/*exp*/, nn/*mod*/); // tmp = base^exp modulo mod
mpz_sub_ui(tmpI,tmpI,1);
mpz_tdiv_q(tmpI, tmpI, n);
mpz_powm(tmpII, g/*base*/, lambda/*exp*/, nn/*mod*/); // tmp = base^exp modulo mod
mpz_sub_ui(tmpII,tmpII,1);
mpz_tdiv_q(tmpII, tmpII, n);
mpz_invert (tmpII,tmpII,n);
mpz_mul(tmpI,tmpII,tmpI);
mpz_mod(tmpI, tmpI, n);
gmp_printf ("\nDecryption = %Zd\n", tmpI);
}
void qsieve_divide(mpz_t x, mpz_t y, mpz_t z)
{
if(x != z) mpz_tdiv_r(TD, x, y);
if(y != z) mpz_tdiv_q(TC, x, y);
if(x != z) if(TD!=x) mpz_set(x, TD);
if(y != z) if(TC!=z) mpz_set(z, TC);
}
/*------------------------------------------------------------------------*/
static uint32
lift_roots(sieve_fb_t *s, curr_poly_t *c,
uint64 p, uint32 num_roots)
{
uint32 i;
uint32 degree = s->degree;
uint64_2gmp(p, s->p);
mpz_mul(s->p2, s->p, s->p);
mpz_tdiv_r(s->nmodp2, c->trans_N, s->p2);
mpz_sub(s->tmp1, c->trans_m0, c->mp_sieve_size);
mpz_tdiv_r(s->m0, s->tmp1, s->p2);
for (i = 0; i < num_roots; i++) {
mpz_powm_ui(s->tmp1, s->roots[i], (mp_limb_t)degree, s->p2);
mpz_sub(s->tmp1, s->nmodp2, s->tmp1);
if (mpz_cmp_ui(s->tmp1, (mp_limb_t)0) < 0)
mpz_add(s->tmp1, s->tmp1, s->p2);
mpz_tdiv_q(s->tmp1, s->tmp1, s->p);
mpz_powm_ui(s->tmp2, s->roots[i], (mp_limb_t)(degree-1), s->p);
mpz_mul_ui(s->tmp2, s->tmp2, (mp_limb_t)degree);
mpz_invert(s->tmp2, s->tmp2, s->p);
mpz_mul(s->tmp1, s->tmp1, s->tmp2);
mpz_tdiv_r(s->tmp1, s->tmp1, s->p);
mpz_addmul(s->roots[i], s->tmp1, s->p);
mpz_sub(s->roots[i], s->roots[i], s->m0);
if (mpz_cmp_ui(s->roots[i], (mp_limb_t)0) < 0)
mpz_add(s->roots[i], s->roots[i], s->p2);
}
return num_roots;
}
int
promoteToMPZNumber(number *n)
{ switch(n->type)
{ case V_INTEGER:
mpz_init_set_si64(n->value.mpz, n->value.i);
n->type = V_MPZ;
break;
case V_MPZ:
break;
case V_MPQ:
{ mpz_t mpz;
mpz_init(mpz);
mpz_tdiv_q(mpz,
mpq_numref(n->value.mpq),
mpq_denref(n->value.mpq));
clearNumber(n);
n->type = V_MPZ;
n->value.mpz[0] = mpz[0];
break;
}
case V_FLOAT:
mpz_init_set_d(n->value.mpz, n->value.f);
n->type = V_MPZ;
break;
}
return TRUE;
}
/*
* Compute (ax +/- b)/d
*/
int b98_compute_frac(mpz_t result, const mpz_t a, const mpz_t x, const mpz_t b, const mpz_t d, int sign)
{
mpz_t num_tmp;
mpz_init(num_tmp);
mpz_mul(num_tmp, a, x);
switch (sign)
{
case B98_FRAC_ADD:
mpz_add(num_tmp, num_tmp, b);
break;
case B98_FRAC_SUB:
mpz_sub(num_tmp, num_tmp, b);
break;
default:
mpz_clear(num_tmp);
return -1;
}
mpz_tdiv_q (result, num_tmp, d);
mpz_clear(num_tmp);
return 0x00;
}
bool FermatProbablePrimalityTestFast(const mpz_class &n,
unsigned int& nLength,
CPrimalityTestParams &testParams,
bool fFastFail)
{
static const mpz_class mpzTwo = 2;
mpz_t& mpzE = testParams.mpzE;
mpz_t& mpzR = testParams.mpzR;
mpz_sub_ui(mpzE, n.get_mpz_t(), 1);
mpz_powm(mpzR, mpzTwo.get_mpz_t(), mpzE, n.get_mpz_t());
if (mpz_cmp_ui(mpzR, 1) == 0)
return true;
if (fFastFail)
return false;
// Fermat test failed, calculate chain length (integer and fractional part)
mpz_sub(mpzE, n.get_mpz_t(), mpzR);
mpz_mul_2exp(mpzR, mpzE, DifficultyFractionalBits);
mpz_tdiv_q(mpzE, mpzR, n.get_mpz_t());
unsigned int fractionalLength = mpz_get_ui(mpzE);
nLength = (nLength & DifficultyChainLengthMask) | fractionalLength;
return false;
}
void factor(mpz_t N)
{
int res;
char *str;
mpz_t divisor;
mpz_t next;
mpz_init(divisor);
mpz_init(next);
if (mpz_cmp(N, one) == 0)
return;
res = mpz_probab_prime_p(N, 10);
if (res) {
str = mpz_to_str(N);
if (!str)
return;
printf(" %s", str);
free(str);
return;
}
rho(divisor, N);
factor(divisor);
mpz_tdiv_q(next, N, divisor);
factor(next);
}
void
ppl_min_for_le_pointset (ppl_Pointset_Powerset_C_Polyhedron_t ps,
ppl_Linear_Expression_t le, mpz_t res)
{
ppl_Coefficient_t num, denom;
mpz_t dv, nv;
int minimum, err;
mpz_init (nv);
mpz_init (dv);
ppl_new_Coefficient (&num);
ppl_new_Coefficient (&denom);
err = ppl_Pointset_Powerset_C_Polyhedron_minimize (ps, le, num, denom, &minimum);
if (err > 0)
{
ppl_Coefficient_to_mpz_t (num, nv);
ppl_Coefficient_to_mpz_t (denom, dv);
gcc_assert (value_notzero_p (dv));
mpz_tdiv_q (res, nv, dv);
}
mpz_clear (nv);
mpz_clear (dv);
ppl_delete_Coefficient (num);
ppl_delete_Coefficient (denom);
}
double PrimeTester::EulerLagrangeLifchitzTest(const Bn& primePrev, bool bSophieGermain) {
((m_tmpNext = primePrev) <<= 1) += bSophieGermain ? 1 : -1;
unsigned mod = m_tmpNext.get_ui() % 8;
if (bSophieGermain) {
mpz_powm(m_tmp_R.get_mpz_t(), BN_2.get_mpz_t(), primePrev.get_mpz_t(), m_tmpNext.get_mpz_t());
} else {
mpz_sub_ui(m_tmp_N_Minus1.get_mpz_t(), primePrev.get_mpz_t(), 1);
mpz_powm(m_tmp_R.get_mpz_t(), BN_2.get_mpz_t(), m_tmp_N_Minus1.get_mpz_t(), m_tmpNext.get_mpz_t());
}
if (mod == (bSophieGermain ? 7 : 1)) {
if (m_tmp_R==1)
return 1;
} else if (mod == (bSophieGermain ? 3 : 5)) {
mpz_add_ui(m_tmp_T.get_mpz_t(), m_tmp_R.get_mpz_t(), 1);
if (m_tmp_T == m_tmpNext)
return 1;
}
mpz_mul(m_tmp_T.get_mpz_t(), m_tmp_R.get_mpz_t(), m_tmp_R.get_mpz_t());
mpz_tdiv_r(m_tmp_R.get_mpz_t(), m_tmp_T.get_mpz_t(), m_tmpNext.get_mpz_t()); // derive Fermat test remainder
m_tmp_T = (m_tmpNext - m_tmp_R) << 24;
mpz_tdiv_q(m_tmp_T.get_mpz_t(), m_tmp_T.get_mpz_t(), m_tmpNext.get_mpz_t());
int64_t len = m_tmp_T.get_ui();
// if (!(((n - r) << FRACTIONAL_BITS) / n).AsInt64(len) || len >= (1<<FRACTIONAL_BITS))
// Throw(E_FAIL);
return double(len) / (1 << FRACTIONAL_BITS);
}
/*------------------------------------------------------------------------*/
static void
search_coeffs_core(msieve_obj *obj, poly_search_t *poly,
uint32 deadline)
{
uint32 i, j;
uint32 degree = poly->degree;
uint32 num_poly = poly->num_poly;
uint32 mult = 0;
switch (degree) {
case 4: mult = 4 * 4 * 4 * 4; break;
case 5: mult = 5 * 5 * 5 * 5 * 5; break;
case 6: mult = 6 * 6 * 6 * 6 * 6 * 6; break;
}
for (i = 0; i < num_poly; i++) {
curr_poly_t *c = poly->batch + i;
mpz_mul_ui(c->trans_N, poly->N, (mp_limb_t)mult);
for (j = 0; j < degree - 1; j++)
mpz_mul(c->trans_N, c->trans_N, c->high_coeff);
mpz_root(c->trans_m0, c->trans_N, (mp_limb_t)degree);
mpz_tdiv_q(poly->m0, poly->N, c->high_coeff);
mpz_root(poly->m0, poly->m0, (mp_limb_t)degree);
c->sieve_size = c->coeff_max / mpz_get_d(poly->m0) *
c->p_size_max * c->p_size_max / degree;
mpz_set_d(c->mp_sieve_size, c->sieve_size);
}
sieve_lattice(obj, poly, 2000, 2001, 100000,
num_poly * deadline);
}
void nchoosek_gmp(mpz_t result, mpz_t n, mpz_t k) {
// special cases
if(mpz_cmp_ui(k, 0) < 0) {
mpz_set_ui(result, 0);
return;
}
if(mpz_cmp(k, n) > 0) {
mpz_set_ui(result, 0);
return;
}
mpz_t c;
mpz_init_set_ui(c, 0);
// symmetry
mpz_sub(c, n, k);
if(mpz_cmp(k, c) > 0) {
mpz_set(k, c);
}
mpz_cdiv_q_ui(c, n, 2);
if(mpz_cmp(k, c) > 0) {
mpz_sub(k, n, k);
}
mpz_set_ui(result, 1);
mpz_set_ui(c, 1);
for(; mpz_cmp(c, k) <= 0; mpz_add_ui(c, c, 1)) {
mpz_mul(result, result, n);
mpz_sub_ui(n, n, 1);
mpz_tdiv_q(result, result, c);
}
mpz_clear(c);
}
int main(int argc, char *argv[]) {
int i = 0, num_arg = 0;
mpz_t max, unit, num, token;
if (argc < 2) {
fprintf(stderr, "Usage: %s <num_tokens>\n", argv[0]);
exit(EXIT_FAILURE);
}
if (1 != sscanf(argv[1], "%d", &num_arg)) {
fprintf(stderr, "Cannot parse %s as number of tokens.\n", argv[1]);
exit(EXIT_FAILURE);
}
mpz_init(max);
mpz_init(unit);
mpz_init(num);
mpz_init(token);
mpz_set_ui(num, num_arg);
mpz_set_ui(token, 0); // start at token 0
mpz_ui_pow_ui(max, 2, (128-1));
mpz_tdiv_q(unit, max, num);
for (; i < num_arg; i++) {
gmp_printf("%Zd\n", token);
mpz_add(token, token, unit);
}
return 0;
}
void
generate (int limb_bits, int nail_bits, int base)
{
int numb_bits = limb_bits - nail_bits;
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, numb_bits);
mpz_set_ui (big_base, 1L);
chars_per_limb = 0;
for (;;)
{
mpz_mul_ui (big_base, big_base, (long) base);
if (mpz_cmp (big_base, t) > 0)
break;
chars_per_limb++;
}
chars_per_bit_exactly = 0.69314718055994530942 / log ((double) base);
mpz_ui_pow_ui (big_base, (long) base, (long) chars_per_limb);
normalization_steps = limb_bits - mpz_sizeinbase (big_base, 2);
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, 2*limb_bits - normalization_steps);
mpz_tdiv_q (big_base_inverted, t, big_base);
mpz_set_ui (t, 1L);
mpz_mul_2exp (t, t, limb_bits);
mpz_sub (big_base_inverted, big_base_inverted, t);
}
unsigned int choose(unsigned int nInt, unsigned int rInt)
{
mpz_t n, r, a, b;
if ( ((nInt - rInt) < 0)
|| ((nInt - rInt) >= TABLE_SIZE)
|| (nInt < 0)
|| (nInt >= TABLE_SIZE)
|| (rInt < 0)
|| (rInt >= TABLE_SIZE))
{
printf("bounds fail! n=%d r=%d\n", nInt, rInt);
exit(1);
}
mpz_init(n); mpz_init(r); mpz_init(a); mpz_init(b);
mpz_set_ui(n, nInt); mpz_set_ui(r, rInt);
mpz_set(a, factorialTable[nInt - rInt]); // (n - r)!
mpz_mul(b, factorialTable[rInt], a); // r!(n - r)!
mpz_tdiv_q(a, factorialTable[nInt], b);
if (mpz_cmp(a, cutoff) > 0)
{
printf("choose(%d,%d)=", nInt, rInt);
mpz_out_str(stdout, 10, a);
printf("\n");
return 1;
}
return 0;
}
void int_to_chargg(mpz_t we, int poz){
int l,ll;
mpz_set(wep,we);
mpz_ui_pow_ui(we_p,ch,m-1);
mpz_tdiv_q(we_p2,wep,we_p);
tab[(poz*m+0)]=mpz_get_ui(we_p2);
l=0;
for (ll=m-1;ll>1;ll--) {l++;
mpz_ui_pow_ui(we_p,ch,ll);
mpz_mod(we_p,wep,we_p);
mpz_ui_pow_ui(we_p2,ch,ll-1);
mpz_tdiv_q(we_p,we_p,we_p2);
tab[(poz*m+l)]=mpz_get_ui(we_p);
}
mpz_mod_ui(we_p,wep,ch);
tab[(poz*m+l+1)]=mpz_get_ui(we_p); }
void mpz_inverseModulo(mpz_t *v, mpz_t _aa, mpz_t _bb) // renvoi l'inverse de a mod b ou 0 si pas inversible
{
mpz_t _temp; mpz_init(_temp);
mpz_t _r; mpz_init(_r);
mpz_t _a; mpz_init(_a); mpz_set(_a,_aa);
mpz_t _b; mpz_init(_b); mpz_set(_b,_bb);
mpz_t _u2; mpz_init(_u2); mpz_set_ui(_u2,1);
mpz_t _u1; mpz_init(_u1); mpz_set_ui(_u1,0);
mpz_t _u; mpz_init(_u); mpz_set_ui(_u,0);
while (mpz_cmp_ui(_b,0) > 0 )
{
mpz_set(_u1,_u);
mpz_mod(_r,_a,_b);
mpz_tdiv_q(_temp,_a ,_b);
mpz_mul (_temp,_u1,_temp);
mpz_sub (_u ,_u2,_temp);
mpz_set (_u2 ,_u1);
if (mpz_cmp_ui(_r,1)==0) {printf("\n"); mpz_set(*v,_u); return ; }
else { mpz_set(_a,_b); mpz_set(_b,_r); }
}
mpz_set_ui(*v,0); // Les deux nombres ne sont pas inversibles, donc pas premiers entr eeux
}
static PyObject *
Pygmpy_t_div(PyObject *self, PyObject *args)
{
PyObject *x, *y;
PympzObject *q, *tempx, *tempy;
if (PyTuple_GET_SIZE(args) != 2) {
TYPE_ERROR("t_div() requires 'mpz','mpz' arguments");
return NULL;
}
x = PyTuple_GET_ITEM(args, 0);
y = PyTuple_GET_ITEM(args, 1);
if (!(q = Pympz_new()))
return NULL;
if (CHECK_MPZANY(x) && CHECK_MPZANY(y)) {
if (mpz_sgn(Pympz_AS_MPZ(y)) == 0) {
ZERO_ERROR("t_div() division by 0");
Py_DECREF((PyObject*)q);
return NULL;
}
mpz_tdiv_q(q->z, Pympz_AS_MPZ(x), Pympz_AS_MPZ(y));
}
else {
tempx = Pympz_From_Integer(x);
tempy = Pympz_From_Integer(y);
if (!tempx || !tempy) {
TYPE_ERROR("t_div() requires 'mpz','mpz' arguments");
Py_XDECREF((PyObject*)tempx);
Py_XDECREF((PyObject*)tempy);
Py_DECREF((PyObject*)q);
return NULL;
}
if (mpz_sgn(Pympz_AS_MPZ(tempy)) == 0) {
ZERO_ERROR("t_div() division by 0");
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
Py_DECREF((PyObject*)q);
return NULL;
}
mpz_tdiv_q(q->z, tempx->z, tempy->z);
Py_DECREF((PyObject*)tempx);
Py_DECREF((PyObject*)tempy);
}
return (PyObject*)q;
}
int rsa_import_key(rsa_private_key_t *key, int endian,
uint8_t *n, size_t n_len, uint8_t *e, size_t e_len,
uint8_t *p, uint8_t *q)
{
mpz_t t1, t2, phi;
if (n == NULL || n_len == 0 || (p == NULL && q == NULL)) return -1;
/* init key */
key->size = n_len << 3;
if (e == NULL || e_len == 0) {
mpz_init_set_ui(key->e, 65537);
} else {
mpz_init2(key->e, (e_len << 3) + GMP_NUMB_BITS);
mpz_import(key->e, e_len, endian, 1, 0, 0, e);
}
mpz_init2(key->n, key->size + GMP_NUMB_BITS);
mpz_init2(key->p, key->size / 2 + GMP_NUMB_BITS);
mpz_init2(key->q, key->size / 2 + GMP_NUMB_BITS);
mpz_init2(key->d, key->size + GMP_NUMB_BITS);
mpz_init2(key->u, key->size / 2 + GMP_NUMB_BITS);
mpz_init2(t1, key->size / 2 + GMP_NUMB_BITS);
mpz_init2(t2, key->size / 2 + GMP_NUMB_BITS);
mpz_init2(phi, key->size + GMP_NUMB_BITS);
/* import values */
mpz_import(key->n, n_len, endian, 1, 0, 0, n);
if (p != NULL) mpz_import(key->p, n_len / 2, endian, 1, 0, 0, p);
if (q != NULL) mpz_import(key->q, n_len / 2, endian, 1, 0, 0, q);
if (p == NULL) mpz_tdiv_q(key->p, key->n, key->q);
if (q == NULL) mpz_tdiv_q(key->q, key->n, key->p);
/* p shall be smaller than q */
if (mpz_cmp(key->p, key->q) > 0) mpz_swap(key->p, key->q);
/* calculate missing values */
mpz_sub_ui(t1, key->p, 1);
mpz_sub_ui(t2, key->q, 1);
mpz_mul(phi, t1, t2);
mpz_invert(key->d, key->e, phi);
mpz_invert(key->u, key->p, key->q);
/* release helper variables */
mpz_clear(t1);
mpz_clear(t2);
mpz_clear(phi);
/* test key */
if (rsa_test_key(key) != 0) {
rsa_release_private_key(key);
return -1;
}
return 0;
}
ui extract_digit(ui nth) {
// joggling between tmp1 and tmp2, so GMP won't have to use temp buffers
mpz_mul_ui(tmp1, num, nth);
mpz_add(tmp2, tmp1, acc);
mpz_tdiv_q(tmp1, tmp2, den);
return mpz_get_ui(tmp1);
}
VAL bigDiv(VM* vm, VAL x, VAL y) {
mpz_t* bigint;
VAL cl = allocate(vm, sizeof(Closure) + sizeof(mpz_t), 0);
bigint = (mpz_t*)(((char*)cl) + sizeof(Closure));
mpz_tdiv_q(*bigint, GETMPZ(GETBIG(vm,x)), GETMPZ(GETBIG(vm,y)));
SETTY(cl, BIGINT);
cl -> info.ptr = (void*)bigint;
return cl;
}
mpz ceil(mpq const & a) {
if (a.is_integer())
return a.get_numerator();
mpz r;
mpz_tdiv_q(mpq::zval(r), mpq_numref(a.m_val), mpq_denref(a.m_val));
if (a.is_pos())
++r;
return r;
}
mpz floor(mpq const & a) {
if (a.is_integer())
return a.get_numerator();
mpz r;
mpz_tdiv_q(mpq::zval(r), mpq_numref(a.m_val), mpq_denref(a.m_val));
if (a.is_neg())
--r;
return r;
}
void mpq::ceil() {
if (is_integer())
return;
bool pos = is_pos();
mpz_tdiv_q(mpq_numref(m_val), mpq_numref(m_val), mpq_denref(m_val));
mpz_set_ui(mpq_denref(m_val), 1);
if (pos)
mpz_add_ui(mpq_numref(m_val), mpq_numref(m_val), 1);
}
void mpq::floor() {
if (is_integer())
return;
bool neg = is_neg();
mpz_tdiv_q(mpq_numref(m_val), mpq_numref(m_val), mpq_denref(m_val));
mpz_set_ui(mpq_denref(m_val), 1);
if (neg)
mpz_sub_ui(mpq_numref(m_val), mpq_numref(m_val), 1);
}
BigNumberBase BigNumberBase::div(const BigNumberBase& x, const BigNumberBase& y)
{
if (x.m_prec != 0 || y.m_prec != 0)
{
abort();
}
BigNumberBase result;
mpz_tdiv_q(result.m_gmp->m_integer, x.m_gmp->m_integer, y.m_gmp->m_integer);
return result;
}
static void
get_no_of_elements(mpz_t ele, gfc_expr * u1, gfc_expr * l1, gfc_expr * s1)
{
/* nNoOfEle = (u1-l1)/s1 */
mpz_sub (ele, u1->value.integer, l1->value.integer);
if (s1 != NULL)
mpz_tdiv_q (ele, ele, s1->value.integer);
}
void
ovm_q_trunc2(oregister_t *l, oregister_t *r)
{
switch (r->t) {
case t_void:
ovm_raise(except_floating_point_error);
case t_word:
if (r->v.w == 0)
ovm_raise(except_floating_point_error);
l->t = t_mpz;
if (r->v.w > 0)
mpz_mul_ui(ozr(r), ozs(l), r->v.w);
else {
mpz_set_si(ozr(r), r->v.w);
mpz_mul(ozr(r), ozs(l), ozr(r));
}
mpz_tdiv_q(ozr(l), ozr(l), ozr(r));
check_mpz(l);
break;
case t_float:
ovm_trunc_d(l, mpq_get_d(oqr(l)) / r->v.d);
break;
case t_mpz:
mpz_tdiv_q(ozr(l), ozr(l), ozr(r));
check_mpz(l);
break;
case t_rat:
mpq_set_si(oqr(r), rat_num(r->v.r), rat_den(r->v.r));
case t_mpq:
l->t = t_mpz;
mpq_div(oqr(l), oqr(l), oqr(r));
mpz_tdiv_q(ozr(l), ozr(l), ozs(l));
check_mpz(l);
break;
case t_mpr:
mpfr_set_q(orr(l), oqr(l), thr_rnd);
ovm_trunc_r(l, orr(r));
break;
default:
ovm_raise(except_not_a_real_number);
}
}
void special_tests(void)
{
mpz_t n, d, q, q2, r;
mpz_init(n); mpz_init(d);
mpz_init(q); mpz_init(q2); mpz_init(r);
gmp_sscanf("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "%Zx", n);
gmp_sscanf("20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", d);
mpz_tdiv_q(q, n, d);
mpz_tdiv_qr(q2, r, n, d);
if (mpz_cmp(q, q2) != 0)
{
fprintf (stderr, "ERROR\n");
fprintf (stderr, "dividend = "); debug_mp (n, -16);
fprintf (stderr, "divisor = "); debug_mp (d, -16);
fprintf (stderr, "q1 = "); debug_mp (q, -16);
fprintf (stderr, "q2 = "); debug_mp (q2, -16);
abort();
}
gmp_sscanf("3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", n);
gmp_sscanf("400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "%Zx", d);
mpz_tdiv_q(q, n, d);
mpz_tdiv_qr(q2, r, n, d);
if (mpz_cmp(q, q2) != 0)
{
fprintf (stderr, "ERROR\n");
fprintf (stderr, "dividend = "); debug_mp (n, -16);
fprintf (stderr, "divisor = "); debug_mp (d, -16);
fprintf (stderr, "q1 = "); debug_mp (q, -16);
fprintf (stderr, "q2 = "); debug_mp (q2, -16);
abort();
}
mpz_clear(n); mpz_clear(d);
mpz_clear(q); mpz_clear(q2); mpz_clear(r);
}
