/// http://www.wolframalpha.com/input/?i=9901+is+prime%3F
#include <fstream>
#include <iostream>
#include <vector>
#include <bitset>
#include <string.h>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <set>
#include <map>
#include <string>
#include <queue>
#include <deque>

using namespace std;

const char infile[] = "sumdiv.in";
const char outfile[] = "sumdiv.out";

ifstream fin(infile);
ofstream fout(outfile);

const int MAXN = 100005;
const int oo = 0x3f3f3f3f;
const int MOD = 9901;

typedef vector<int> Graph[MAXN];
typedef vector<int> :: iterator It;

const inline int min(const int &a, const int &b) { if( a > b ) return b;   return a; }
const inline int max(const int &a, const int &b) { if( a < b ) return b;   return a; }
const inline void Get_min(int &a, const int b)    { if( a > b ) a = b; }
const inline void Get_max(int &a, const int b)    { if( a < b ) a = b; }

inline int Factorize(int A, int B, vector <pair<int, long long> > & V) {
    for(int i = 2 ; 1LL * i * i <= A ; ++ i) {
        if(A % i)
            continue;
        int fact = i;
        int iPower = 0;
        while(A % fact == 0) {
            A /= fact;
            ++ iPower;
        }
        V.push_back(make_pair(fact, 1LL * iPower * B));
    }
    return A;
}

inline int lgPow(int N, long long P) {
    int Ans = 1;
    for( ; P ; P >>= 1) {
        if(P & 1)
            Ans = (1LL * Ans * N) % MOD;
        N = (1LL * N * N) % MOD;
    }
    return Ans;
}

inline int modularInverse(int n) {
    n %= MOD;
    return lgPow(n, MOD - 2);
}

inline int BuildSum(vector <pair<int, long long> > P, int MOD, int A, int B) {
    int Sum = 1;
    for(vector <pair<int, long long> > :: iterator it = P.begin(), fin = P.end(); it != fin ; ++ it) {
        int pi = it->first;
        long long di = it->second;
        int denominator = modularInverse(pi - 1);
        int numerator = (lgPow(pi, di + 1) - 1 + MOD) % MOD;
        Sum = (1LL * Sum * ((denominator * numerator) % MOD)) % MOD;
    }
    if(A > 1) {
        if(A % MOD != 1) {
            int pi = A;
            long long di = B;
            int denominator = modularInverse(pi - 1);
            int numerator = (lgPow(pi, di + 1) - 1 + MOD) % MOD;
            Sum = (1LL * Sum * ((denominator * numerator) % MOD)) % MOD;
        }
        else Sum = (1LL * Sum * (B + 1)) % MOD;
    }
    return Sum;
}

int main() {
    int A, B;
    vector <pair<int, long long> > P;
    fin >> A >> B;
    A = Factorize(A, B, P);
    fout << BuildSum(P, MOD, A, B) << '\n';
    fin.close();
    fout.close();
    return 0;
}