/* compute n^m mod p, where m >= 0 and p > 0. */ static int power_mod(int n, int m, int p) { if (m == 0) return 1; else if (m % 2 == 0) { int x = power_mod(n, m / 2, p); return MULMOD(x, x, p); } else return MULMOD(n, power_mod(n, m - 1, p), p); }
static long long int solve4(int n, int m) { int low, high; low = MIN(n, m); high = MAX(n, m); int *primes; int prime_count = fill_primes(&primes, low); /* printf("count: %d primes: %p\n", prime_count, primes); */ /* for (int i = 0; i < prime_count; ++i) { */ /* printf("%d\n", primes[i]); */ /* } */ long long int result = 1; for (int i = 0; i < prime_count; ++i) { int prime = primes[i]; long long int acc = prime; long long int nn = low, nm = high; long long int base = 0; while (nn >= acc && nm >= acc) { base += (nn / acc) * (nm / acc); acc *= prime; } result *= power_mod(prime, base, MOD); result %= MOD; /* printf("i: %d %d base: %lld\n", i, prime, base); */ } free(primes); return result; }
/* * Load a DH private key */ DH_PrivateKey::DH_PrivateKey(const AlgorithmIdentifier& alg_id, const secure_vector<uint8_t>& key_bits) : DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_42) { if(m_y == 0) m_y = power_mod(group_g(), m_x, group_p()); }
static long long int power_mod(int i, long long int n, int m) { if (n == 0) return 1; long long int half = power_mod(i, n / 2, m); long long int result = (half * half) % m; int rem = n % 2; return rem ? (result * i) % m : result; }
NR_PrivateKey::NR_PrivateKey(const AlgorithmIdentifier& alg_id, const secure_vector<byte>& key_bits, RandomNumberGenerator& rng) : DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_57) { m_y = power_mod(group_g(), m_x, group_p()); load_check(rng); }
DSA_PrivateKey::DSA_PrivateKey(const AlgorithmIdentifier& alg_id, const MemoryRegion<byte>& key_bits, RandomNumberGenerator& rng) : DL_Scheme_PrivateKey(alg_id, key_bits, DL_Group::ANSI_X9_57) { y = power_mod(group_g(), x, group_p()); load_check(rng); }
int main(int argc, char **argv) { unsigned int x,y,a; scanf("%u %u %u",&x,&y,&a); power_mod(x,y,a); return 0; }
/************************************************* * Algorithm Specific PKCS #8 Initialization Code * *************************************************/ void DH_PrivateKey::PKCS8_load_hook(RandomNumberGenerator& rng, bool generated) { if(y == 0) y = power_mod(group_g(), x, group_p()); core = DH_Core(rng, group, x); if(generated) gen_check(rng); else load_check(rng); }
/************************************************* * DH_Core Constructor * *************************************************/ DH_Core::DH_Core(RandomNumberGenerator& rng, const DL_Group& group, const BigInt& x) { op = Engine_Core::dh_op(group, x); const BigInt& p = group.get_p(); BigInt k(rng, std::min(p.bits()-1, BLINDING_BITS)); if(k != 0) blinder = Blinder(k, power_mod(inverse_mod(k, p), x, p), p); }
/************************************************* * IF_Core Constructor * *************************************************/ IF_Core::IF_Core(RandomNumberGenerator& rng, const BigInt& e, const BigInt& n, const BigInt& d, const BigInt& p, const BigInt& q, const BigInt& d1, const BigInt& d2, const BigInt& c) { op = Engine_Core::if_op(e, n, d, p, q, d1, d2, c); if(BLINDING_BITS) { BigInt k(rng, std::min(n.bits()-1, BLINDING_BITS)); blinder = Blinder(power_mod(k, e, n), inverse_mod(k, n), n); } }
/************************************************* * ELG_Core Constructor * *************************************************/ ELG_Core::ELG_Core(RandomNumberGenerator& rng, const DL_Group& group, const BigInt& y, const BigInt& x) { op = Engine_Core::elg_op(group, y, x); const BigInt& p = group.get_p(); p_bytes = p.bytes(); if(BLINDING_BITS) { BigInt k(rng, std::min(p.bits()-1, BLINDING_BITS)); blinder = Blinder(k, power_mod(k, x, p), p); } }
/* * Create generator of the q-sized subgroup (DSA style generator) */ BigInt DL_Group::make_dsa_generator(const BigInt& p, const BigInt& q) { const BigInt e = (p - 1) / q; if(e == 0 || (p - 1) % q > 0) throw Invalid_Argument("make_dsa_generator q does not divide p-1"); for(size_t i = 0; i != PRIME_TABLE_SIZE; ++i) { BigInt g = power_mod(PRIMES[i], e, p); if(g > 1) return g; } throw Internal_Error("DL_Group: Couldn't create a suitable generator"); }
/* * Create a NR private key */ NR_PrivateKey::NR_PrivateKey(RandomNumberGenerator& rng, const DL_Group& grp, const BigInt& x_arg) { m_group = grp; m_x = x_arg; if(m_x == 0) m_x = BigInt::random_integer(rng, 2, group_q() - 1); m_y = power_mod(group_g(), m_x, group_p()); if(x_arg == 0) gen_check(rng); else load_check(rng); }
static long long int solve5(int n, int m) { int low, high; low = MIN(n, m); high = MAX(n, m); int *sieve = calloc((low + 1), sizeof(int)); for (int j = 2; j <= low / 2; ++j) { sieve[2 * j] = 1; } for (int i = 3; i <= (int)floor(sqrt(low)); i += 2) { if (sieve[i] == 0) { for (int j = 2; j <= low / i; ++j) { sieve[i * j] = 1; } } } /* for (int i = 1; i <= low; ++i) { */ /* if (sieve[i] == 0) { */ /* printf("I: %d\n", i); */ /* } */ /* } */ /* return 0; */ long long int result = 1; for (int i = 2; i <= low; ++i) { if (sieve[i] != 0) { continue; } int prime = i; long long int acc = prime; long long int nn = low, nm = high; long long int base = 0; while (nn >= acc && nm >= acc) { base += (nn / acc) * (nm / acc); acc *= prime; } result *= power_mod(prime, base, MOD); result %= MOD; /* printf("i: %d %d base: %lld\n", i, prime, base); */ } return result; }
static long long int solve3(int n, int m) { int low, high; low = MIN(n, m); high = MAX(n, m); primes[0] = 2; primes[1] = 3; primes[2] = 5; prime_count = 3; /* build primes */ for (int i = 1; i <= (low + 5) / 6; ++i) { if (is_prime(6 * i + 1)) { /* printf("%d %d %d\n", prime_count, i, 0); */ primes[prime_count ++] = 6 * i + 1; } if (is_prime(6 * i + 5)) { /* printf("%d %d %d\n", prime_count, i, 0); */ primes[prime_count ++] = 6 * i + 5; } } /* for (int i = 7; i <= low; i += 2) { */ /* if (is_prime(i)) { */ /* primes[prime_count ++] = i; */ /* } */ /* } */ /* printf("N: %d M: %d prime_count: %d\n", n, m, prime_count); */ long long int result = 1; for (int i = 0; i < prime_count; ++i) { int prime = primes[i]; long long int acc = prime; long long int nn = low, nm = high; long long int base = 0; while (nn >= acc && nm >= acc) { base += (nn / acc) * (nm / acc); acc *= prime; } result *= power_mod(prime, base, MOD); result %= MOD; /* printf("i: %d %d base: %lld\n", i, prime, base); */ } return result; }
/* * Create a DH private key */ DH_PrivateKey::DH_PrivateKey(RandomNumberGenerator& rng, const DL_Group& grp, const BigInt& x_arg) { group = grp; x = x_arg; if(x == 0) { const BigInt& p = group_p(); x.randomize(rng, 2 * dl_work_factor(p.bits())); } if(y == 0) y = power_mod(group_g(), x, group_p()); if(x == 0) gen_check(rng); else load_check(rng); }
/* * Create a DH private key */ DH_PrivateKey::DH_PrivateKey(RandomNumberGenerator& rng, const DL_Group& grp, const BigInt& x_arg) { m_group = grp; if(x_arg == 0) { const BigInt& p = group_p(); m_x.randomize(rng, dl_exponent_size(p.bits())); } else { m_x = x_arg; } if(m_y == 0) { m_y = power_mod(group_g(), m_x, group_p()); } }
static long long int solve(int n, int m) { struct prime_info *primes = malloc(PRIME_COUNT * sizeof(struct prime_info)); int prime_count = 0; long long int result = 1; for (int i = 2; i <= n; ++i) { long long int r; int left; prime(i, m, primes, &prime_count, &r, &left, MOD); /* result *= r; */ /* result %= MOD; */ } for (int i = 0; i < prime_count; ++i) { assert(primes[i].value > 0); /* printf("%d %d\n", primes[i].value, primes[i].count); */ assert(primes[i].count >= 0); result *= power_mod(primes[i].value, primes[i].count, MOD); result %= MOD; } free(primes); return result; }
static fftw_rader_data *create_rader_aux(int p, int flags) { fftw_complex *omega, *work; int g, ginv, gpower; int i; FFTW_TRIG_REAL twoPiOverN; fftw_real scale = 1.0 / (p - 1); /* for convolution */ fftw_plan plan; fftw_rader_data *d; if (p < 2) fftw_die("non-prime order in Rader\n"); flags &= ~FFTW_IN_PLACE; d = (fftw_rader_data *) fftw_malloc(sizeof(fftw_rader_data)); g = find_generator(p); ginv = power_mod(g, p - 2, p); omega = (fftw_complex *) fftw_malloc((p - 1) * sizeof(fftw_complex)); plan = fftw_create_plan(p - 1, FFTW_FORWARD, flags & ~FFTW_NO_VECTOR_RECURSE); work = (fftw_complex *) fftw_malloc((p - 1) * sizeof(fftw_complex)); twoPiOverN = FFTW_K2PI / (FFTW_TRIG_REAL) p; gpower = 1; for (i = 0; i < p - 1; ++i) { c_re(work[i]) = scale * FFTW_TRIG_COS(twoPiOverN * gpower); c_im(work[i]) = FFTW_FORWARD * scale * FFTW_TRIG_SIN(twoPiOverN * gpower); gpower = MULMOD(gpower, ginv, p); } /* fft permuted roots of unity */ fftw_executor_simple(p - 1, work, omega, plan->root, 1, 1, plan->recurse_kind); fftw_free(work); d->plan = plan; d->omega = omega; d->g = g; d->ginv = ginv; d->p = p; d->flags = flags; d->refcount = 1; d->next = NULL; d->cdesc = (fftw_codelet_desc *) fftw_malloc(sizeof(fftw_codelet_desc)); d->cdesc->name = NULL; d->cdesc->codelet = NULL; d->cdesc->size = p; d->cdesc->dir = FFTW_FORWARD; d->cdesc->type = FFTW_RADER; d->cdesc->signature = g; d->cdesc->ntwiddle = 0; d->cdesc->twiddle_order = NULL; return d; }