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 Scala (2.11.7) (judge verdict: Accepted)

import scala.annotation.tailrec
object Main extends App {

  import scala.io.StdIn._
  import scala.math._

  val Array(n, p) = readLine.trim.split(' ').map(_.toLong)
    // p == x^n = log(p) = n log(x) log(p) / n == log(x)
  if (n == 1){
    println(p)
  }else {
    val maxPrime = math.exp(math.log(p) / n)
    var res = 1L
    var current = p
    val primes = prime(maxPrime.toInt)
    for (primeFactor ← primes) {
      while (current % exponent(primeFactor, n) == 0) {
        res *= primeFactor
        current /= exponent(primeFactor, n)
      }
    }
    println(res)
  }
  def exponent(base: Long, exp: Long): Long = {
    exp match {
      case 0L ⇒ 1L
      case 1L ⇒ base
      case _ ⇒ exponent(base, exp / 2).let{it ⇒ it * it * exponent(base, exp % 2)}
    }
  }
  def prime(upper: Int): List[Int] = {
    val isPrime = Array.tabulate(upper + 1){_ ⇒ true}
    var res: List[Int] = Nil
    for (i ← 2 to math.sqrt(upper).ceil.toInt){
      if (isPrime(i)){
        for (j ← i * 2 to upper by i) {
          isPrime(j) = false
        }
      }
    }
    for (i ← 2 until isPrime.length){
      if (isPrime(i))
        res ::= i
    }
    res
  }
  implicit class Extension[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}