#include<bits/stdc++.h>
#define int long long
#define ii pair<int,int>
#define ff first
#define ss second

using namespace std;
const int maxn = 2e5 + 5;
int n, m, t, cnt, timer;
int lz[maxn * 4];
tuple<int,int,int> events[maxn];
ii asn[4 * maxn];
int _t;
struct node{
    array<int, 2> col;
    int l, r;
    node(int val = 0)
    {
        l = r = val;
        col = {0, 0};
        if (val >= 0) col[val]++;
    }
    void rev()
    {
        l ^= 1; r ^= 1;
        swap(col[0], col[1]);
    }
};

node nothing(-1), seg[4 * maxn];;

bool check(node &a, node &b)
{
    return a.col == b.col && a.l == b.l && a.r == b.r;
}

node operator + (node a, node b)
{
    if (check(a, nothing)) return b;
    if (check(b, nothing)) return a;
    node c;
    c.l = a.l; c.r = b.r;
    c.col[0] = a.col[0] + b.col[0];
    c.col[1] = a.col[1] + b.col[1];
    if (a.r == b.l) c.col[a.r]--;
    return c;
}

void rev(int id)
{
    seg[id].rev();
    (lz[id] += 1) %= 2;
}

void down(int id)
{
    if (lz[id] == 0) return;
    rev(id * 2);
    rev(id * 2 + 1);
    lz[id] = 0;
}

void upd_rev(int lx, int rx, int id = 1, int l = 1, int r = n)
{
    if (lx > r || l > rx) return;
    if (lx <= l && r <= rx) return rev(id);
    down(id);
    int mid = (l + r) / 2;
    upd_rev(lx, rx, id * 2, l, mid);
    upd_rev(lx, rx, id * 2 + 1, mid + 1, r);
    seg[id] = seg[id * 2] + seg[id * 2 + 1];
}

node qry(int lx, int rx, int id = 1, int l = 1, int r = n)
{
    if (lx > r || l > rx) return nothing;
    if (lx <= l && r <= rx) return seg[id];
    int mid = (l + r) / 2;
    down(id);
    return qry(lx, rx, id * 2, l, mid) + qry(lx, rx, id * 2 + 1, mid + 1, r);
}

void upd_asn(int lx, int rx, ii val, int id, int l, int r)
{
    if (lx > r || l > rx) return;
    if (lx <= l && r <= rx)
    {
        asn[id] = val;
        return;
    }
    int mid = (l + r) / 2;
    upd_asn(lx, rx, val, id * 2, l, mid);
    upd_asn(lx, rx, val, id * 2 + 1, mid + 1, r);
}

ii getid(int pos, int id, int l, int r)
{
    if (l == r) return asn[id];
    int mid = (l + r) / 2;
    if (pos <= mid) return max(asn[id], getid(pos, id * 2, l, mid));
    return max(asn[id], getid(pos, id * 2 + 1, mid + 1, r));
}

int getid(int pos)
{
    return getid(pos, 1, 1, n).ss;
}

void upd_asn(int l, int r, int val)
{
    upd_asn(l, r, {++timer, val}, 1, 1, n);
}

int getl(int l, int r)
{
    int lx = l, rx = r, ans;
    while (lx <= rx)
    {
        int mid = (lx + rx) / 2;
        auto tmp = qry(l, mid);
        if (min(tmp.col[0], tmp.col[1]) == 0)
            ans = mid, lx = mid + 1;
        else rx = mid - 1;
    }
    return ans;
}

int getr(int l, int r)
{
    int lx = l, rx = r, ans;
    while (lx <= rx)
    {
        int mid = (lx + rx) / 2;
        auto tmp = qry(mid, r);
        if (min(tmp.col[0], tmp.col[1]) == 0)
            ans = mid, rx = mid - 1;
        else lx = mid + 1;
    }
    return ans;
}

void build(int id = 1, int l = 1, int r = n)
{
    if (l == r) {
        seg[id] = node(0);
        return;
    }
    int mid = (l + r) / 2;
    build(id * 2, l, mid);
    build(id * 2 + 1, mid + 1, r);
    seg[id] = seg[id * 2] + seg[id * 2 + 1];
}

signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
//    freopen("test.inp", "r", stdin);
//    freopen("test.out", "w", stdout);
    cin >> n >> t;
    for (int i = 1; i <= n; i++)
    {
        int u, v, x, y;
        cin >> u >> v >> x >> y;
        y--;
        events[u] = {v, y, 0};
        events[x] = {v, y, 1};
    }
    n *= 2;
    array<int, 2> ans = {0, 0};
    for (int i = 1; i <= n; i++)
    {
        _t = -1;
        auto [l, r, oc] = events[i];
        if (oc == 0)
        {
            upd_rev(l, r);
            auto tmp = qry(l, r);
            ans[0] += tmp.col[0];
            ans[1] += tmp.col[1];
            int u = getl(l, r);
            int v = getr(l, r);
            upd_asn(l, u, ++cnt);
            upd_asn(v, r, ++cnt);
        }
        else
        {
            upd_rev(l, r);
            auto tmp = qry(l, r);
            ans[0] += tmp.col[0];
            ans[1] += tmp.col[1];
            int u = getl(l, r), v = getr(l, r);
            upd_asn(l, u, ++cnt);
            upd_asn(v, r, ++cnt);
            if (min(tmp.col[0], tmp.col[1]) == 0)
            {
                int c = tmp.l;
                if (l > 1 && r < n && getid(l - 1) == getid(r + 1))
                {
                    ans[c]--;
                    upd_asn(l, r, getid(l - 1));
                }
                else
                {
                    int L = -1;
                    if (l > 1) L = getid(l - 1);
                    if (l > 1)
                    {
                        int v = getr(1, l - 1);
                        upd_asn(v, r, L);
                        ans[c]--;
                    }
                    if (r < n)
                    {
                        int v = getl(r + 1, n);
                        if (L != -1) upd_asn(l, v, L);
                        else upd_asn(l, v, getid(r + 1));
                        ans[c]--;
                    }
                }
            } else
            {
                if (l > 1)
                {
                    ans[tmp.l]--;
                    upd_asn(l, getl(l, r), getid(l - 1));
                }
                if (r < n)
                {
                    ans[tmp.r]--;
                    upd_asn(getr(l, r), r, getid(r + 1));
                }
            }
        }
    }
    if (t == 1) cout << ans[0] + ans[1] + 1;
    else cout << ans[0] + 1 << " " << ans[1];
}