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 Rust (1.15.1) (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;

fn power(mut x: i64, mut a: i64, mod_: i64) -> i64 {
    let mut res: i64 = 1;
    while a > 0 {
        if a % 2 == 1 {
            res = res * x % mod_;
        }
        x = x * x % mod_;
        a /= 2;
    }
    res
}

fn ncr(n: usize, r: usize, fact: &Vec<i64>, invf: &Vec<i64>, mod_: i64) -> i64 {
    (fact[n] * invf[r] % mod_) * invf[n - r] % mod_
}

fn main() {
    let mod_ = 10_i64.pow(9) + 7;
    let n: usize = read();
    let m: i64 = read();
    let mut po = m;
    let mut num = 2;
    let mut ans = 1;
    let size = n + 50;
    let mut fact: Vec<i64> = vec![1; size];
    let mut invf: Vec<i64> = vec![1; size];
    for i in 2..size {
        fact[i] = i as i64 * fact[i - 1] % mod_;
        invf[i] = power(fact[i], mod_ - 2, mod_);
    }
    while po > 1 {
        if po % num == 0 {
            let mut cnt: usize = 0;
            while po % num == 0 {
                po /= num;
                cnt += 1;
            }
            ans *= ncr(cnt + n - 1, cnt, &fact, &invf, mod_);
            ans %= mod_;
        }
        num += 1;
    }
    println!("{}", ans);
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}