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

use std::collections::HashMap;
#[allow(unused_macros)]
macro_rules! invec {
    ( $t:ty ) => {{
        let mut s = String::new();
        match std::io::stdin().read_line(&mut s) {
            Ok(0) => Vec::<$t>::new(),
            Ok(n) => s.trim().split_whitespace().map(|s| s.parse::<$t>().unwrap()).collect::<Vec<$t>>(),
            Err(_) => Vec::<$t>::new(),
        }
    }}
}

#[allow(unused_macros)]
macro_rules! input {
    ( $($t:ty),* ) => {{
        let mut s = String::new();
        std::io::stdin().read_line(&mut s);
        let mut splits = s.trim().split_whitespace();
        ($(
            {
                 splits.next().unwrap().parse::<$t>().unwrap()
            },
        )*)
    }}
}

fn prime_factorization(mut m: u64) -> HashMap<u64, u64> {
    let mut hmap = HashMap::new();
    let end = (m as f64).sqrt().floor() as u64 + 1;
    for i in 2..end {
        while m % i == 0 {
            let count = hmap.entry(i).or_insert(0);
            *count += 1;
            m /= i;
        }
    }
    if m != 1 {
        hmap.insert(m, 1);
    }
    return hmap;
}

fn comb(n: u64, r: u64) -> u64 {
    // if n / 2 < r {
    //     return comb(n, n - r);
    // }
    let numerator = ((n-r+1)..(n+1)).fold(1, |acc, x| (acc * x) % MODIFIER);
    let denominator = (1..(r+1)).fold(1, |acc, x| (acc * x));

    (numerator * modpow(denominator, MODIFIER - 2)) % MODIFIER
}

fn modpow(a: u64, p: u64) -> u64 {
    match p {
        0               => { 1 },
        p if p % 2 == 0 => { 
                             let half = modpow(a, p / 2) % MODIFIER;
                             (half * half) % MODIFIER
                           },
        p               => { (a * modpow(a, p - 1))% MODIFIER }
    }
}

static MODIFIER: u64 = 1_000_000_007;

#[allow(unused_must_use)]
#[allow(unused_variables)]
fn solve() {
    let (n, m) = input!(u64, u64);
    
    let primes = prime_factorization(m);
    
    

    let ans = primes.values()
                    .map(|x| comb(x + n - 1, *x))
                    .fold(1, |acc, x| (acc * x) % MODIFIER);

    println!("{}", ans);

}

fn main() {
    solve();
}