#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const int MOD = 1e9 + 7;

int main() {
    int n, k;
    cin >> n >> k;

    // dp[v]: số dãy độ dài i kết thúc bằng giá trị v
    vector<int> dp(k + 1, 0);
    // dp_next[v]: số dãy độ dài i+1 kết thúc bằng giá trị v
    vector<int> dp_next(k + 1, 0);

    // Khởi tạo cho độ dài 1
    for (int v = 1; v <= k; v++) {
        dp[v] = 1;
    }

    for (int i = 2; i <= n; i++) {
        fill(dp_next.begin(), dp_next.end(), 0);

        for (int u = 1; u <= k; u++) {
            if (dp[u] == 0) continue;
            // a_{i-1} = u, a_i phải là ước của u
            // Duyệt các ước của u (trừ u本身 vì có vẻ như điều kiện là chia hết? code mẫu dùng ước đúng)
            // Code mẫu dùng:
            // 1. u -> bội đúng của u (nếu điều kiện là u chia hết cho a_i)
            // 2. u -> ước đúng của u (nếu điều kiện là a_i chia hết cho u)
            // Đề bài 'a_{i-1} chia hết cho a_i' => a_i là ước của a_{i-1}.

            // Solution 1 & 3 ghi: u -> ước đúng của u
            for (int d = 1; d * d <= u; d++) {
                if (u % d == 0) {
                    int x = d;
                    // x là ước của u (a_i = x)
                    // Lưu ý: code mẫu có vẻ đang làm bài 'a_i chia hết cho a_{i-1}'? 
                    // Đọc kỹ: Solution 1 có comment '// u -> ước đúng của u' và vòng lặp d
                    // Solution 3 có comment 'DP[i][j] ... a[i] = j' và vòng lặp j la divisors of i (tên biến hơi乱)
                    // Solution 1: ndp[v] += dp[u] where v is divisor of u
                    dp_next[x] = (dp_next[x] + dp[u]) % MOD;
                    if (u / d != x) {
                        dp_next[u / d] = (dp_next[u / d] + dp[u]) % MOD;
                    }
                }
            }
            // Loại trừ chính nó nếu chỉ yêu cầu ước đúng
            // Giả sử đề bài yêu cầu a_{i-1} chia hết cho a_i (không nhất thiết phải khác)
            // Code mẫu Solution 1 không loại trừ自身 (vòng lặp d=1..sqrt, d=1 -> x=1, u/d=u -> add cả 2)
            // Solution 3 dùng dp[0] cho i-1, dp[1] cho i. Vòng lặp j la divisor of i (tên biến i là u)
            // Cần phải check lại logic: 
            // Solution 1: 
            // for (int d=1; d*d<=u; d++) {
            //   if(u%d==0) { int x=d; ndp[x] += dp[u]; if(u/d != x) ndp[u/d] += dp[u]; }
            // }
            // Vòng lặp này add dp[u] vào tất cả các ước của u.
            // Như vậy dp_next[v] có giá trị từ dp[u] với mọi u là bội của v.
        }
        swap(dp, dp_next);
    }

    long long sum = 0;
    for (int v = 1; v <= k; v++) {
        sum = (sum + dp[v]) % MOD;
    }
    cout << sum << endl;
    return 0;
}

#include <iostream>
#include <vector>

using namespace std;

const int MOD = 1e9 + 7;

int main() {
    int n, k;
    cin >> n >> k;

    // dp[v]: số dãy độ dài i kết thúc bằng v
    vector<int> dp(k + 1, 1); // Khởi tạo độ dài 1: mọi v đều có 1 cách

    for (int i = 2; i <= n; i++) {
        vector<int> next_dp(k + 1, 0);

        // Tính prefix sum của dp trước
        vector<int> prefix(k + 1, 0);
        for (int v = 1; v <= k; v++) {
            prefix[v] = (prefix[v - 1] + dp[v]) % MOD;
        }

        // next_dp[v] = sum(dp[u]) for all u that are multiples of v
        // next_dp[v] = sum(dp[v], dp[2v], dp[3v], ...)
        // Cach 1: Duyệt v, duyệt bội
        for (int v = 1; v <= k; v++) {
            long long sum = 0;
            for (int u = v; u <= k; u += v) {
                sum = (sum + dp[u]) % MOD;
            }
            next_dp[v] = sum;
        }

        dp = next_dp;
    }

    long long ans = 0;
    for (int v = 1; v <= k; v++) {
        ans = (ans + dp[v]) % MOD;
    }
    cout << ans << endl;
    return 0;
}

for (int v = 2 * u; v <= k; v += u) {
    ndp[v] = add(ndp[v], dp[u]);
}

#include <bits/stdc++.h>
using namespace std;

const int MOD = 1e9 + 7;
int N, K;
int dp[105][20005]; // dp[i][v]: so day do dai i ket thuc bang v

int main() {
    if (fopen("SEQDIV.INP", "r")) {
        freopen("SEQDIV.INP", "r", stdin);
        freopen("SEQDIV.OUT", "w", stdout);
    }

    cin >> N >> K;

    // Khoi tao do dai 1
    for (int v = 1; v <= K; v++) dp[1][v] = 1;

    for (int i = 2; i <= N; i++) {
        // Tinh toan dp[i][v]
        // Dieu kien: a_{i-1} chia het cho a_i => a_{i-1} phai la boi cua a_i
        // dp[i][v] = sum(dp[i-1][u]) for all u that are multiples of v

        // Su dung mang tien to de tinh nhanh
        // Hoac don gian la duyet nguoc de tinh toan

        // Cach 1: Duyet v tu nho den lon, suong tien cho viec tinh tien to
        // Neu a_i = v, a_{i-1} phai la multiple of v
        // dp[i][v] = dp[i-1][v] + dp[i-1][2v] + dp[i-1][3v] + ...

        // De tinh nhanh, ta co the duyet v tu lon ve nho va cap nhat
        // Hoac su dung mang tien to

        // Solution 2 cua user dainghiajustiin co ve su dung 2 mang duyet nguoc
        // 
        // Gia su de bai la a_{i-1} | a_i
        // dp[i][v] = sum(dp[i-1][u]) where u % v == 0

        // Cach de hieu nhat: Duyet v, duyet boi
        for (int v = 1; v <= K; v++) {
            long long sum = 0;
            for (int u = v; u <= K; u += v) {
                sum += dp[i-1][u];
            }
            dp[i][v] = sum % MOD;
        }
    }

    long long ans = 0;
    for (int v = 1; v <= K; v++) ans = (ans + dp[N][v]) % MOD;
    cout << ans << endl;
    return 0;
}