#include <bits/stdc++.h>

struct Frac {
    int64_t a, b, c, d;
    // (ax + b) / (cx + d)

    Frac() {
        a = d = 1;
        b = c = 0;
    }

    Frac(int64_t a, int64_t b, int64_t c, int64_t d) : a(a), b(b), c(c), d(d) { ; }

    std::pair<int64_t, int64_t> get(int x, int y) const {
        return {a * x + b * y, c * x + d * y};
    }

    int64_t get_max(int x, int y) const {
        auto [a, b] = get(x, y);
        return std::max(a, b);
    }
};

Frac comp(const Frac& l, const Frac& r) {
    Frac res = {
        int(l.a) * 1LL * int(r.a) + int(l.b) * 1LL * int(r.c),
        int(l.a) * 1LL * int(r.b) + int(l.b) * 1LL * int(r.d),
        int(l.c) * 1LL * int(r.a) + int(l.d) * 1LL * int(r.c),
        int(l.c) * 1LL * int(r.b) + int(l.d) * 1LL * int(r.d)};

    return res;
}

int n, m, N;
int64_t ans;

int64_t dfs2_calls = 0;

bool dfs2(int p, int q, int x, const Frac& f) {
    dfs2_calls++;

    if (p + 2LL * x * q > N) {
        return false;
    }
    auto [a0, b0] = f.get(p + 2 * x * q, q);
    {
        if (std::max(a0, b0) > N || std::min(a0, b0) > std::min(n, m)) {
            return false;
        }
    }

    int p1 = f.a * q, p2 = f.a * p + f.b * q;
    int q1 = f.c * q, q2 = f.c * p + f.d * q;

    int64_t dlt = 0;
    for (auto [n, m] : std::array{std::pair{::n, ::m}, std::pair{::m, ::n}}) {
        int r1 = n - p2 - p1 * 2 * x;
        int r2 = m - q2 - q1 * 2 * x;

        if (std::min(r1, r2) >= 0) {
            r1 = p1 == 0 ? int(1e9) : r1 / (2 * p1) + 1;
            r2 = q1 == 0 ? int(1e9) : r2 / (2 * q1) + 1;
            int dt = std::min(r1, r2);
            dlt += dt;
        }
    }

    // std::cerr << dlt << " ";
    ans += dlt;

    for (int k = 1; a0 + 2 * k * b0 <= N; k++) {
        int x2 = std::max(x, k);

        if (!dfs2(p, q, std::max(x, k), comp(Frac(0, 1, 1, 2 * k), f))) {
            break;
        }
    }
    return true;
}

bool dfs1(int a, int b, int x = 0) {
    if (std::max(a, b) > N) {
        return false;
    }
    // if (a + 2LL * (x + 1) * b > N) {
    //     return false;
    // }
    if (!dfs2(a, b, x + 1, Frac(0, 1, 1, 0))) {
        return false;
    }
    for (int k = 1; a + 2 * k * b <= N && b + 2LL * (std::max(x, k) + 1) * (a + 2 * k * b) <= N; k++) {
        if (!dfs1(b, a + 2 * k * b, std::max(x, k))) {
            break;
        }
    }
    return true;
}

int32_t main() {
    n = m = 3e7;
    std::cin >> n >> m;

    N = std::max(n, m);

    dfs1(0, 1, 0);

    std::cout << ans << "\n";
    std::cerr << dfs2_calls / 1e6 << " M\n";

    return 0;
}