/// @title: Count non negative integer tuple (a, b, c) satisfied (sum <= S) and (product <= T)
/// @testing: for large S <= 1e18, T <= 1e12
/// > in O(T^(2/3)) time complexity = 830ms codeforces = 310ms ideone
/// > in O(const) memory complexity
/// > in O(3700Mb) code memory in 200 lines, 4444 characters
///
/// @date:    23/08/2021
/// @link:    https://ideone.com/yMi8tu
/// @author:  SPyofgame
/// @lisence: free lisence

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")

#include <iostream>
#include <cmath>

typedef long long ll;
const int MOD = 1e9 + 7;

///====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====*====

/// Utility function
ll min(ll a, ll b) { return a < b ? a : b; }
ll max(ll a, ll b) { return a > b ? a : b; }
ll square(ll x) { return x * x; }

/// Sum of (1 + 2 + ... + x)
ll natural_sum(ll x)
{
    return (x <= 0) ? 0 : x * (x + 1) / 2;
}

/// Sum of (l + (l + 1) + ... + r)
ll natural_sum(ll l, ll r)
{
    return (l > r) ? 0 : natural_sum(r) - natural_sum(l - 1);
}

/// Sigma(p = y -> x) floor(n / p) in O(cbrt(n))
/// @link: https://arxiv.org/pdf/1206.3369.pdf
/// @author: Richard Sladkey
ll fastsumdiv(ll y, ll x, ll n)
{
    if (y > x) return 0;

    ll S = 0;
    ll B = n / (x + 1);
    ll E = n % (x + 1);
    ll D = n / x - B;
    ll G = B - x * D;
    ll d = 0;

    for (; x >= y; --x)
    {
        E += G;
        if (E >= x)
        {
            D += 1, G -= x, E -= x;
            if (E >= x)
            {
                D += 1, G -= x, E -= x;
                if (E >= x) break; /// not likely to happen more
            }
        }
        else if (E < 0)
        {
            D -= 1, G += x, E += x;
        }

        G += 2 * D, B += D, S += B;
    }

    E = n % (x + 1);
    D = n / x - B;
    G = B - x * D;
    for (; x >= y; --x)
    {
        E += G;
        d = E / x;
        D += d;
        E -= x * d;
        G += 2 * D - x * d, B += D, S += B;
    }

    for (; x >= y; --x)
    {
        S += n / x;
    }

    return S;
}

/// you can modify to -> Bignum / Modulo / Overflow
void add(ll &res, ll val)
{
    val %= MOD;
    res += val;
    if (res >= MOD) res -= MOD;
}

/// you can modify to -> Bignum / Modulo / Overflow
void sub(ll &res, ll val)
{
    val %= MOD;
    res -= val;
    if (res < 0) res += MOD;
}

/// Count (a, b, c) satisfied
/// { min(a, b, c) >= 0
/// { a + b + c <= S
/// { a * b * c <= T
/// O(cbrt(T)^2) complexity
///
/// @proof: https://math.stackexchange.com/questions/4230187/faster-algorithm-for-counting-non-negative-tripplea-b-c-satisfied-a-b-c
/// @author: SPyofgame
ll solve_ABC(ll S, ll T)
{
    ll cbT = cbrt(T); /// Not very accuracy
    while (cbT * cbT * cbT < T) ++cbT;
    while (cbT * cbT * cbT > T) --cbT;



/// [1] 0 <= a < b < c && a <= cbrt(T) -> cnt1 * 6
    ll cnt1 = 0;
    add(cnt1, (S / 2) * S - 2 * natural_sum(S / 2)); /// a = 0

    ll k = 1;
    for (ll a = 1, upa = min(S, cbT); a <= upa; ++a) /// a > 0 -> count(b < c)
    {
        ll SSS = S - a;
        ll TTT = T / a;
        ll KKK = min(SSS / 2, min((ll)sqrt(TTT), TTT / 2 + 1));

        /// Binary search for max k satisfy (S - a - k) <= (T / a / k)
        ll k = a;
        for (ll l = a + 1, r = KKK; l <= r; )
        {
            ll m = (l + r) >> 1;
            ll v = TTT / m;
            if (SSS - m <= v)
            {
                k = m;
                l = m + 1;
            }
            else
            {
                r = m - 1;
            }
        }

        sub(cnt1, natural_sum(a + 1, KKK));
        add(cnt1, SSS * (k - a) - natural_sum(a + 1, k));
        add(cnt1, fastsumdiv(k + 1, KKK, TTT));
    }



/// [2] 0 <= a < b = c && a <= cbrt(T) -> cnt2 * 3
    ll cnt2 = 0;
    add(cnt2, S / 2); /// a = 0
    for (ll a = 1, upa = min(S, cbT); a <= upa; ++a) /// a > 0 -> count(b = c)
    {
        add(cnt2, max(0LL, min((S - a) / 2, ll(floor(sqrt(T / a)))) - a));
    }



/// [3] 0 <= a = b < c && a <= cbrt(T) -> cnt3 * 3
    ll cnt3 = 0;
    add(cnt3, S); /// a = 0
    for (ll a = 1, upa = min(S / 2, cbT); a <= upa; ++a) /// a > 0 -> count(a < c)
    {
        add(cnt3, max(0LL, min(S - a - a, T / a / a) - a));
    }



/// [4] 0 <= a = b = c && a <= cbrt(T) -> cnt4 * 1
    ll cnt4 = 0;
    add(cnt4, min(S / 3, cbT) + 1); /// a = b = c >= 0



/// Final result: total counting
    ll res = 0;
    add(res, cnt1 * 6 + cnt2 * 3 + cnt3 * 3 + cnt4 * 1);
    return res;
}

/// Main function
int main()
{
	/// Input any number 0 <= S, T <= 1e18
    std::cout << solve_ABC(1000000000000000000LL, 1000000000000LL);
    return 0;
}