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::str::FromStr;
use std::fmt::Debug;

fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn factorize(m: u64) -> Vec<u64>{
    let mut v: Vec<u64> = Vec::new();
    let mut target = m;
    for x in 2..(m as f64).sqrt().ceil() as u64{
        let mut counter = 0;
        while target % x == 0{
            target /= x;
            counter += 1;
        }
        if counter != 0{
            v.push(counter);
        }
    }
    if target > 1{
        v.push(1);
    }
    
    v
}

fn factorial(n: u64) -> u64{
    let mut ans: u64 = 1;
    for i in 2..n+1{
        ans *= i;
    }
    ans
}

fn combination(n: u64, m: u64) -> u64{
    //println!("n = {}, m = {}", n, m);
    let mut ans = 1;
    for i in 0..m{
        //println!("lets multiply {}, {}", ans, n-i);
        ans = ans * n -i % 1000000007;
        //println!("joyo {}", ans);
    }
    /*
    println!("factorial(m): {}", factorial(m));
    println!("return: {}", ans/factorial(m));
    */
    ans/factorial(m)
}

fn main(){
    let line: Vec<u64> = read_as_vec();
    let (n, m) = (line[0], line[1]);
    let f = factorize(m);
    //println!("f = {:?}", f);
    let mut ans = 1;
    for x in &f{
        //ans = ans * factorial(*x+n-1)/factorial(*x)/factorial(n-1);
        //println!("ans = {}", ans);
        ans *= combination(*x+n-1, *x);
        ans %=1000000007;
    }
    //println!("{}", combination(5,2));
    println!("{}", ans);
}