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

// Hàm tính số cặp (j, i) sao cho C(i, j) KHÔNG chia hết cho p
// Dựa trên Lucas Theorem: C(i, j) chia hết cho p nếu và chỉ nếu
// trong ít nhất một cặp số hạng tử cơ số p (i_k, j_k), ta có j_k > i_k.
// Vậy, C(i, j) KHÔNG chia hết cho p khi j_k <= i_k với mọi k.
// Số cách chọn j_k <= i_k cho mỗi số hạng tử i_k là (i_k + 1).
// Do đó, tổng số cặp không chia hết là tổng của (i_k + 1) với mọi i_k.
int64 count_not_divisible(int n, int p) {
    int64 total = 0;
    for (int i = 0; i < n; ++i) {
        int64 count = 1;
        int temp = i;
        while (temp > 0) {
            count *= (temp % p + 1);
            temp /= p;
        }
        total += count;
    }
    return total;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, p;
    cin >> n >> p;

    // Tổng số cặp (j, i) thỏa mãn 0 <= j <= i < n là tổng của (i + 1) từ i = 0 đến n-1
    // Cong thuc tong: n*(n+1)/2
    int64 total_pairs = 1LL * n * (n + 1) / 2;

    // Số cặp chia hết = Tổng số cặp - Số cặp không chia hết
    int64 divisible = total_pairs - count_not_divisible(n, p);

    cout << divisible << "\n";
    return 0;
}

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

using ll = long long;

int p;
vector<int> digits; // Biểu diễn n dưới cơ số p

// dp[pos][less_i][less_j]
// pos: vị trí chữ số đang xét (từ trái sang phải)
// less_i: true nếu prefix của i đã nhỏ hơn prefix của n
// less_j: true nếu prefix của j đã nhỏ hơn prefix của n
// Giá trị trả về: số cặp (j, i) thỏa mãn điều kiện j <= i và C(i, j) không chia hết cho p
ll dp[30][2][2];

ll dfs(int pos, bool less_i, bool less_j) {
    if (pos == (int)digits.size()) return 1; // Tìm thấy một cặp (j, i) hợp lệ

    if (dp[pos][less_i][less_j] != -1) return dp[pos][less_i][less_j];

    ll res = 0;
    int limit_i = less_i ? p - 1 : digits[pos];
    int limit_j = less_j ? p - 1 : digits[pos];

    for (int i_d = 0; i_d <= limit_i; i_d++) {
        for (int j_d = 0; j_d <= limit_j; j_d++) {
            // Điều kiện Lucas Theorem: j_d <= i_d
            if (j_d <= i_d) {
                bool new_less_i = less_i || (i_d < limit_i);
                bool new_less_j = less_j || (j_d < limit_j);
                res += dfs(pos + 1, new_less_i, new_less_j);
            }
        }
    }
    return dp[pos][less_i][less_j] = res;
}

ll solve(ll n, int p_val) {
    if (n == 0) return 0;
    p = p_val;
    digits.clear();
    // Chuyển n thành chuỗi cơ số p
    while (n > 0) {
        digits.push_back(n % p);
        n /= p;
    }
    reverse(digits.begin(), digits.end());

    memset(dp, -1, sizeof(dp));
    // Kết quả là tổng số cặp (j, i) <= n thỏa mãn Lucas
    return dfs(0, false, false);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n, p;
    cin >> n >> p;

    ll total_pairs = 1LL * n * (n + 1) / 2;
    ll not_divisible = solve(n - 1, p); // Tính cho n-1

    cout << total_pairs - not_divisible << endl;
    return 0;
}

// Pseudo code
long long count = 0;
for (int i = 0; i < n; i++) {
    for (int j = 0; j <= i; j++) {
        if (C(i, j) % p == 0) count++;
    }
}
// Phải dùng BigInteger hoặc Lucas để check C(i, j) % p == 0