Problem:
Score : 300 points

Problem Statement

There are N integers a_1, a_2, ..., a_N not less than 1.
The values of a_1, a_2, ..., a_N are not known, but it is known that a_1 \times a_2 \times ... \times a_N = P.

Find the maximum possible greatest common divisor of a_1, a_2, ..., a_N.

Constraints

1 \leq N \leq 10^{12}

1 \leq P \leq 10^{12}

Input

Input is given from Standard Input in the following format:

N P

Output

Print the answer.

Sample Input 1

3 24

Sample Output 1

2

The greatest common divisor would be 2 when, for example, a_1=2, a_2=6 and a_3=2.

Sample Input 2

5 1

Sample Output 2

1

As a_i are positive integers, the only possible case is a_1 = a_2 = a_3 = a_4 = a_5 = 1.

Sample Input 3

1 111

Sample Output 3

111

Sample Input 4

4 972439611840

Sample Output 4

206

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>

#if MYDEBUG
#include "lib/cp_debug.hpp"
#else
#define DBG(...) ;
#endif
#if __cplusplus <= 201402L
template <typename T>
T gcd(T a, T b) { return ((a % b == 0) ? b : gcd(b, a % b)); }
template <typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
#endif
using LL = long long;
constexpr LL LINF = 334ll << 53;
constexpr int INF = 15 << 26;
constexpr LL MOD = 1E9 + 7;

namespace Problem {
using namespace std;

class Solver2 {
 public:
  LL n, p;
  vector<int> isPrime, minFactor;
  vector<LL> primes;
  Solver2(LL n, LL p) : n(n), p(p), isPrime(2e6 + 10, 1), minFactor(2e6 + 10){};
  void sieveMinFactor(vector<int> &isP, vector<int> &minFac, vector<long long> &prime) {
    fill(isP.begin(), isP.end(), 1);
    long long ub = (int)isP.size();
    isP[0] = isP[1] = 0;
    minFac[0] = 0;
    minFac[1] = 1;
    for (int i = 2; i < ub; ++i) {
      if (isP[i]) {
        minFac[i] = i;
        prime.push_back(i);
        for (long long j = (long long)i * i; j < ub; j += i) {
          isP[j] = 0;
          if (minFac[j] == 0) minFac[j] = i;
        }
      }
    }
  }
  void solve() {
    sieveMinFactor(isPrime, minFactor, primes);
    map<LL, LL> m;
    for (auto x : primes) {
      while (p % x == 0) {
        m[x]++;
        p /= x;
      }
    }
    if (p > 1) m[p] = 1;
    LL ans = 1;
    DBG(m)
    for (auto x : m) {
      for (LL i = 0; i < x.second / n; ++i) {
        ans *= x.first;
      }
    }
    cout << ans << endl;
  }
};
}  // namespace Problem

int main() {
  std::cin.tie(0);
  std::ios_base::sync_with_stdio(false);
  // std::cout << std::fixed << std::setprecision(12);
  long long n = 0, p;
  std::cin >> n >> p;

  Problem::Solver2 sol(n, p);
  sol.solve();
  return 0;
}