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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"fmt"
	"math"
	"sort"
)

type Entry struct {
	prime int64
	count int64
}

type Entries []Entry

func (es Entries) Len() int {
	return len(es)
}

func (es Entries) Less(i, j int) bool {
	return es[i].count > es[j].count
}

func (es Entries) Swap(i, j int) {
	es[i], es[j] = es[j], es[i]
}

func main() {
	var n, p int64
	fmt.Scanf("%d %d\n", &n, &p)

	primeLimit := int64(math.Sqrt(float64(p)))
	allPrimes := listPrimes(primeLimit)
	entries := countPrimes(p, allPrimes)

	sort.Sort(Entries(entries))

	factor := int64(1)
	for _, e := range entries {
		if e.count >= n {
			v := e.prime * (e.count / n)
			factor *= v
		}
	}

	fmt.Println(factor)
}

func countPrimes(n int64, allPrimes []int64) []Entry {
	es := []Entry{}

	for _, p := range allPrimes {
		if p*p > n {
			break
		}
		cnt := int64(0)
		for n%p == 0 {
			cnt += 1
			n /= p
		}
		if cnt > 0 {
			es = append(es, Entry{p, cnt})
		}
	}
	if n > 1 {
		es = append(es, Entry{n, 1})
	}

	return es
}

func listPrimes(limit int64) []int64 {
	ns := make([]int64, limit-1)
	for i := int64(2); i <= limit; i++ {
		ns[i-2] = i
	}

	divided := make([]bool, limit+1)

	ps := make([]int64, 0)
	for _, n := range ns {
		if divided[n] {
			continue
		}
		ps = append(ps, n)
		for i := n; i < int64(len(divided)); i += n {
			divided[i] = true
		}
	}

	return ps
}