using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
    class Program
    {
        static void Main(string[] args)
        {
            ABC110.D();
        }
        class ABC110
        {
            public static void C()
            {
                var S = ReadStr();
                var T = ReadStr();
                var dict1 = new Dictionary<char, char>();
                var dict2 = new Dictionary<char, char>();
                for (int i = 0; i < S.Length; ++i)
                {
                    var s = S[i];
                    var t = T[i];
                    if (dict1.ContainsKey(s))
                    {
                        if (dict1[s] != t)
                        {
                            Console.WriteLine("No"); return;
                        }
                    }
                    else
                    {
                        dict1.Add(s, t);
                    }
                    if (dict2.ContainsKey(t))
                    {
                        if (dict2[t] != s)
                        {
                            Console.WriteLine("No"); return;
                        }
                    }
                    else
                    {
                        dict2.Add(t, s);
                    }
                }
                Console.WriteLine("Yes");
            }
            public static void D()
            {
                var nm = ReadLongN();
                var N = (int)nm[0];
                var M = nm[1];
                var fact = Util.Factorize(M);
                var comb = Util.Combin(N * 2 + 1000, Util.P);
                long prod = 1;
                foreach(var kvp in fact)
                {
                    var v = kvp.Value;
                    prod = (prod * comb(v + N - 1, v)) % Util.P;
                }
                Console.WriteLine(prod);
            }
        }

        class Util
        {
            public static readonly long P = 1000000007;
            public static long Inverse(long a, long p)
            {
                long b = p, c = 1, d = 0, e = 0, f = 0;
                while (b != 0)
                {
                    e = a / b;
                    f = b; b = a - e * b; a = f;
                    f = d; d = c - e * d; c = f;
                }
                c %= p;
                return c + (c < 0 ? p : 0);
            }
            public static long[] Facts(int n, long p)
            {
                var facts = new long[n + 1];
                facts[0] = 1;
                for (int i = 1; i <= n; ++i)
                {
                    facts[i] = (i * facts[i - 1]) % p;
                }
                return facts;
            }
            public static Func<int, int, long> Combin(int n, long P)
            {
                var fact = Facts(n, P);
                var inv = fact.Select(x => Inverse(x, P)).ToArray();
                return (N, M) =>
                {
                    if (N < 0 || N < M || M < 0) { return 0; }
                    return (((fact[N] * inv[M]) % P) * inv[N - M]) % P;
                };
            }
            public static Dictionary<long, int> Factorize(long x)
            {
                var dict = new Dictionary<long, int>();
                long minp = 2;
                while (x > 1)
                {
                    bool ok = false;
                    for (long p = minp; p * p <= x; ++p)
                    {
                        if (x % p == 0)
                        {
                            if (!dict.ContainsKey(p))
                            {
                                dict.Add(p, 0);
                            }
                            dict[p]++;
                            minp = p;
                            x /= p;
                            ok = true;
                            break;
                        }
                    }
                    if (!ok)
                    {
                        if (!dict.ContainsKey(x)) { dict.Add(x, 0); }
                        dict[x]++;
                        break;
                    }
                }
                return dict;
            }
        }

        #region Reader
        static string ReadStr()
        {
            return Console.ReadLine();
        }
        static string[] ReadStrN()
        {
            return Console.ReadLine().Split(' ');
        }
        static int ReadInt()
        {
            return Convert.ToInt32(Console.ReadLine());
        }
        static int[] ReadIntN()
        {
            return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray();
        }
        static long ReadLong()
        {
            return Convert.ToInt64(Console.ReadLine());
        }
        static long[] ReadLongN()
        {
            return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray();
        }
        static long[,] ReadLongMatrix(int r,int c)
        {
            var mat = new long[r, c];
            for(int i = 0; i < r; ++i)
            {
                var x = ReadLongN();
                for(int j = 0; j < c; ++j)
                {
                    mat[i, j] = x[j];
                }
            }
            return mat;
        }
        static Tuple<string, string>[] ReadTupleStr(int n)
        {
            List<Tuple<string, string>> list = new List<Tuple<string, string>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadStrN();
                list.Add(new Tuple<string, string>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<long, long>[] ReadTupleLong(int n)
        {
            List<Tuple<long, long>> list = new List<Tuple<long, long>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadLongN();
                list.Add(new Tuple<long, long>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<int, int>[] ReadTupleInt(int n)
        {
            List<Tuple<int, int>> list = new List<Tuple<int, int>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadIntN();
                list.Add(new Tuple<int, int>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Tuple<double, double>[] ReadTupleDouble(int n)
        {
            List<Tuple<double, double>> list = new List<Tuple<double, double>>();
            for (int i = 0; i < n; ++i)
            {
                var ab = ReadLongN();
                list.Add(new Tuple<double, double>(ab[0], ab[1]));
            }
            return list.ToArray();
        }
        static Dictionary<int, HashSet<int>> ReadAdjacencyList(int N, int M)
        {
            Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
            for (int i = 0; i <= N; ++i)
            {
                dict.Add(i, new HashSet<int>());
            }
            for (int i = 0; i < M; ++i)
            {
                var ab = ReadIntN();
                dict[ab[0]].Add(ab[1]);
                dict[ab[1]].Add(ab[0]);
            }
            return dict;
        }
        #endregion
    }
}


Measured memory_bytes: 20192