#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MOD 1000000007
#define N_MAX 100000
using namespace std;

typedef pair<int, int> P;
typedef pair<long long, long long> LLP;

/*
  階乗計算（MODで割った余りで返す）
*/

class Factorial {
    private:
        vector<long long int> fac;
    public:
        Factorial();
        Factorial(long long int n_max);
        void initialization(long long int n_max);
        long long int getFactorial(long long int n);
};

Factorial::Factorial() {}
Factorial::Factorial(long long int n_max) {
    fac.clear();
    fac.push_back(1);
    fac.push_back(1);
    for (long long int i = 2; i <= n_max; i++) {
        fac.push_back(fac[i-1] * i % MOD);
    }
}
void Factorial::initialization(long long int n_max) {
    fac.clear();
    fac.push_back(1);
    fac.push_back(1);
    for (long long int i = 2; i <= n_max; i++) {
        fac.push_back(fac[i-1] * i % MOD);
    }
}
long long int Factorial::getFactorial(long long int n) {
    return fac[n];
}

/*
  MOD計算
*/
// 割り算のための逆元を求める（mod m での a の逆元）
long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m; 
    if (u < 0) u += m;
    return u;
}

/*
    順列と組み合わせ (P, C, H)
*/

class PCH {
    private:
        Factorial fact;
    
    public:
        PCH(long long int n_max);
        long long int P(long long int n, long long int r);
        long long int C(long long int n, long long int r);
        long long int H(long long int n, long long int r);
};
PCH::PCH(long long int n_max) {
    fact.initialization(n_max);
}
long long int PCH::P(long long int n, long long int r) {
    return fact.getFactorial(n) % MOD * modinv(fact.getFactorial(r), MOD) % MOD;
}

long long int PCH::C(long long int n, long long int r) {
    return fact.getFactorial(n) % MOD * modinv(fact.getFactorial(r), MOD) % MOD * modinv(fact.getFactorial(n - r), MOD) % MOD;
}

long long int PCH::H(long long int n, long long int r) {
    return C(n - 1 + r, r);
}

/*
  素因数分解
    nを素因数分解した結果をllpに格納する。結果はllp[i].first = (素因数)、llp[i].second = （個数）
    n <= 1 の時は何もしないので注意。
    n が素数ならばllpには (n, 1) のpairのみが入っている
*/
void factorization(vector<LLP>& llp, long long n) {
    if (n <= 1) return;
    long long n2 = n;
    for (long long i = 2; i * i <= n ; i++) {
        int count = 0;
        while (n2 % i == 0) {
            n2 = n2 / i;
            count ++;
        }
        if (count > 0) {
            LLP temp;
            temp.first = i;
            temp.second = count;
            llp.push_back(temp);
        }
    }
    if (n2 > 1) {
        LLP temp;
        temp.first = n2;
        temp.second = 1;
        llp.push_back(temp);
    }
}

int main() {
    int N, M;
    cin >> N >> M;

    if (M == 1) {
        cout << 1 << endl;
        return 0;
    }

    vector<LLP> pfactors;
    factorization(pfactors, M);

    PCH pch(N_MAX * 2);

    long long int res = 1;

    for (int i = 0; i < pfactors.size(); i++) {
        res = res * pch.H(N, pfactors[i].second) % MOD;
    }

    cout << res << endl;

    return 0;
}

Measured memory_bytes: 2420