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)

#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};

#[allow(unused_imports)]
use template::buf_scan::*;
#[allow(unused_imports)]
use template::*;

#[allow(dead_code)]
#[macro_use]
pub mod macros {
    #[macro_export]
    macro_rules! debug {
        ($($a:expr),*) => {{
            use ::std::io::Write;
            writeln!(&mut ::std::io::stderr(), concat!($(stringify!($a), " = {:?}, "),*), $($a),*).unwrap();
        }}
    }

    #[macro_export]
    macro_rules! input {
        (source = $s:expr, $($r:tt)*) => {
            let mut scanner = $crate::template::buf_scan::BufScanner::new($s.as_bytes());
            input_inner!{scanner, $($r)*}
        };
        (scanner = $s:ident, $($r:tt)*) => {
            input_inner!{$s, $($r)*}
        };
        ($($r:tt)*) => {
            let stdin = ::std::io::stdin();
            let mut scanner = $crate::template::buf_scan::BufScanner::new(stdin.lock());
            input_inner!{scanner, $($r)*}
        };
    }

    macro_rules! input_inner {
        ($scanner:expr) => {};
        ($scanner:expr, ) => {};
        ($scanner:ident, $var:ident : $t:tt $($r:tt)*) => {
            let $var = read_value!($scanner, $t);
            input_inner!{$scanner $($r)*}
        };
        ($scanner:ident, mut $var:ident : $t:tt $($r:tt)*) => {
            let mut $var = read_value!($scanner, $t);
            input_inner!{$scanner $($r)*}
        };
    }

    macro_rules! read_value {
        ($scanner:ident, ( $($t:tt),* )) => {
            ( $(read_value!($scanner, $t)),* )
        };
        ($scanner:ident, [ $t:tt ; $len:expr ]) => {
            (0..$len).map(|_| read_value!($scanner, $t)).collect::<Vec<_>>()
        };
        ($scanner:ident, chars) => {
            read_value!($scanner, String).chars().collect::<Vec<char>>()
        };
        ($scanner:ident, usize1) => {
            read_value!($scanner, usize) - 1usize
        };
        ($scanner:ident, $t:ty) => {
            ($scanner).next::<$t>()
        };
    }
}


fn prime_factorization(mut n: u32) -> Vec<(u32, u32)> {
    let sqrt_n = ((n as f64).sqrt() + 2.0) as u32;
    let mut res = vec![];
    for p in 2..sqrt_n {
        if n % p != 0 {
            continue;
        }
        let mut e = 0u32;
        while n % p == 0 {
            n /= p;
            e += 1;
        }
        res.push((p, e));
    }
    if n != 1 {
        res.push((n, 1));
    }
    return res;
}

fn main() {
    input! {
        n: usize,
        m: u32,
    }
    let es: Vec<_> = prime_factorization(m).iter().map(|x| x.1).collect();
    const MOD: u32 = 1_000_000_007;
    let mut res = 1u64;

    for e in es {
        let e = e as usize;
        let mut dp = vec![0u32; e+1];
        dp[0] = 1;
        for _ in 0..n {
            for j in 0..e {
                dp[j+1] += dp[j];
                dp[j+1] %= MOD;
            }
        }
        res *= dp[e] as u64;
        res %= MOD as u64;
    }
    println!("{}", res);
}

#[allow(dead_code)]
pub mod template {
    pub mod buf_scan {
        pub trait LockRead<R: ::std::io::BufRead> {
            fn locked_scanner(self: Self) -> BufScanner<R>;
        }

        impl<'a> LockRead<::std::io::StdinLock<'a>> for &'a ::std::io::Stdin {
            fn locked_scanner(self: Self) -> BufScanner<::std::io::StdinLock<'a>> {
                BufScanner::new(self.lock())
            }
        }

        pub struct BufScanner<R: ::std::io::BufRead> {
            br: R,
            buf: Vec<u8>,
            pos: usize,
        }

        impl<R: ::std::io::BufRead> BufScanner<R> {
            pub fn new(br: R) -> Self {
                BufScanner {
                    br: br,
                    buf: Vec::new(),
                    pos: 0usize,
                }
            }
            fn fill_line(&mut self) {
                self.buf.clear();
                self.pos = 0;
                self.br
                    .read_until(b'\n', &mut self.buf)
                    .expect("Read a line");
                if let Some(&b'\n') = self.buf.last() {
                    self.buf.pop();
                    if let Some(&b'\r') = self.buf.last() {
                        self.buf.pop();
                    }
                }
            }
            fn skip_space(&mut self) {
                loop {
                    for i in self.pos..self.buf.len() {
                        if self.buf[i] != b' ' {
                            self.pos = i;
                            return;
                        }
                    }
                    self.fill_line();
                }
            }
            pub fn read_token(&mut self) -> &str {
                self.skip_space();
                let start = self.pos;
                while self.pos < self.buf.len() && self.buf[self.pos] != b' ' {
                    self.pos += 1;
                }
                let ret = unsafe { ::std::str::from_utf8_unchecked(&self.buf[start..self.pos]) };
                self.pos += 1; // skip the last space (or len() + 1 which is fine)
                return ret;
            }
            pub fn next<T: ::std::str::FromStr>(&mut self) -> T {
                self.read_token().parse::<T>().ok().expect("Parse")
            }
        }
    }
}