#include <bits/stdc++.h>
#include <cassert>

using namespace std;

#define pb push_back
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()

pair<int, int> inters(pair<int, int> A, pair<int, int> B) {
    return {max(A.first, B.first), min(A.second, B.second)};
}

vector<pair<int, int>> solve2(int n, vector<array<int, 4>> a, int k) {
    int minright = 1e9 + 1, maxleft = -1, minup = 1e9 + 1, maxdown = -1;
    for (int i = 0; i < n; i++) {
        minright = min(minright, a[i][2]);
        maxleft = max(maxleft, a[i][0]);
        maxdown = max(maxdown, a[i][1]);
        minup = min(minup, a[i][3]);
    }
    vector<pair<int, int>> Ans;
    if (minright >= maxleft) {
        vector<int> used(n, 0);
        vector<pair<int, int>> ans;
        while (true) {
            int minu = 1e9 + 1, ps = -1;
            for (int i = 0; i < n; i++) {
                if (!used[i] && minu > a[i][3]) {
                    minu = a[i][3]; ps = i;
                }
            }
            if (ps == -1) break;
            ans.pb({minright, minu});
            for (int j = 0; j < n; j++) {
                if (a[j][1] <= minu && minu <= a[j][3]) {
                    used[j] = 1;
                } 
            }
        }
        for (auto u : ans) Ans.pb(u);
        for (int i = 0; i < k - sz(ans); i++) Ans.pb(ans[0]);
        return Ans;
    }
    if (minup >= maxdown) {
        vector<int> used(n, 0);
        vector<pair<int, int>> ans;
        while (true) {
            int minu = 1e9 + 1, ps = -1;
            for (int i = 0; i < n; i++) {
                if (!used[i] && minu > a[i][2]) {
                    minu = a[i][2]; ps = i;
                }
            }
            if (ps == -1) break;
            ans.pb({minu, minup});
            for (int j = 0; j < n; j++) {
                if (a[j][0] <= minu && minu <= a[j][2]) {
                    used[j] = 1;
                } 
            }
        }
        for (auto u : ans) Ans.pb(u);
        for (int i = 0; i < k - sz(ans); i++) Ans.pb(ans[0]);
        return Ans;
    }
    if (k <= 1) {
        return {{-1, -1}};
    }
    int posr = -1, posl = -1;
    for (int i = 0; i < n; i++) {
        if (a[i][2] == minright) posr = i;
        if (a[i][0] == maxleft) posl = i;
    }
    if (k <= 2) {
    vector<pair<int, int>> segs_left, segs_right;
    for (int i = 0; i < n; i++) {
        if (i != posl && i != posr) {
            auto lolleft = inters({a[posr][1], a[posr][3]}, {a[i][1], a[i][3]}), lolright = inters({a[posl][1], a[posl][3]}, {a[i][1], a[i][3]});
            auto LL = inters({a[posr][0], a[posr][2]}, {a[i][0], a[i][2]});
            if (LL.first > LL.second) {
                lolleft.first = lolleft.second + 1;
            }
            auto RR = inters({a[posl][0], a[posl][2]}, {a[i][0], a[i][2]});
            if (RR.first > RR.second) {
                lolright.first = lolright.second + 1;
            }
            segs_left.pb(lolleft);
            segs_right.pb(lolright);
        }
    }
//cout << minright << ' ' << maxleft << ' ' << posl << ' ' << posr << '\n';
    if (segs_left.size() == n - 2 && segs_right.size() == n - 2) {
        if (segs_left.empty()) {
            for (int i = 0; i < n; i++) Ans.pb({a[i][0], a[i][1]});
            for (int j = 0; j < k - n; j++)Ans.pb({a[0][0], a[0][1]});
            return Ans;
        }
        multiset<int> Ls, Rs;
        for (int i = 0; i < sz(segs_right); i++) {
            //cout << segs_right[i].first << ' ' << segs_right[i].second << '\n';
            Ls.insert(segs_right[i].first); Rs.insert(segs_right[i].second);
        }
        if (*Ls.rbegin() <= *Rs.begin()) {
            Ans.pb({minright, 1});
            Ans.pb({maxleft, *Ls.rbegin()});
            //cout << minright << ' ' << 1 << '\n' << maxleft << ' ' << *Ls.rbegin() << '\n';
            for (int jj = 0; jj < k - 2; jj++) Ans.pb({1, 1});
            return Ans;
        }
        vector<pair<int, int>> events;
        for (int i = 0; i < sz(segs_left); i++) {
            if (segs_left[i].first <= segs_left[i].second) {
                events.pb({segs_left[i].first, i});
                events.pb({segs_left[i].second + 1, i});
            }
        }
        sort(all(events));
        vector<int> usedd(sz(segs_left), 0);
        int i = 0;
        while (i < sz(events)) {
            int j = i;
            while (j < sz(events) && events[j].first == events[i].first) {
                if (usedd[events[j].second] == 1) {
                    Ls.insert(segs_right[events[j].second].first);
                    Rs.insert(segs_right[events[j].second].second);
                } else {
                    Ls.erase(Ls.find(segs_right[events[j].second].first));
                    Rs.erase(Rs.find(segs_right[events[j].second].second));
                    usedd[events[j].second] = 1;
                }
                j++;
            }
            if (Ls.empty() || *Ls.rbegin() <= *Rs.begin()) {
                assert(events[i].first <= 1000000000);
                Ans.pb({minright, events[i].first}); Ans.pb({maxleft, *Ls.rbegin()});
				int ev = events[i].first;
                for (int jj = 0; jj < k - 2; jj++) Ans.pb({1, 1});
                return Ans;
            }
            i = j;
        }
    }
    }
    if (k <= 2) {
        return {{-1, -1}};
    }

    auto check = [&](int i, int x, int y) -> bool {
        return a[i][0] <= x && x <= a[i][2] && a[i][1] <= y && y <= a[i][3];
    };

    auto check_inters = [&](int i, int j) {
        auto ix = inters({a[i][0], a[i][2]}, {a[j][0], a[j][2]}), iy = inters({a[i][1], a[i][3]}, {a[j][1], a[j][3]});
        return (ix.first <= ix.second && iy.first <= iy.second);
    };

    int posu = -1, posd = -1;
    for (int i = 0; i < n; i++) {
        if (a[i][1] == maxdown) posd = i;
        if (a[i][3] == minup) posu = i;
    }
    // posl - maxleft, posr - minright
    // if (posu == posl) {
    //     vector<array<int, 4>> newa;
    //     int curx = a[posu][0], cury = a[posu][3];
    //     for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
    //     Ans = solve2(sz(newa), newa, k - 1);
    //     Ans.pb({curx, cury});
    //     return Ans;
    // }
    // if (posu == posr) {
    //     vector<array<int, 4>> newa;
    //     int curx = a[posu][2], cury = a[posu][3];
    //     for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
    //     Ans = solve2(sz(newa), newa, k - 1);
    //     Ans.pb({curx, cury});
    //     return Ans;
    // }
    // if (posd == posr) {
    //     vector<array<int, 4>> newa;
    //     int curx = a[posd][2], cury = a[posd][1];
    //     for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
    //     Ans = solve2(sz(newa), newa, k - 1);
    //     Ans.pb({curx, cury});
    //     return Ans;
    // }
    // if (posd == posl) {
    //     vector<array<int, 4>> newa;
    //     int curx = a[posd][0], cury = a[posd][1];
    //     for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
    //     Ans = solve2(sz(newa), newa, k - 1);
    //     Ans.pb({curx, cury});
    //     return Ans;
    // }

    if (check_inters(posd, posr)) {
        vector<array<int, 4>> newa;
        int curx = a[posr][2], cury = a[posd][1];
        for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
        Ans = solve2(sz(newa), newa, k - 1);
        if (Ans[0].first != -1) {
            Ans.pb({curx, cury});
            return Ans;
        }
    }
    if (check_inters(posd, posl)) {
        vector<array<int, 4>> newa;
        int curx = a[posl][0], cury = a[posd][1];
        for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
        Ans = solve2(sz(newa), newa, k - 1);
        if (Ans[0].first != -1) {
            Ans.pb({curx, cury});
            return Ans;
        }
    }
    if (check_inters(posu, posl)) {
        vector<array<int, 4>> newa;
        int curx = a[posl][0], cury = a[posu][3];
        for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
        Ans = solve2(sz(newa), newa, k - 1);
        if (Ans[0].first != -1) {
            Ans.pb({curx, cury});
            return Ans;
        }
    }
    if (check_inters(posu, posr)) {
        vector<array<int, 4>> newa;
        int curx = a[posr][2], cury = a[posu][3];
        for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
        Ans = solve2(sz(newa), newa, k - 1);
        if (Ans[0].first != -1) {
            Ans.pb({curx, cury});
            return Ans;
        }
    }
    if (k <= 3) return {{-1, -1}};
    auto try_point = [&](int curx, int cury) -> vector<pair<int, int>> {
        vector<array<int, 4>> newa;
        for (int i = 0; i < n; i++) if (!check(i, curx, cury)) newa.pb(a[i]);
        vector<pair<int, int>> haha = solve2(sz(newa), newa, k - 1);
        if (haha[0].first != -1) {
            haha.pb({curx, cury});
        }
        return haha;
    };
    // {
    //     auto rs = try_point(a[posu][0], a[posu][3]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posu][2], a[posu][3]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posd][0], a[posd][1]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posd][2], a[posd][1]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posl][0], a[posl][3]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posl][0], a[posl][1]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posr][2], a[posr][1]);
    //     if (rs[0].first != -1) return rs;
    // }
    // {
    //     auto rs = try_point(a[posr][2], a[posr][3]);
    //     if (rs[0].first != -1) return rs;
    // }
    mt19937 rnd(time(NULL));
    vector<int> ids(n);
    iota(all(ids), 0);
    for (int i = 0; i < n; i++) swap(ids[i], ids[rnd()%(i+1)]);
    for (int i : ids) {
        if (!check_inters(i, posu)) continue;
        if (a[i][0] <= a[posu][0] && a[posu][2] <= a[i][2]) continue;

        if (a[i][0] >= a[posu][0] && a[i][0] <= a[posu][2]) {
            auto lol = try_point(a[i][0], a[posu][3]);
            if (lol[0].first != -1) return lol;
        }
        if (a[i][2] >= a[posu][0] && a[i][2] <= a[posu][2]) {
            auto lol2 = try_point(a[i][2], a[posu][3]);
            if (lol2[0].first != -1) return lol2;
        }
    }
    return {{-1, -1}};
}

void solve() {
    int n, k; cin >> n >> k;
    vector<array<int, 4>> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i][0] >> a[i][1] >> a[i][2] >> a[i][3];
        // left down right up
    }
    auto lol = solve2(n, a, k);
    assert(lol[0].first != -1);
    for (auto u : lol) cout << u.first << ' ' << u.second << '\n';
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else 
        cin.tie(0)->sync_with_stdio(false);
    #endif

    while (tt--) {
        solve();
    }
    return 0;
}