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

import scala.collection.mutable

object Main extends App {

  import scala.io.StdIn._

  val mod = 1000000007L
  val factorial = Array.tabulate(100033){_.toLong}
  for (i ← 2 until factorial.length){
    factorial(i) = factorial(i) * factorial(i - 1) % mod
  }
  val inverse = factorial.map(it ⇒ exp(it, mod - 2))
  val Array(n, m) = readLine.trim.split(' ').map(_.toInt)
  println(
    primeFactors(m).map{case (_, e) ⇒ factorial(n + e - 1) * inverse(n - 1) % mod * inverse(e) % mod}.foldLeft(1L){case (l, r) ⇒ l * r % mod}
  )
  def primeFactors(num: Long): Iterable[(Long, Int)] = {
    val res = mutable.Queue[(Long, Int)] ()
    var count = 0
    var p = 3L
    var n = num
    while (n % 2 == 0){
      n /= 2
      count += 1
    }
    if (count != 0) res.enqueue(2L → count)
    while (p * p <= n){
      if (num % p == 0){
        count = 0
        while(n % p == 0) {
          n /= p
          count += 1
        }
        res.enqueue(p → count)
      }
      p += 2
    }
    if (n != 1) res.enqueue(n → 1)
    res
  }

  implicit class ScopedFunc[T](val value: T){
    def let[A](func: T ⇒ A): A = func(value)
  }
  def exp(base: Long, exponent: Long): Long = {
    exponent match{
      case 0 ⇒ 1
      case 1 ⇒ base % mod
      case _ ⇒ exp(base, exponent / 2).let(it ⇒ (it * it % mod) * exp(base, exponent % 2) % mod)
    }
  }
}
//https://beta.atcoder.jp/contests/abc110/tasks/abc110_d