#include <iostream>
#include <fstream>
#include <bitset>

using namespace std;
ifstream in ("sumdiv.in");
ofstream out ("sumdiv.out");
int const radmax = 8000;
int const modulo = 9901;

bitset<radmax> ciur;
int primes[radmax], nprimes;
int a, b;


void computeciur() {
  primes[0] = 2;
  nprimes = 1;
  for(int i = 3; i <= radmax; i += 2) {
    if(ciur[i] == 0) {
      primes[nprimes] = i;
      nprimes++;
      if(1LL * i * i <= radmax) {
        int j = i * i;
        while (j<=radmax) {
          ciur[j] = 1;
          j += 2*i;
        }
      }
    }
  }
}

void gcd(int &x ,int &y ,int a ,int b){
  if(b == 0){
    x = 1;
    y = 0;
  } else{
    gcd(x ,y ,b , a % b);
    int aux = x;
    x = y;
    y = aux - a / b * y;
  }
}

int logpow(int x, int y) {
  if(y == 0)
    return 1;
  else {

    int result = logpow(x, y >> 1);
    if((y & 1) == 0)
      return (result * result) % modulo;
    else
      return ((result * result) % modulo * x) % modulo;
  }
}



void updatesumformula(int &sumadiv, int factor, int power) {
  int invers, y;

  if (factor % modulo == 1) {
    sumadiv = (sumadiv * ((power + 1) % modulo)) % modulo;
  } else {
    int powerterm = (logpow(factor % modulo, power + 1) + modulo - 1) % modulo;

//  int invers2 = effpow(factor - 1, modulo - 2) % modulo;
    gcd(invers, y, (modulo + factor - 1) % modulo, modulo);
    if (invers <= 0)
      invers = modulo + invers % modulo;

    sumadiv = (((sumadiv * powerterm) % modulo) * invers) % modulo;
  }
}

void descompunere(int n) {
  int sumadiv = 1;

  int i = 0;
  while(i < nprimes && primes[i] * primes[i] <= n) {
    if(n % primes[i] == 0){
      int npow = 0;
      while(n % primes[i] == 0){
        n /= primes[i];
        npow++;
      }
      npow *= b;
      updatesumformula(sumadiv, primes[i], npow);
    }
    i++;
  }
  if(1<n) {
    updatesumformula(sumadiv, n % modulo, b);
  }
  out<<sumadiv % modulo;
}

int main() {
  computeciur();
  in>>a>>b;
  if(a == 0)
    out<<0;
  else{
    descompunere(a);
  }
  return 0;
}