#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
#include <assert.h>
using namespace std;
 
 
const string file = "sumdiv";
 
const string infile = file + ".in";
const string outfile = file + ".out";
 
 
const int INF = 0x3f3f3f3f;
 
const int MODN = 9901;

vector<int> primes;
vector<int> descomp;
vector<int> powers;



int powMod(int base, int power)
{
	int result = 1;
	int c = base;

	for(int i = 0; i < 32; i++)
	{
		if( (1 << i) & power)
		{
			result *= c;
			result %= MODN;
		}

		c *= c;
		c %= MODN;
	}

	return result;
}


void ciur(int N)
{
	vector<bool> V(N + 1);
	primes.push_back(2);
	for(int i = 4; i <= N; i += 2)
	{
		V[i] = true;
	}

	int maxN = (int)sqrt(1.0 * N) + 1;
	for(int i = 3; i <= N; i += 2)
	{
		if(V[i] == false)
		{
			primes.push_back(i);
			if(i<= maxN)
			{
				for(int j = i * i; j <= N; j += 2 * i)
				{
					V[j] = true;
				}
			}
		}
	}

}

 
void factorOut(int A)
{
	for(unsigned int i = 0; i < primes.size(); i++)
	{
		int count = 0;

		if(primes[i] > A)
			break;
		if(A % primes[i] != 0)
			continue;


		while(A % primes[i] == 0)
		{
			A/= primes[i];
			count++;
		}

		descomp.push_back(primes[i]);
		powers.push_back(count);
	}
	if(A != 1)
	{
		descomp.push_back(A);
		powers.push_back(1);
	}
}

int main()
{
#ifdef ONLINE_JUDGE
    ostream &fout = cout;
    istream &fin = cin;
#else
    fstream fout(outfile.c_str(), ios::out);
    fstream fin(infile.c_str(), ios::in);
#endif  
 

	int A, B;
	fin >> A >> B;

	primes.reserve(1050);
	ciur(8000);

	factorOut(A);

	for(vector<int>::iterator itr = powers.begin();
		itr != powers.end();
		itr++)
	{
		(*itr) = *itr * B;
	}

	int Sol = 1;


	for(unsigned int i = 0; i < descomp.size(); i++)
	{
		int up = powMod(descomp[i], powers[i] + 1) - 1;

		int down = descomp[i] - 1;
		down = powMod(down, MODN - 2);

		Sol *= up;
		Sol %= MODN;
		Sol *= down;
		Sol %= MODN;
	}

	

	fout << Sol << "\n";


#ifdef ONLINE_JUDGE
#else
 
    fin.close();
    fout.close();
#endif
}