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 read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

fn primer(m: u64) -> u64 {
    let end = (((m as f64).sqrt()) as u64) + 1;
    for i in 2..end {
        if m % i == 0 {
            return i;
        }
    }
    m
}

fn prime_factrization(mut m: u64) -> Vec<usize> {
    let mut ans: Vec<usize> = vec![];
    let mut tmp: u64 = 0;
    let mut l: usize = 0;
    while m > 1 {
        let prm = primer(m);
        m /= prm;
        if prm == 1 {
            break;
        } else if prm != tmp {
            tmp = prm;
            l += 1;
            ans.push(1);
        } else {
            ans[l - 1] += 1;
        }
    }
    ans
}

const R: u64 = 1000000007;

fn main() {
    let nm: Vec<u64> = read_vec();
    let n = nm[0] as usize;
    let m = nm[1];

    let mut cmb: Vec<Vec<u64>> = vec![vec![1; n]; 31];

    for i in 1..31 {
        for j in 1..n {
            cmb[i][j] = (cmb[i - 1][j] + cmb[i][j - 1]) % R;
        }
    }

    let mut ans: u64 = 1;
    let primes = prime_factrization(m);
    for p in primes {
        ans *= cmb[p][n - 1];
        ans %= R;
    }

    println!("{}", ans);
}