Problem:
Score : 400 points

Problem Statement

You are given positive integers N and M.

How many sequences a of length N consisting of positive integers satisfy a_1 \times a_2 \times ... \times a_N = M? Find the count modulo 10^9+7.

Here, two sequences a' and a'' are considered different when there exists some i such that a_i' \neq a_i''.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq M \leq 10^9

Input

Input is given from Standard Input in the following format:

N M

Output

Print the number of the sequences consisting of positive integers that satisfy the condition, modulo 10^9 + 7.

Sample Input 1

2 6

Sample Output 1

4

Four sequences satisfy the condition: \{a_1, a_2\} = \{1, 6\}, \{2, 3\}, \{3, 2\} and \{6, 1\}.

Sample Input 2

3 12

Sample Output 2

18

Sample Input 3

100000 1000000000

Sample Output 3

957870001

Solution in Kotlin (1.0.0) (judge verdict: Accepted)

fun main(args: Array<String>) {
    val MOD = 1000000007L
    fun modpow(a: Long, p: Int): Long {
        if (p == 0) return 1
        return if (p % 2 == 0) {
            val halfP = p / 2
            val half = modpow(a, halfP)
            half * half % MOD
        } else {
            a * modpow(a, p - 1) % MOD
        }
    }

    fun calcComb(a: Int, b: Int): Long {
        if (b > a - b) return calcComb(a, a - b)
        var ansMul = 1L
        var ansDiv = 1L
        for (n in 0 until b) {
            ansMul *= (a - n).toLong()
            ansDiv *= (n + 1).toLong()
            ansMul %= MOD
            ansDiv %= MOD
        }
        return ansMul * modpow(ansDiv, MOD.toInt() - 2) % MOD
    }
    
    val (N, M) =listOfInt()
    var MNokori = M
    var ans = 1L
    var n = 2
    while (n * n <= MNokori) {
        if (MNokori % n == 0) {
            var cnt = 0
            while (MNokori % n == 0) {
                cnt++
                MNokori /= n
            }
            ans *= calcComb(N + cnt - 1, N - 1)
            ans %= MOD
        }
        n += 1
    }
    if (MNokori != 1) {
        ans *= calcComb(N + 1 - 1, N - 1)
        ans %= MOD
    }
    println(ans)
}
fun next() = readLine()!!
fun nextInt() = Integer.parseInt(next())
fun listOfString() = next().split(" ")
fun listOfInt() = listOfString().map { Integer.parseInt(it) }
fun listOfLong() = listOfString().map { java.lang.Long.parseLong(it) }