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: Wrong Answer)

fun main(args: Array<String>) {
    val mod = 1000000007
    var (N, M) = readLongList()

    var q = 2
    var count = 0
    val list = mutableListOf(1)
    val comb = Comb(1000000, mod)

    while (M != 1) {
        if (M % q == 0) {
            M /= q
            count++
            continue
        }

        q++
        if (count != 0)
            list.add(count)
        count = 0
    }
    //|||||->||o|o 5C2 (n 4)
    var ans = 1L
    for (i in list) {
        ans = (ans * comb[N+i-1, i]) %mod
    }

    println(ans)
}

fun readString() = readLine()!!
fun readInt() = readLine()!!.toInt()
fun readLong() = readLine()!!.toLong()
fun readIntList() = readLine()!!.split(" ").map(String::toInt)
fun readLongList() = readLine()!!.split(" ").map(String::toInt)

class Comb(val max:Int, val mod:Int) {
    val fac  = LongArray(max).apply { this[0] = 1L; this[1] = 1L }
    val finv = LongArray(max).apply { this[0] = 1L; this[1] = 1L }
    val inv  = LongArray(max).apply { this[1] = 1L }

    init {
        for (i in 2 until max) {
            fac[i] = fac[i - 1] * i % mod
            inv[i] = mod - inv[mod % i] * (mod / i) % mod
            finv[i] = finv[i - 1] * inv[i] % mod
        }
    }

    operator fun get(n:Int, k:Int):Long{
        if (n < k) return 0
        if (n < 0 || k < 0) return 0
        return fac[n] * (finv[k] * finv[n - k] % mod) % mod
    }
}