#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

long long div_up(long long a, long long b) {
    if (a >= 0)
        return (a + b - 1) / b;
    return a / b;
}


// line: (a,b) - ax+b, a.first < b.first
long long inter(const pair<long long, long long>& a, const pair<long long, long long>& b) {
    return div_up(a.second - b.second, b.first - a.first);
}

long long at(const pair<long long, long long>& line, long long x) {
    return line.first * x + line.second;
}

const long long INF = 1e18 + 1000;

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int n;
    long long m;
    cin >> n >> m;
    vector<pair<long long, long long>> as(n);
    vector<pair<long long, long long>> bs(n);
    for (int i = 0; i < n; ++i) {
        cin >> as[i].first >> as[i].second >> bs[i].first >> bs[i].second;
    }
    vector<long long> events;
    events.emplace_back(0);
    for (int i = 0; i < n; ++i) {
        if (as[i].second == bs[i].second)
            continue;
        if (as[i].second > bs[i].second) {
            if (bs[i].first >= as[i].first)
                events.emplace_back(div_up(bs[i].first - as[i].first, as[i].second - bs[i].second));
        } else {
            if (as[i].first >= bs[i].first) {
                events.emplace_back(div_up(as[i].first - bs[i].first, bs[i].second - as[i].second));
            }
        }
    }
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            if (as[i].second < as[j].second) {
                events.emplace_back(inter(make_pair(as[i].second, as[i].first), make_pair(as[j].second, as[j].first)));
            } else if (as[i].second > as[j].second) {
                events.emplace_back(inter(make_pair(as[j].second, as[j].first), make_pair(as[i].second, as[i].first)));
            }

            if (bs[i].second < bs[j].second) {
                events.emplace_back(inter(make_pair(bs[i].second, bs[i].first), make_pair(bs[j].second, bs[j].first)));
            } else if (bs[i].second > bs[j].second) {
                events.emplace_back(inter(make_pair(bs[j].second, bs[j].first), make_pair(bs[i].second, bs[i].first)));
            }
        }
    }

    for (int i = 0; i < events.size(); ++i) {
        if (events[i] < 0) {
            swap(events[i], events.back());
            events.pop_back();
            --i;
        }
    }

    sort(events.begin(), events.end());
    events.resize(unique(events.begin(), events.end()) - events.begin());
    while (events.back() > m)
        events.pop_back();
    events.emplace_back(m + 1);

    unsigned long long ans = 0;

    for (int i = 0; i + 1 < events.size(); ++i) {
        long long cur_time = events[i];
        long long to_time = events[i + 1];
        vector<int> order(n);
        iota(order.begin(), order.end(), 0);

        auto is_positive = [&](int i) {
            if (as[i].second == bs[i].second)
                return as[i].first < bs[i].first;
            if (as[i].second > bs[i].second) {
                return cur_time < div_up(bs[i].first - as[i].first, as[i].second - bs[i].second);
            }
            return cur_time >= div_up(as[i].first - bs[i].first, bs[i].second - as[i].second);
        };

        sort(order.begin(), order.end(), [&](int a, int b) {
            bool p1 = is_positive(a);
            bool p2 = is_positive(b);
            if (p1 && p2) {
                if (as[a].second == as[b].second)
                    return as[a].first < as[b].first;
                if (as[a].second > as[b].second)
                    return cur_time < div_up(as[b].first - as[a].first, as[a].second - as[b].second);
                return cur_time >= div_up(as[a].first - as[b].first, as[b].second - as[a].second);
            } else if (p1) {
                return true;
            } else if (p2) {
                return false;
            } else {
                if (bs[a].second == bs[b].second)
                    return bs[b].first > bs[b].first;
                if (bs[a].second > bs[b].second)
                    return cur_time >= div_up(bs[b].first - bs[a].first, bs[a].second - bs[b].second);
            }   return cur_time < div_up(bs[a].first - bs[b].first, bs[b].second - bs[a].second);
        });
        vector<pair<long long, long long>> lines;
        lines.emplace_back(0ll, 0ll);
        pair<long long, long long> cur(0ll, 0ll);
        for (int i : order) {
            lines.emplace_back(cur.first + as[i].second, cur.second + as[i].first);
            cur = make_pair(cur.first - bs[i].second + as[i].second, cur.second - bs[i].first + as[i].first);
        }


        sort(lines.begin(), lines.end(), [](const pair<long long, long long>& l1, const pair<long long, long long>& l2) {
            if (l1.first == l2.first)
                return l1.second > l2.second;
            return l1.first < l2.first;
        });

        vector<pair<long long, long long>> cht_lines;
        vector<long long> points;
        for (const pair<long long, long long>& line : lines) {
            if (cht_lines.empty()) {
                cht_lines.emplace_back(line);
                continue;
            }
            if (cht_lines.back().first == line.first)
                continue;
            while (!points.empty() && points.back() >= inter(cht_lines.back(), line)) {
                cht_lines.pop_back();
                points.pop_back();
            }
            points.emplace_back(inter(cht_lines.back(), line));
            cht_lines.emplace_back(line);
        }

        long long from = -INF;
        for (int i = 0; i < cht_lines.size(); ++i) {
            long long to = i + 1 == cht_lines.size() ? INF : points[i];

            if (max(from, cur_time) < min(to, to_time)) {
                long long a = max(from, cur_time);
                long long b = min(to, to_time) - 1;
                if ((a + b) % 2)
                    ans += uint64_t((b - a + 1) / 2) * (uint64_t(a + b) * uint64_t(cht_lines[i].first) + uint64_t(2 * cht_lines[i].second));
                else
                    ans += uint64_t(b - a + 1) * (uint64_t((a + b) / 2) * uint64_t(cht_lines[i].first) + uint64_t(cht_lines[i].second));
            }
            from = to;
        }
    }
    cout << ans << '\n';

    return 0;
}