#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
using namespace std;
 
ifstream fin("gfact.in");
ofstream fout("gfact.out");
 
vector <int> fact;
int num[1000];
 
int legendre(int check, int prime)
{
    int number = 0;
    int copy = prime;
    while(prime <= check)
    {
        number = number + (check / prime);
        prime *= copy;
    }
 
    return number;
}
 
bool Check(int check)
{
    int size = fact.size();
    int number;
    for(int i = 0 ; i < size ; i++)
    {
        if(legendre(check,fact[i]) < num[i])
            return false;
    }

    return true;
}

int binarySearch(int prime, int need)
{
    int right = 2000000000, left = 1, result, solution = -1;
    long long half;
    while(left <= right)
    {
        half = (right + left) / 2;
        if(Check(half) == true)
        {
            solution = half;
            right = half - 1;
        }
        else
        {
            left = half + 1;
        }
        
        
    }
    return solution;
}
 
void primeDecomposition(int value, int exp)
{

    if(value % 2 == 0)
    {
        fact.push_back(2);
        int size = fact.size();
        while(value % 2 == 0)
        {
            num[size - 1]++;
            value /= 2;
        }
        num[size - 1] *= exp;
    }

    for(int i = 3 ; i * i <= value ; i += 2)
    {
        if(value % i == 0)
        {
            fact.push_back(i);
            int size = fact.size();
            while(value % i == 0)
            {
                num[size - 1]++;
                value /= i;
            }
            num[size - 1] *= exp;
        }
    }
    if(value > 1)
    {
        fact.push_back(value);
        num[fact.size() - 1] = exp;
    }
}
 
int solve()
{
    int maxValue = 0, taker;
    int size = fact.size();
    for(int i = 0 ; i < size; i++)
    {
        taker = binarySearch(fact[i],num[i]); 
        if(taker > maxValue)
            maxValue = taker;
    }
 
    return taker;
}
int main()
{
    int p,q;
    fin >> p >> q;
    if(p == 1)
    {
        fout << 1 << "\n";
        return 0;
    }
    primeDecomposition(p, q);
    fout << solve() << "\n";
    return 0;
}