#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;

template <typename T> inline constexpr bool chmin(T &a, T b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T> inline constexpr bool chmax(T &a, T b) {
  if (b > a) {
    a = b;
    return true;
  }
  return false;
}
template <typename ite>
void print_ite(ite start, ite end, char sp = ' ', char en = '\n') {
  for (auto i = start; i != end; i++)
    cout << *i << sp;
  cout << en;
}
template <typename ite> void scan_ite(ite start, ite end) {
  for (auto i = start; i != end; i++)
    cin >> (*i);
}
inline void Yes(bool condition) { cout << (condition ? "Yes\n" : "No\n"); }

namespace mod {
using u64 = uint_fast64_t;
template <u64 MOD> class modInt {

private:
  u64 a;
  constexpr u64 extgcd(const u64 a, const u64 b, u64 &x, u64 &y) const {
    u64 d = a;
    if (b != 0) {
      d = extgcd(b, a % b, y, x);
      y -= (a / b) * x;
    } else {
      x = 1;
      y = 0;
    }
    return d;
  }

public:
  constexpr modInt(const long long x = 0) : a(((x % MOD) + MOD) % MOD) {}
  constexpr inline u64 value() const { return a; }
  constexpr modInt pow(u64 p) const {
    if (p == 0)
      return modInt(1);
    if (p % 2 == 0) {
      modInt d = pow(p / 2);
      return d * d;
    } else {
      return *this * pow(p - 1);
    }
  }
  constexpr modInt inverse() const {
    u64 x = 0, y = 0;
    extgcd(a, MOD, x, y);
    return modInt(x);
  }
  constexpr modInt &operator+=(const modInt x) {
    a += x.a;
    if (a >= MOD) {
      a -= MOD;
    }
    return *this;
  }
  constexpr modInt &operator-=(const modInt x) {
    if (a < x.a) {
      a += MOD;
    }
    a -= x.a;
    return *this;
  }
  constexpr modInt &operator*=(const modInt x) {
    a = a * x.a % MOD;
    return *this;
  }
  constexpr modInt &operator/=(const modInt x) {
    assert(x.a != 0);
    *this *= x.inverse();
    return *this;
  }
  constexpr modInt operator++() { return *this += modInt(1); }
  constexpr modInt operator--() { return *this -= modInt(1); }
};
template <u64 MOD>
constexpr modInt<MOD> operator+(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) += rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator-(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) -= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator*(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) *= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator/(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) /= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator==(const modInt<MOD> lha, const modInt<MOD> rha) {
  return lha.value() == rha.value();
}
template <u64 MOD>
constexpr modInt<MOD> operator!=(const modInt<MOD> lha, const modInt<MOD> rha) {
  return !(lha.value() == rha.value());
}
template <u64 MOD>
std::ostream &operator<<(std::ostream &stream, const modInt<MOD> x) {
  stream << x.value();
  return stream;
}
template <u64 MOD>
std::istream &operator>>(std::istream &stream, modInt<MOD> &x) {
  u64 a;
  stream >> a;
  x = modInt<MOD>(a);
  return stream;
}
} // namespace mod

using modi = mod::modInt<(int)1e9 + 7>;
int main() {
  modi ans = 0;
  int n, k;
  cin >> n >> k;
  vector<modi> memo(k + 5, 0);
  for (int i = k; i >= 1; i--) {
    // gcd$B$,(Bi$B$K$J$k$h$&$J(B
    modi way = modi(k / i).pow(n);
    for (int j = 2 * i; j <= k; j += i) {
      way -= memo[j];
    }
    memo[i] = way;
    ans += way * modi(i);
  }
  cout << ans << endl;
}


Measured memory_bytes: 3672