void
bignum_power_number(int expo)
{
unsigned int *a, *b, *t;
save();
p1 = pop();
a = mpow(p1->u.q.a, abs(expo));
b = mpow(p1->u.q.b, abs(expo));
if (expo < 0) {
t = a;
a = b;
b = t;
MSIGN(a) = MSIGN(b);
MSIGN(b) = 1;
}
p1 = alloc();
p1->k = NUM;
p1->u.q.a = a;
p1->u.q.b = b;
push(p1);
restore();
}
void testSingular(const MatrixType& m_const, double tol)
{
// we need to pass by reference in order to prevent errors with
// MSVC for aligned data types ...
MatrixType& m = const_cast<MatrixType&>(m_const);
const int IsComplex = NumTraits<typename internal::traits<MatrixType>::Scalar>::IsComplex;
typedef typename internal::conditional<IsComplex, TriangularView<MatrixType,Upper>, const MatrixType&>::type TriangularType;
typename internal::conditional< IsComplex, ComplexSchur<MatrixType>, RealSchur<MatrixType> >::type schur;
MatrixType T;
for (int i=0; i < g_repeat; ++i) {
m.setRandom();
m.col(0).fill(0);
schur.compute(m);
T = schur.matrixT();
const MatrixType& U = schur.matrixU();
processTriangularMatrix<MatrixType>::run(m, T, U);
MatrixPower<MatrixType> mpow(m);
T = T.sqrt();
VERIFY(mpow(0.5).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
T = T.sqrt();
VERIFY(mpow(0.25).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
T = T.sqrt();
VERIFY(mpow(0.125).isApprox(U * (TriangularType(T) * U.adjoint()), tol));
}
}
void testExponentLaws(const MatrixType& m, double tol)
{
typedef typename MatrixType::RealScalar RealScalar;
MatrixType m1, m2, m3, m4, m5;
RealScalar x, y;
for (int i=0; i < g_repeat; ++i) {
generateTestMatrix<MatrixType>::run(m1, m.rows());
MatrixPower<MatrixType> mpow(m1);
x = internal::random<RealScalar>();
y = internal::random<RealScalar>();
m2 = mpow(x);
m3 = mpow(y);
m4 = mpow(x+y);
m5.noalias() = m2 * m3;
VERIFY(m4.isApprox(m5, static_cast<RealScalar>(tol)));
m4 = mpow(x*y);
m5 = m2.pow(y);
VERIFY(m4.isApprox(m5, static_cast<RealScalar>(tol)));
m4 = (std::abs(x) * m1).pow(y);
m5 = std::pow(std::abs(x), y) * m3;
VERIFY(m4.isApprox(m5, static_cast<RealScalar>(tol)));
}
}
void
test_mroot(void)
{
int i, j, mem;
unsigned int *a, *b, *c;
logout("testing mroot\n");
mem = mtotal;
// small numbers
for (i = 0; i < 10; i++) {
a = mint(i);
for (j = 1; j < 10; j++) {
b = mpow(a, j);
c = mroot(b, j);
if (c == 0 || mcmp(a, c) != 0) {
sprintf(logbuf, "failed a=%d b=%d c=%d\n", a[0], b[0], c[0]);
logout(logbuf);
errout();
}
mfree(b);
mfree(c);
}
mfree(a);
}
a = mint(12345);
for (i = 1; i < 10; i++) {
b = mpow(a, i);
c = mroot(b, i);
if (c == 0 || mcmp(a, c) != 0) {
logout("failed\n");
errout();
}
mfree(b);
mfree(c);
}
mfree(a);
if (mtotal != mem) {
logout("memory leak\n");
errout();
}
logout("ok\n");
}
int main()
{
int i, j, n, c, fb[8], T;
Matrix m;
char s[16384];
for (scanf("%d", &T); T-- > 0 && scanf("%d %d %s", &n, &c, s) == 3;) {
for (i = 0; s[i]; i++)
s[i] = toupper(s[i]);
memset(fb, 0, sizeof(fb));
for (i = 'A'; i <= 'A'+c; i++) {
char *p = strchr(s, i);
if (p != NULL)
for (p++; *p; p++) fb[i-'A'] |= 1 << (*p-'A');
}
memset(&m, 0, sizeof(m));
m.d = 1 << c;
for (int s = 0; s < m.d; s++)
for (int a = 0; a < c; a++)
if (s & (1 << a)) m.a[s][s & ~fb[a]]++;
mpow(m, n);
for (i = j = 0; i < m.d; i++)
j = (j + m.a[m.d-1][i]) % 4242;
printf("%d\n", j);
}
return 0;
}
long long solve(long long n, long long b, long long d, long long m) {
// d * (b^n - 1) / (b - 1) mod m
long long ret;
ret = mpow(b, n, (b - 1) * m); // b^n mod (b-1) * m
ret = (ret + (b - 1) * m - 1)/ (b - 1);
ret = mul(ret, d, m);
return ret;
}
int dfs(int idx, long long k2) {
if (idx == 12) {
if (mpow(K1, k2, t10[idx]) == k2%t10[idx]) {
K2 = k2;
return 1;
}
return 0;
}
for (int i = (idx == 11); i <= 9; i++) {
long long x = t10[idx] * i + k2;
if (mpow(K1, x, t10[idx]) == x%t10[idx]) {
if (dfs(idx+1, x))
return 1;
}
}
return 0;
}
unsigned int *
mroot(unsigned int *n, unsigned int index)
{
int i, j, k;
unsigned int m, *x, *y;
if (index == 0)
stop("root index is zero");
// count number of bits
k = 32 * (MLENGTH(n) - 1);
m = n[MLENGTH(n) - 1];
while (m) {
m >>= 1;
k++;
}
if (k == 0)
return mint(0);
// initial guess
k = (k - 1) / index;
j = k / 32 + 1;
x = mnew(j);
MSIGN(x) = 1;
MLENGTH(x) = j;
for (i = 0; i < j; i++)
x[i] = 0;
while (k >= 0) {
mp_set_bit(x, k);
y = mpow(x, index);
switch (mcmp(y, n)) {
case -1:
break;
case 0:
mfree(y);
return x;
case 1:
mp_clr_bit(x, k);
break;
}
mfree(y);
k--;
}
mfree(x);
return 0;
}
void testTriangularProduct(const MatrixType& m, const VectorType& v, double tol)
{
typedef typename MatrixType::RealScalar RealScalar;
MatrixType m1;
VectorType v1, v2, v3;
RealScalar p;
for (int i=0; i < g_repeat; ++i) {
generateTriangularMatrix<MatrixType>::run(m1, m.rows());
MatrixPowerTriangular<MatrixType> mpow(m1);
v1 = VectorType::Random(v.rows(), v.cols());
p = internal::random<RealScalar>();
v2.noalias() = mpow(p) * v1;
v3.noalias() = mpow(p).eval() * v1;
std::cout << "testTriangularProduct: error powerm = " << relerr(v2, v3) << '\n';
VERIFY(v2.isApprox(v3, static_cast<RealScalar>(tol)));
}
}
void cidr(unsigned long first, unsigned long last) {
if (first < last) {
unsigned int idx1=31,idx2=0,prefix;
while (bit(first,idx1) == bit(last,idx1)) idx1--;
prefix=(first>>idx1+1)<<idx1+1;
while (idx2 <= idx1 && bit(first,idx2) == 0 && bit(last,idx2) == 1) idx2++;
if (idx2 <= idx1) {
cidr(first,prefix|(unsigned long)mpow(2,idx1)-1);
cidr(prefix|1<<idx1,last);
}
else printf("%s/%d\n",inet_ntoa(htonl(prefix)),32-idx2);
}
int main() {
scanf("%*d");
char buf[32];
int n;
while (scanf("%d", &n) == 1) {
sprintf(buf, "%d", n);
int m = strlen(buf), sum = 0;
for (int i = 0; i < m; i++)
sum += mpow(buf[i] - '0', m);
puts("Not Armstrong" + (sum == n ? 4 : 0));
}
return 0;
}
int main() {
// freopen("in.txt", "r+t", stdin);
// freopen("out.txt", "w+t", stdout);
int testcase, cases = 0;
long long D, V;
scanf("%d", &testcase);
while (scanf("%lld %lld", &D, &V) == 2) {
assert(D >= 0 && V > 0 && D <= 2e+9 && V <= 2e+9);
long long ret = 0;
if (D == 0) ret = 1;
else if (D == 1) ret = (V + 1)%mod;
else if (V == 1) ret = -1;
else if (V == 2) ret = (1 + D * 2)%mod;
else {
ret = mpow(V - 1, D, mod) - 1 + mod;
ret = ret * mpow(V - 2, mod - 2, mod) %mod;
ret = ret * V %mod;
ret = (ret + 1 + mod)%mod;
assert(ret >= 0);
}
printf("Case %d: %lld\n", ++cases, ret);
}
return 0;
}
int deal_input(char *str, char *strre)
{
int length;
char stmp[INPUTLENGTH];
int dotpos;
int i;
unsigned int left,right;
int number;
length = strlen(str);
for(i=0; i<length; i++) {
if(str[i] == '.') {
dotpos = i;
break;
}
}
memset(stmp, 0, sizeof(stmp));
memcpy(stmp, str, dotpos);
left = atoi(stmp);
for(i=length-1; i>dotpos; i--) {
if( str[i] == '0' ) {
length--;
continue;
} else
break;
}
if(length == dotpos+1) {
right=0;
number = left;
dotpos = 0;
} else {
memset(stmp, 0, sizeof(stmp));
memcpy(stmp, str+dotpos+1, length-dotpos-1);
right = atoi(stmp);
number = right+ (left*mpow(length-dotpos-1));
dotpos = length-dotpos-1;
}
sprintf(strre, "%d", number);
return dotpos;
}
int poly::eval(const vector<int>& x, int m)
{
int ret = 100*m;
for(deque<term>::iterator i=terms.begin(); i!=terms.end(); i++)
{
int tmp = 1;
monomial mon = i->second;
for(int j=0; j<n_vars; j++)
{
tmp *= mpow(x[j],mon[j],m);
tmp %= m;
}
tmp *= i->first;
tmp = (tmp+100*m) % m;
ret += tmp;
}
return (ret+100*m)%m;
}
int main(){
int a, b;
printf("Enter two integers: ");
scanf("%d %d",&a, &b);
#ifdef opquo
printf("Quotient: %d\n",quo(a,b));
#endif
#ifdef oprem
printf("Remainder: %d\n",rem(a,b));
#endif
#ifdef opsum
printf("Sum: %d\n",sum(a,b));
#endif
#ifdef opprod
printf("Product: %d\n",prod(a,b));
#endif
#ifdef opmpow
printf("Exponent: %ld\n",mpow(a,b));
#endif
return 0;
}
int main() {
int testcase;
int n, p[128];
scanf("%d", &testcase);
while (testcase--) {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &p[i]);
int ret = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
continue;
if (mpow(p[i], (p[j]-1)/2, p[j]) == 1)
ret++;
}
}
printf("%d\n", ret);
}
return 0;
}
void
test_mpow(void)
{
int i, j, mem, x;
unsigned int *a, *b, *c;
logout("testing mpow\n");
mem = mtotal;
// small numbers
for (i = -10; i < 10; i++) {
a = mint(i);
x = 1;
for (j = 0; j < 10; j++) {
b = mpow(a, j);
c = mint(x);
if (mcmp(b, c) != 0) {
sprintf(logbuf, "failed a=%d b=%d c=%d\n", a[0], b[0], c[0]);
logout(logbuf);
errout();
}
mfree(b);
mfree(c);
x *= i;
}
mfree(a);
}
if (mem != mtotal) {
logout("memory leak\n");
errout();
}
logout("ok\n");
}
double Length(int a, int b, struct Vertex **vert)
{
return sqrt(mpow(vert[a]->x - vert[b]->x) + mpow(vert[a]->y - vert[b]->y));
}
unsigned int mpow(unsigned int x, unsigned int n) {
return (!n)?1:(n&1)?x*mpow(x,n-1):mpow(x*x,n/2);
}
int main() {
printf("%lld\n", mpow(2, 10, 1000));
return 0;
}
