#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>

using namespace std;
using LLONG = long long;
const LLONG MOD = 1000000007;

class ModCalc
{
    LLONG m_mod = MOD;
    vector<LLONG> m_fac;
    vector<LLONG> m_ifac;

public:
    ModCalc(const LLONG mod)
    {
        m_mod = mod;
    }

    // Combinationを計算したいときの前処理：O(max)
    ModCalc(const int max, const LLONG mod)
    {
        m_mod = mod;
        m_fac = vector<LLONG>(max + 1);
        m_ifac = vector<LLONG>(max + 1);
        m_fac[0] = m_ifac[0] = 1;
        for (int i = 0; i < max; ++i)
        {
            m_fac[i + 1] = m_fac[i] * (i + 1) % mod;    // n! (mod M)
            m_ifac[i + 1] = m_ifac[i] * ModPow(i + 1, mod - 2) % mod;   // k!^(M-2) (mod M)
        }
    }

    const LLONG ModAdd(LLONG a, LLONG b) const
    {
        return (a + b) % m_mod;
    }

    const LLONG ModSubtract(LLONG a, LLONG b) const
    {
        LLONG diff = a - b;
        return diff >= 0 ? diff : diff + m_mod;
    }

    const LLONG ModMulti(LLONG a, LLONG b) const
    {
        LLONG prod = a * b % m_mod;
        return prod >= 0 ? prod : prod + m_mod;
    }

    const LLONG ModDiv(LLONG a, LLONG b) const
    {
        LLONG c = m_mod, u = 1, v = 0;
        while (c)
        {
            LLONG t = b / c;
            b -= t * c; swap(b, c);
            u -= t * v; swap(u, v);
        }
        u %= m_mod;
        if (u < 0) u += m_mod;
        return (a % m_mod) * u % m_mod;
    }

    const LLONG ModPow(LLONG x, LLONG n) const
    {
        LLONG ret = 1;
        while (n != 0)
        {
            if (n & 1) ret = ret * x % m_mod;
            x = x * x % m_mod;
            n = n >> 1;
        }
        return ret;
    }

    const LLONG ModComb(LLONG n, LLONG r) const
    {
        if (n == 0 && r == 0) return 1;
        if (n < r || n < 0) return 0;
        LLONG tmp = m_ifac[n - r] * m_ifac[r] % m_mod;
        return tmp * m_fac[n] % m_mod;
    }
};

int main()
{
    int N, K; cin >> N >> K;
    ModCalc mod(MOD);
    vector<LLONG> gcdNums(K + 1);
    for (int x = K; x >= 1; --x)
    {
        // GCD が x の倍数になっているものの個数
        LLONG gcdNum = mod.ModPow(K / x, N);
        // GCD が x になるものを求めるため，上から 2x, 3x, ... になるものを除く
        for (int x2 = x * 2; x2 <= K; x2 += x)
        {
            gcdNum = mod.ModSubtract(gcdNum, gcdNums[x2]);
        }
        gcdNums[x] = gcdNum;
    }
    LLONG ans = 0;
    for (int x = 1; x <= K; ++x)
    {
        ans = mod.ModAdd(ans, gcdNums[x] * x);
    }
    cout << ans << endl;
}

//int main()
//{
//    int N, K; cin >> N >> K;
//    vector<LLONG> gcd2Nums(K + 1);
//    // N = 1 のとき gcd({a1}) = a1
//    for (int i = 1; i <= K; ++i)
//    {
//        gcd2Nums[i] = 1;
//    }
//    // N = n のときの各 gcd の場合の数が与えられているとき，
//    // N = n + 1 （末尾にa_n+1を追加）とすると
//    for (int n = 1; n < N; ++n)
//    {
//        for (int i = 1; i <= K; ++i)
//        {
//            int baisuNum = K / i;
//            gcd2Nums[i] *= baisuNum;
//            gcd2Nums[i] %= MOD;
//        }
//    }
//    LLONG ans = 0;
//    for (int i = 1; i <= K; ++i)
//    {
//        ans += gcd2Nums[i];
//        ans %= MOD;
//    }
//    cout << ans << endl;
//}

//int main()
//{
//    int N, K; cin >> N >> K;
//    // S(N, 1) -> ... -> S(N, K)
//    vector<LLONG> gcd2Nums(N + 1, 0);
//    vector<LLONG> k2Sums(K + 1, 0); 
//    // K = 1 のとき，GCD は 1 で，総和も１
//    gcd2Nums[1] = k2Sums[1] = 1;
//    for (int k = 2; k <= K; ++k)
//    {
//
//    }
//    // 二次元DP? k + 1 まで使えるようにしたとき，
//    // k + 1 を使う数が 0 ~ N の k 通り
//    // しかし，dp[N][K]はメモリに乗らない…
//}


Measured memory_bytes: 4036