#include <bits/stdc++.h>

using i64 = long long;

constexpr int S = 2.1e7;
struct Node {
    int l, r, v;
} seg[S];
int tot;
void modify(int &u, int l, int r, int p) {
    seg[++tot] = seg[u];
    u = tot;
    seg[u].v += 1;
    if (r - l == 1) {
        return;
    }
    int m = (l + r) / 2;
    if (p < m) {
        modify(seg[u].l, l, m, p);
    } else {
        modify(seg[u].r, m, r, p);
    }
}
int query(int u, int l, int r, int ql, int qr) {
    if (!u || r <= ql || qr <= l) {
        return 0;
    }
    if (ql <= l && r <= qr) {
        return seg[u].v;
    }
    int m = (l + r) / 2;
    return query(seg[u].l, l, m, ql, qr) + query(seg[u].r, m, r, ql, qr);
}

int main() {
    freopen("top.in", "r", stdin);
    freopen("top.out", "w", stdout);
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int n, E;
    std::cin >> n >> E;

    std::vector<int> a(n), b(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
    }
    for (int i = 0; i < n; ++i) {
        std::cin >> b[i];
    }

    std::vector<int> c(n);
    std::vector<i64> f(n + 1), sum(n + 1);
    for (int i = 0; i < n; ++i) {
        c[i] = std::min(a[i], b[i]);
        f[i + 1] = f[i] + -std::min(b[i] - a[i], 0);
        sum[i + 1] = sum[i] + b[i] - a[i];
    }

    auto v = sum;
    std::sort(v.begin(), v.end());
    v.erase(std::unique(v.begin(), v.end()), v.end());
    std::vector<int> s(n + 1);
    std::vector<int> root(n + 2);
    for (int i = 0; i <= n; ++i) {
        s[i] = std::lower_bound(v.begin(), v.end(), sum[i]) - v.begin();
        root[i + 1] = root[i];
        modify(root[i + 1], 0, int(v.size()), s[i]);
    }

    std::vector<int> lmin(n), rmin(n, n), stk{-1};
    for (int i = 0; i < n; ++i) {
        while (stk.back() != -1 && c[stk.back()] <= c[i]) {
            rmin[stk.back()] = i;
            stk.pop_back();
        }
        lmin[i] = stk.back();
        stk.push_back(i);
    }

    i64 ans = 0;
    for (int x = 0; x < n; ++x) {
        if (x - lmin[x] < rmin[x] - x) {
            for (int i = lmin[x] + 1; i <= x; ++i) {
                int j = std::upper_bound(f.begin(), f.end(), f[i] + E - c[x]) - f.begin();
                j = std::min(j, rmin[x] + 1);
                if (x + 1 < j) {
                    ans += query(root[j], 0, int(v.size()), s[i], int(v.size()));
                    ans -= query(root[x + 1], 0, int(v.size()), s[i], int(v.size()));
                }
            }
        } else {
            for (int i = x; i < rmin[x]; ++i) {
                int j = std::lower_bound(f.begin(), f.end(), f[i + 1] + c[x] - E) - f.begin();
                j = std::max(j, lmin[x] + 1);
                if (j <= x) {
                    ans += query(root[x + 1], 0, int(v.size()), 0, s[i + 1] + 1);
                    ans -= query(root[j], 0, int(v.size()), 0, s[i + 1] + 1);
                }
            }
        }
    }

    std::cout << ans << "\n";

    return 0;
}