int main()
{
int T;
scanf("%d", &T);
int ncase = 0;
while (T--) {
scanf("%d", &C);
i64 ans = 1;
i64 fac = 1;
while (C--) {
scanf("%d%d", &P, &a);
ans = (ans * mod_pow(P, a, MOD)) % MOD;
i64 x = mod_pow(P, a, MOD) - 1 + MOD;
x = x * (mod_inv(P - 1, MOD) + MOD) % MOD;
i64 y = a + 1;
y = y * mod_pow(P, a, MOD) % MOD;
x = (x + y) % MOD;
fac = fac * x % MOD;
}
ans = (ans + fac) % MOD;
printf("Case %d: %lld\n", ++ncase, ans);
}
return 0;
}
/**
* Just compute Yc = g^a % p and return it in "key_exchange_message". The
* premaster secret is Ys ^ a % p.
*/
int dh_key_exchange( dh_key *server_dh_key,
unsigned char *premaster_secret,
unsigned char **key_exchange_message )
{
huge Yc;
huge Z;
huge a;
int message_size;
short transmit_len;
// TODO obviously, make this random, and much longer
set_huge( &a, 6 );
mod_pow( &server_dh_key->g, &a, &server_dh_key->p, &Yc );
mod_pow( &server_dh_key->Y, &a, &server_dh_key->p, &Z );
// Now copy Z into premaster secret and Yc into key_exchange_message
memcpy( premaster_secret, Z.rep, Z.size );
message_size = Yc.size + 2;
transmit_len = htons( Yc.size );
*key_exchange_message = malloc( message_size );
memcpy( *key_exchange_message, &transmit_len, 2 );
memcpy( *key_exchange_message + 2, Yc.rep, Yc.size );
free_huge( &Yc );
free_huge( &Z );
free_huge( &a );
return message_size;
}
/**
* 米勒-拉宾(Miller-Rabin)素数测试
*/
bool miller_rabin(const BigInteger& n, unsigned s)
{
assert(s > 0);
#if 0 // unoptimized
/**
* 米勒-拉宾(Miller-Rabin)素数测试
*
* 参考文献：
* [1]潘金贵，顾铁成. 现代计算机常用数据结构和算法[M]. 南京大学出版社. 1994. 584
*/
const BigInteger ONE(1);
for (size_t i = 0; i < s; ++i)
{
const BigInteger a = BigInteger::rand_between(ONE, n); // rand in [1, n)
if (_miller_rabin_witness(a, n))
return false; // 一定是合数
}
return true; // 几乎肯定是素数
#else
/**
* Miller-Rabin 素数测试
* 参见java语言BigInteger.passesMillerRabin()实现
*/
const BigInteger ONE(1), TWO(2);
// Find a and m such that m is odd and n == 1 + 2**a * m
BigInteger this_minus_one(n);
--this_minus_one;
BigInteger m(this_minus_one);
const int a = m.lowest_bit();
m >>= a;
// Do the tests
for (size_t i = 0; i < s; ++i)
{
// Generate a uniform random in [1, n)
const BigInteger b = BigInteger::rand_between(ONE, n); // _rand_1_n(n);
int j = 0;
BigInteger z(0);
mod_pow(b, m, n, &z);
while (!((j == 0 && z == ONE) || z == this_minus_one))
{
if ((j > 0 && z == ONE) || ++j == a)
return false;
mod_pow(z, TWO, n, &z);
}
}
return true;
#endif
}
int main() {
int T; scanf("%d", &T);
while(T--){
int K, N; scanf("%d %d", &K, &N);
if(N == 1) printf("1\n");
else if(N == 2 || N == 3) printf("%d\n", K);
else {
long long b_c = mod_pow(2, N - 3, MOD - 1);
long long a_b_c = mod_pow(K, b_c, MOD);
printf("%lld\n", a_b_c);
}
}
}
int baby_step_giant_step(int a, int b, int p)
{
a %= p, b %= p;
if(b == 1) return 0;
int cnt = 0;
long long t = 1;
for(int g = gcd(a, p); g != 1; g = gcd(a, p))
{
if(b % g) return -1;
p /= g, b /= g, t = t * a / g % p;
++cnt;
if(b == t) return cnt;
}
std::map<int, int> hash;
int m = int(sqrt(1.0 * p) + 1);
long long base = b;
for(int i = 0; i != m; ++i)
{
hash[base] = i;
base = base * a % p;
}
base = mod_pow(a, m, p);
long long now = t;
for(int i = 1; i <= m + 1; ++i)
{
now = now * base % p;
if(hash.count(now))
return i * m - hash[now] + cnt;
}
return -1;
}
int main()
{
LL x;
scanf("%*lld%*lld%lld", &x);
printf("%d\n", mod_pow(2, x % (mod - 1)));
return 0;
}
int main()
{
scanf("%d", &t);
while(t--)
{
scanf("%d%d%d%d", &n, &m, &p, &x);
memset(vis + 1, 0, m * sizeof(bool));
memset(c + 1, 0, m * sizeof(int));
for(register int xx; n--; )
{
scanf("%d", &xx);
vis[xx] = 1;
}
for(register int i = 1; i <= m; ++i)
f[i] = ((LL)f[i - 1] * x + 1) % p;
register int ans = 1;
for(register int i = m; i > 0; --i)
{
for(register int j = i + i; j <= m && !vis[i]; j += i)
vis[i] |= vis[j];
if(!vis[i])
continue;
c[i] = 1;
for(int j = i + i; j <= m; j += i)
c[i] -= c[j];
ans = (LL)ans * mod_pow(f[i], c[i]) % p;
}
printf("%d\n", ans);
}
return 0;
}
int main()
{
f[1] = f[2] = 1;
for(int i = 3; i < maxn; ++i)
if((f[i] = f[i - 1] + f[i - 2]) >= mod)
f[i] -= mod;
f[0] = g[0] = g[1] = g[2] = 1;
for(int i = 3; i < maxn; ++i)
{
int val = mod_inv(f[i]);
for(int j = i + i; j < maxn; j += i)
f[j] = (LL)f[j] * val % mod;
f[i] = (LL)f[i - 1] * f[i] % mod;
g[i] = (LL)g[i - 1] * val % mod;
}
scanf("%d", &t);
while(t--)
{
int ans = 1;
scanf("%d%d", &n, &m);
for(int i = 3, j, u, v; i <= n && i <= m; i = j + 1)
{
u = n / i;
v = m / i;
j = std::min(n / u, m / v);
ans = (LL)ans * mod_pow((LL)f[j] * g[i - 1] % mod, (LL)u * v % (mod - 1)) % mod;
}
printf("%d\n", ans);
}
return 0;
}
int main()
{
long long int t,z,i,c,r;
char s[101];
long long int n;
scanf("%lld",&t);
while(t--)
{
char s[101];
z=0;
scanf("%lld",&n);
n=n-1;
while(1)
{
z++;
if((n-mod_pow(5,z))>=0)
n=n-mod_pow(5,z);
else
break;
}
c=0;
//printf("z=%d n=%lld\n",z,n);
while(n>0)
{
r=n%5;
if(r==0)
s[c]='m';
else if(r==1)
s[c]='a';
else if(r==2)
s[c]='n';
else if(r==3)
s[c]='k';
else if(r==4)
s[c]='u';
c++;
n=n/5;
}
for(i=1;i<=z-c;i++)
printf("m");
for(i=c-1;i>=0;i--)
printf("%c",s[i]);
printf("\n");
}
return(0);
}
int dfs(int dep, Exp sig) {
if(dep <= 0)
return mod_pow(2, sig);
int ret = 0;
for(int i = 0, sgn = 1; i <= cnt[dep]; ++i, sgn = -sgn)
ret = (ret + (LL)sgn * c[cnt[dep]][i] * dfs(dep - 1, sig * fct[dep][i])) % mod;
return ret < 0 ? ret + mod : ret;
}
int main()
{
unsigned long long int i;
char * mask = (char*)malloc(CAP/2);
if (!mask)
{
printf("Memory Error\n");
}
memset(mask,1,CAP/2);
unsigned long long int mod = 1000000009;
unsigned long long int accum = 1;
unsigned long long int pow = 0;
unsigned long long int b2 = 2;
for (i=b2;i<=CAP;i*=b2) pow += CAP/i;
accum = (accum * (1 + mod_pow(b2,2*pow,mod))) % mod;
for (i=0;i<CAP/2;i++)
{
unsigned long long int inc = 2*(i + 1) + 1;
if (inc > CAP) break;
if (mask[i])
{
unsigned long long int j,p;
pow = 0;
for (p=inc;p<=CAP;p*=inc) pow += CAP/p;
//printf("%llu %d %llu\n",pow,inc,mod_pow(inc,2*pow,mod));
accum = (accum * (1 + mod_pow(inc,2*pow,mod))) % mod;
//printf("%d\n",inc);
for (j = i+inc;j<CAP/2;)
{
mask[j] = 0;
j += inc;
}
}
}
printf("The sum of squares of unitary divisors of %d! = %llu\n",CAP,accum);
return 0;
}
Node gen(int L, int R, int L1, int R1, int pw) // [L, R), L != R, |L| = |R-1| = len, 10^len = pw
{
if(pw == 1)
return (Node){(int)((((L + R - 1LL) * (R - L)) >> 1) % mod), 1};
int ivs = mod_inv(pw - 1), ppw = mod_pow(pw, L1 < R1 ? R1 - L1 : R1 - L1 + mod - 1);
int ret = ((LL)L * ppw - R + (ppw - 1LL) * ivs) % mod * ivs % mod;
if(ret < 0)
ret += mod;
return (Node){ret, ppw};
}
int main()
{
long long int t,n,x;
scanf("%lld",&t);
while(t--)
{
scanf("%lld",&n);
x=mod_pow(3,n)-1;
printf("%lld\n",x);
}
return 0;
}
void happy(char *a, char *b) {
int a_len = strlen(a);
int b_len = strlen(b);
long long a_mod = a[0] - '0';
for (int i = 1; i < a_len; i++) {
a_mod = (a_mod * 10 + (a[i] - '0')) % MOD;
}
long long b_mod = b[0] - '0';
for (int i = 1; i < b_len; i++) {
b_mod = (b_mod * 10 + (b[i] - '0')) % (MOD - 1);
}
printf("%lld\n", mod_pow(a_mod, b_mod));
}
int dfs(int n)
{
if(Hash.count(n))
return Hash[n];
int ret = mod_pow(ch, n) - ch;
if(ret < 0)
ret += mod;
for(int i = 2; i * i <= n; ++i)
if(n % i == 0)
{
if((ret -= dfs(i)) < 0)
ret += mod;
if(i * i < n && (ret -= dfs(n / i)) < 0)
ret += mod;
}
return Hash[n] = ret;
}
void dfs(int dep, int cnt, int sum, int val)
{
if(dep == m)
{
ans = (ans + (LL)val * iact[n - 2 - sum] % mod * mod_pow(n - cnt, n - 2 - sum)) % mod;
return;
}
dfs(dep + 1, cnt, sum, val);
if(!pos[a[dep]])
{
pos[a[dep]] = b[dep];
val = (LL)val * iact[b[dep] - 1] % mod;
if(val)
val = mod - val;
dfs(dep + 1, cnt + 1, sum + b[dep] - 1, val);
pos[a[dep]] = 0;
}
}
/*
Implemented using rolling hash function.
*/
int rabin_karp(const char *needle, const char *haystack)
{
// Rolling hash function for needle is calculated.
int len = strlen(needle);
int maxpow = mod_pow(PRIME_BASE, len - 1, MOD);
int hash_needle = hash(needle, len);
int roll_hash = hash(haystack, len);
const char *win_start = haystack;
const char *win_end = haystack + len;
for(; hash_needle != roll_hash; ++win_end, ++win_start) {
if(*win_end == '\0')
return -1;
roll_hash = rehash(roll_hash, *win_start, *win_end, maxpow);
}
if(strstarts(needle, win_start) == 0)
return win_start - haystack;
else
return -1;
}
int main (int argc, char *argv[])
{
int t, p;
unsigned long long n, k, i, res;
scanf ("%d", &t);
while (t--) {
scanf ("%llu %llu %d", &n, &k, &p);
res = 0;
for (i = 0; i <= n; i++) {
res += mod_pow (k, i, p) % 1000003;
res %= 1000003;
}
printf ("%d\n", res);
}
return 0;
}
int main()
{
fib[1] = 1;
for(int i = 2; i < maxn; ++i)
fib[i] = fib[i - 1] + fib[i - 2];
for(int i = 2; i < maxn; ++i)
fib[i] |= fib[i - 1];
scanf("%d", &t);
while(t--)
{
scanf("%lld", &n);
if(n < maxn)
printf("%d\n", (int)(fib[n] % mod));
else
{
len = (int)(n * (log2(1 + sqrt(5)) - 1) - log2(sqrt(5)) + 1);
printf("%d\n", mod_pow(2, len) - 1);
}
}
return 0;
}
int find_noOfWays(const char *str)
{
int i, j, len, c;
len = strlen(str);
c = 0;
for (i = 0, j = len-1; i <= j; i++, j--)
{
if (str[i] == str[j])
{
if (str[i] == '?')
{
c++;
}
}
else if (str[i] != '?' && str[j] != '?')
{
return 0;
}
}
return mod_pow(26, c);
}
int main()
{
scanf("%d%d", &t, &m);
if(m >= maxm)
{
f[1] = 1;
for(int i = 2; i < maxp; ++i)
{
if(!f[i])
{
prime[tot++] = i;
f[i] = mod_pow(i, m);
}
for(int j = 0, k = (maxp - 1) / i; j < tot && prime[j] <= k; ++j)
{
f[i * prime[j]] = (LL)f[i] * f[prime[j]] % mod;
if(i % prime[j] == 0)
break;
}
}
for(int i = 2; i < maxp; ++i)
{
f[i] += f[i - 1];
if(f[i] >= mod)
f[i] -= mod;
}
ans = 1;
while(t--)
{
scanf("%lld", &n);
++n;
ans = (LL)ans * f[(int)n] % mod;
}
printf("%d\n", ans);
return 0;
}
++m;
iact[1] = 1;
for(int i = 2; i <= m; ++i)
iact[i] = mod - mod / i * (LL)iact[mod % i] % mod;
iact[0] = 1;
for(int i = 1; i <= m; ++i)
iact[i] = (LL)iact[i - 1] * iact[i] % mod;
f[1] = 1;
for(int i = 2; i <= m; ++i)
{
if(!f[i])
{
prime[tot++] = i;
f[i] = mod_pow(i, m - 1);
}
for(int j = 0, k = m / i; j < tot && prime[j] <= k; ++j)
{
f[i * prime[j]] = (LL)f[i] * f[prime[j]] % mod;
if(i % prime[j] == 0)
break;
}
}
for(int i = 2; i <= m; ++i)
{
f[i] += f[i - 1];
if(f[i] >= mod)
f[i] -= mod;
}
ans = 1;
while(t--)
{
scanf("%lld", &n);
++n;
if(n <= m)
{
ans = (LL)ans * f[(int)n] % mod;
continue;
}
pre[0] = n % mod;
for(int i = 1; i <= m; ++i)
pre[i] = (n - i) % mod * pre[i - 1] % mod;
suf[m] = (n - m) % mod;
for(int i = m - 1; i >= 0; --i)
suf[i] = (n - i) % mod * suf[i + 1] % mod;
int res = 0;
for(int i = 0; i <= m; ++i)
{
int tmp = (LL)f[i] * iact[i] % mod * iact[m - i] % mod;
if(i)
tmp = (LL)tmp * pre[i - 1] % mod;
if(i < m)
tmp = (LL)tmp * suf[i + 1] % mod;
if(((m - i) & 1) && tmp)
tmp = mod - tmp;
res += tmp;
if(res >= mod)
res -= mod;
}
ans = (LL)ans * res % mod;
}
printf("%d\n", ans);
return 0;
}
template<class T> T mod_pow( T x, T n, T mod ) {
if ( n == 0 ) return 1;
T res = mod_pow( x * x % mod, n / 2, mod );
if ( n & 1 ) res = res * x % mod;
return res;
}
ll mod_pow(ll x,ll n,ll mod) {
if(n==0) return 1;
ll ret = mod_pow(x * x % mod,n/2,mod);
if(n%2== 1) ret = ret * x % mod;
return ret;
}
T mod_inverse(T a, T m) {
return mod_pow(a, m - 2, m);
}
int main()
{
iact[1] = 1;
for(int i = 2; i < maxm; ++i)
iact[i] = mod - mod / i * (LL)iact[mod % i] % mod;
iact[0] = 1;
for(int i = 1; i < maxm; ++i)
iact[i] = (LL)iact[i - 1] * iact[i] % mod;
for(int i = 0; i < maxm; ++i)
{
c[i][0] = c[i][i] = 1;
for(int j = 1; j < i; ++j)
if((c[i][j] = c[i - 1][j - 1] + c[i - 1][j]) >= mod)
c[i][j] -= mod;
}
LL tn, tq;
scanf("%d", &t);
while(t--)
{
scanf("%lld%d%lld", &tn, &m, &tq);
if((q = tq % mod) == 1)
{
tot = 0;
memset(f + 1, 0, (m + 1) * sizeof(int));
f[1] = 1;
for(int i = 2; i <= m + 1; ++i)
{
if(!f[i])
{
prime[tot++] = i;
f[i] = mod_pow(i, m);
}
for(int j = 0, o; j < tot && (o = i * prime[j]) <= m + 1; ++j)
{
f[o] = (LL)f[i] * f[prime[j]] % mod;
if(i % prime[j] == 0)
break;
}
}
for(int i = 2; i <= m + 1; ++i)
if((f[i] += f[i - 1]) >= mod)
f[i] -= mod;
if(tn <= m + 1)
{
printf("%d\n", f[(int)tn]);
continue;
}
pre[0] = tn % mod;
for(int i = 1; i <= m + 1; ++i)
pre[i] = (tn - i) % mod * pre[i - 1] % mod;
suf[m + 1] = (tn - m - 1) % mod;
for(int i = m; i >= 0; --i)
suf[i] = (tn - i) % mod * suf[i + 1] % mod;
ans = 0;
for(int i = 0; i <= m + 1; ++i)
{
int tmp = (LL)f[i] * iact[i] % mod * iact[m + 1 - i] % mod;
if(i > 0)
tmp = (LL)tmp * pre[i - 1] % mod;
if(i <= m)
tmp = (LL)tmp * suf[i + 1] % mod;
if(((m + 1 - i) & 1) && tmp > 0)
tmp = mod - tmp;
if((ans += tmp) >= mod)
ans -= mod;
}
printf("%d\n", ans);
}
else if(q > 0)
{
n = tn % mod;
int sei = mod_pow(q, (tn + 1) % (mod - 1)), iei = mod_inv(q - 1);
if((f[0] = (LL)(sei - q) * iei % mod) < 0)
f[0] += mod;
for(int i = 1, coeff = n; i <= m; ++i, coeff = (LL)coeff * n % mod)
{
f[i] = (LL)coeff * sei % mod;
for(int j = 0; j < i; ++j)
{
int tmp = (LL)c[i][j] * f[j] % mod;
if(((i - j) & 1) && tmp > 0)
tmp = mod - tmp;
if((f[i] += tmp) >= mod)
f[i] -= mod;
}
f[i] = (LL)f[i] * iei % mod;
}
printf("%d\n", f[m]);
}
else
puts("0");
}
return 0;
}
bool carmichael(int n){
for(int x=2; x<n; x++){
if (mod_pow((long long) x, (long long) n, (long long) n) != x) return false;
}
return true;
}
/*
計算量は O(log(n)) で次式の計算結果を返す
x**n (mod mod)
つまり，xを乗して，modで割った余りを返す．
ex) mod_pow(2, 3, 3) = 2
素数pに対して x**p = x (mod p) が成り立つ
*/
ll mod_pow(ll x, ll n, ll mod) {
if(n == 0) return 1;
ll res = mod_pow(x * x % mod, n / 2, mod);
ll (n & 1) res = res * x % mod;
return res;
}
