#include<bits/stdc++.h>
#define int ll
#define rep(i, a, b) for(int i = (a);i <= (b);++i)
#define per(i, a, b) for(int i = (a);i >= (b);--i)
#define lc (k << 1)
#define rc (k << 1 | 1)
#define lowbit(x) (x & (-x))
#define odd(x) ((x) & 1)
#define even(x) (!odd(x))
#define all(x) begin(x), end(x)
#define fir first
#define sec second
#define vc vector
#define ll long long
#define SZ(x) ((int)x.size())
#define pb push_back
#define il inline
#define pii pair<int, int>
#define pil pair<int, ll>
#define pli pair<ll, int>
#define pll pair<ll, ll>
#define debug(x) cerr << "In Line " << __LINE__ << " " << #x << " = " << x << "\n"
using namespace std;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3fll;
mt19937 rnd(time(0));
bool ms;

const int N = 2e5 + 5;
pll x[N], y[N];
int ans;
vc<int> vec;

il pll operator + (const pll& x, const pll& y) {
    return {x.fir + y.fir, x.sec + y.sec};
}

struct node {
    int l, r;
    pll mn, mx;
    ll uk;
} tr[N << 3];

void build(int k, int l, int r) {
    tr[k] = {l, r};
    if(l == r)
        return;
    int mid = l + r >> 1;
    build(lc, l, mid);
    build(rc, mid + 1, r);
}

il void lazy1(int k, ll x) {
    tr[k].uk += x;
}

il void lazy2(int k, pll x) {
    tr[k].mn = tr[k].mn + x;
}

il void lazy3(int k, pll x) {
    tr[k].mx = tr[k].mx + x;
}

il void update1(int k, int l, int r, int x) {
    if(l <= tr[k].l && tr[k].r <= r) {
        lazy1(k, x);
        return;
    }
    int mid = tr[k].l + tr[k].r >> 1;
    if(r <= mid)
        update1(lc, l, r, x);
    else if(l > mid)
        update1(rc, l, r, x);
    else {
        update1(lc, l, mid, x);
        update1(rc, mid + 1, r, x);
    }
}

il void update2(int k, int l, int r, pll x) {
    if(l <= tr[k].l && tr[k].r <= r) {
        lazy2(k, x);
        return;
    }
    int mid = tr[k].l + tr[k].r >> 1;
    if(r <= mid)
        update2(lc, l, r, x);
    else if(l > mid)
        update2(rc, l, r, x);
    else {
        update2(lc, l, mid, x);
        update2(rc, mid + 1, r, x);
    }
}

il void update3(int k, int l, int r, pll x) {
    if(l <= tr[k].l && tr[k].r <= r) {
        lazy3(k, x);
        return;
    }
    int mid = tr[k].l + tr[k].r >> 1;
    if(r <= mid)
        update3(lc, l, r, x);
    else if(l > mid)
        update3(rc, l, r, x);
    else {
        update3(lc, l, mid, x);
        update3(rc, mid + 1, r, x);
    }
}

il void push_down(int k) {
    lazy1(lc, tr[k].uk);
    lazy2(lc, tr[k].mn);
    lazy3(lc, tr[k].mx);
    lazy1(rc, tr[k].uk);
    lazy2(rc, tr[k].mn);
    lazy3(rc, tr[k].mx);
}

il bool chk(pll x, pll y, ll z) {
    if(!z)
        return 0;
    if(x.fir > y.fir)
        swap(x, y);
    return y.fir - x.sec <= z - 1;
}

il void dfs(int k) {
    if(tr[k].l == tr[k].r) {
        if(chk(tr[k].mn, tr[k].mx, tr[k].uk) || chk({tr[k].mn.fir + 1, tr[k].mn.sec + 1}, tr[k].mx, tr[k].uk))
            ans += vec[tr[k].l + 1] - vec[tr[k].l];
        return;
    }
    push_down(k);
    int mid = tr[k].l + tr[k].r >> 1;
    dfs(lc), dfs(rc);
}

void solve() {
    ans = 0;
    vec.clear();
    int n;
    cin >> n;
    rep(i, 1, n) {
        cin >> x[i].fir >> x[i].sec >> y[i].fir >> y[i].sec;
        vec.pb(y[i].fir);
        vec.pb(y[i].sec + 1);
    }
    vec.pb(0);
    vec.pb(inf);
    sort(all(vec));
    vec.erase(unique(all(vec)), vec.end());
    int m = SZ(vec) - 1;
    build(1, 0, m);
    rep(i, 1, n) {
        int l, r;
        l = lower_bound(all(vec), y[i].fir) - vec.begin();
        r = lower_bound(all(vec), y[i].sec + 1) - vec.begin();
        update1(1, l, r - 1, x[i].sec);
    }
    rep(i, 1, n) {
        int l, r;
        l = lower_bound(all(vec), y[i].fir) - vec.begin();
        r = lower_bound(all(vec), y[i].sec + 1) - vec.begin();
        update2(1, r, m, x[i]);
        update3(1, 0, l - 1, x[i]);
    }
    dfs(1);
    cout << ans << "\n";
}

bool mt;
signed main() {
    freopen("lucky.in", "r", stdin);
    freopen("lucky.out", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    cerr << fabs(&ms - &mt) / 1024 / 1024 << "\n";
    int c, t;
    cin >> c >> t;
    while(t--)
        solve();
    cerr << 1e3 * clock() / CLOCKS_PER_SEC << " ms\n";
    return 0;
}