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)

fn getline() -> String{
    let mut __ret=String::new();
    std::io::stdin().read_line(&mut __ret).ok();
    return __ret;
}

const MOD: i64 = 1000000007;

fn mpermu(a: i64, num: i64) -> i64 {
    match num {
        0 => 1,
        _ => a * mpermu(a - 1, num - 1) % MOD
    }
}

fn mpow(x: i64,  y: i64) -> i64 {
    match y {
        0 => 1,
        _ => (x.pow((y % 2) as u32) * mpow(x * x % MOD, y / 2)) % MOD
    }
}

fn main(){
    let s=getline();
    let a:Vec<_>=s.trim().split(' ').collect();
    let n:i64=a[0].parse().unwrap();
    let m:i64=a[1].parse().unwrap();
    
    let mut v: i64 = m;
    let mut r: i64 = 1;
    let mut div: i64 = 2;
    
    while div * div <= m {
        let mut rd = 0;
    
        while v % div == 0 {
        v /= div;
            rd+=1;
        }
        r = (r * mpermu((rd + n - 1) % MOD, rd) % MOD) * mpow(mpermu(rd, rd), MOD - 2) % MOD;
        div+=1;
    }
    if v > 1 {
        r = (r * (1 + n - 1)) % MOD;
    }
    
    println!("{}", r);
}