#include <bits/stdc++.h>

using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;

class rep {
    struct Iter {
        usize itr;
        constexpr Iter(const usize pos) noexcept : itr(pos) {}
        constexpr void operator++() noexcept { ++itr; }
        constexpr bool operator!=(const Iter& other) const noexcept { return itr != other.itr; }
        constexpr usize operator*() const noexcept { return itr; }
    };
    const Iter first, last;

  public:
    explicit constexpr rep(const usize first, const usize last) noexcept : first(first), last(std::max(first, last)) {}
    constexpr Iter begin() const noexcept { return first; }
    constexpr Iter end() const noexcept { return last; }
};

template <class F> struct RecursiveLambda : private F {
    explicit constexpr RecursiveLambda(F&& f) : F(std::forward<F>(f)) {}
    template <class... Args> constexpr decltype(auto) operator()(Args&&... args) const {
        return F::operator()(*this, std::forward<Args>(args)...);
    }
};

template <class F> constexpr decltype(auto) rec_lambda(F&& f) {
    using G = std::decay_t<F>;
    return RecursiveLambda<G>(std::forward<G>(f));
}

template <class T> using Vec = std::vector<T>;

void main_() {
    usize N;
    u64 K;
    std::cin >> N >> K;
    Vec<std::pair<u64, u64>> dp;
    dp.emplace_back(1, 1);
    for (const auto i : rep(1, std::min<usize>(N, 80) + 1)) {
        const auto cur = dp.size();
        for (const auto j : rep(0, cur)) {
            if (dp[j].first * i <= K) {
                dp.emplace_back(dp[j].first * i, dp[j].second);
            }
        }
        std::inplace_merge(dp.begin(), dp.begin() + cur, dp.end());
        Vec<std::pair<u64, u64>> next;
        u64 last = 0;
        for (const auto [x, c] : dp) {
            if (x != last) {
                next.emplace_back(x, 0);
                last = x;
            }
            next.back().second += c;
        }
        dp = std::move(next);
    }
    const auto size = dp.size();
    Vec<u64> sum(size + 1);
    for (const auto i : rep(0, size)) {
        sum[i + 1] = sum[i] + dp[i].second;
    }
    std::array<u64, 1000000> count{};
    for (const auto i : rep(0, size)) {
        if (dp[i].first <= 1000000) {
            count[dp[i].first] += dp[i].second;
        }
    }
    for (const auto i : rep(1, count.size())) {
        count[i] += count[i - 1];
    }
    u64 ans = 0;
    rec_lambda([&](auto&& dfs, const u64 from, const u64 cur) -> void {
        if (cur > 10000) {
            ans += count[K / cur];
        } else {
            ans += sum[std::lower_bound(dp.begin(), dp.end(), std::pair<u64, u64>(K / cur + 1, 0)) - dp.begin()];
        }
        for (const auto next : rep(from, N + 1)) {
            if (cur * next > K) break;
            dfs(next + 1, cur * next);
        }
    })(81, 1);
    std::cout << ans - 1 << '\n';
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    main_();
    return 0;
}