#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 2e5 + 5;
const int MAXD = 4 + 5;
const int C = 1e9;
const ll linf = 0x3f3f3f3f3f3f3f3f;

struct Rec
{
	int xl, xr, yl, yr;
	bool valid(void) const { return xl <= xr && yl <= yr;}
	bool isin(int x,int y) const { return xl <= x && x <= xr && yl <= y && y <= yr;}
	ll area(void) const { return (ll)(xr - xl + 1) * (yr - yl + 1);}
	void read_self(void){ scanf("%d%d%d%d",&xl,&yl,&xr,&yr);}
};

Rec operator + (const Rec &a,const Rec &b)
{
	return Rec{max(a.xl, b.xl), min(a.xr, b.xr), max(a.yl, b.yl), min(a.yr, b.yr)};
}

int n,d;
Rec p[MAXN], dat[MAXD];
bool valid[MAXN];

vector<int> solve1(vector<pii> vec)
{
	sort(vec.begin(), vec.end(), [] (pii x,pii y){
		return x.second < y.second;
	});
	
	vector<int> res;
	int lst = -C;
	for(pii t: vec) if(t.first > lst)
		res.push_back(lst = t.second);
	return res;
}

int dsc[MAXN * 2], dcnt = 0;

void print(int cur)
{
	for(int i=1; i<=cur; ++i)
		printf("%d %d\n",dsc[dat[i].xl],dsc[dat[i].yl]);
	for(int i=cur+1; i<=d; ++i)
		printf("1 1\n");
	exit(0);
}

void dfs(int cur)
{
	if(cur >= d) return;
	
	Rec lim = {-C, C, -C, C};
	for(int i=1; i<=n; ++i) if(!valid[i])
		lim = lim + p[i];
	if(lim.valid())
	{
		dat[++cur] = lim;
		print(cur);
	}
	
	if(lim.xl <= lim.xr)
	{
		vector<pii> vec;
		for(int i=1; i<=n; ++i) if(!valid[i])
			vec.emplace_back(p[i].yl, p[i].yr);
		vector<int> res = solve1(vec);
		if(cur + (int)res.size() > d) return;
		for(int y: res) dat[++cur] = {lim.xl, lim.xr, y, y};
		print(cur);
	}
	if(lim.yl <= lim.yr)
	{
		vector<pii> vec;
		for(int i=1; i<=n; ++i) if(!valid[i])
			vec.emplace_back(p[i].xl, p[i].xr);
		vector<int> res = solve1(vec);
		if(cur + (int)res.size() > d) return;
		for(int x: res) dat[++cur] = {x, x, lim.yl, lim.yr};
		print(cur);
	}
	
	auto chs = [&] (int x,int y)
	{
		vector<int> use;
		for(int i=1; i<=n; ++i)
			if(!valid[i] && p[i].isin(x,y))
				valid[i] = 1, use.push_back(i);
		if(!use.size()) return;
		dat[cur+1] = {x,x,y,y};
		dfs(cur+1);
		for(int i: use) valid[i] = 0;
	};
	
	chs(lim.xl, lim.yl);
	chs(lim.xr, lim.yl);
	chs(lim.xl, lim.yr);
	chs(lim.xr, lim.yr);
	
	assert(d == 4);
	while(1)
	{
		random_shuffle(p+1,p+n+1);
		dat[1] = {lim.xr, lim.xl, lim.yl, lim.yl};
		dat[2] = {lim.xr, lim.xl, lim.yr, lim.yr};
		dat[3] = {lim.xl, lim.xl, lim.yr, lim.yl};
		dat[4] = {lim.xr, lim.xr, lim.yr, lim.yl};
		
		bool ok = 1;
		for(int i=1; i<=n && ok; ++i)
		{
			int pos = -1;
			ll mndec = linf;
			for(int j=1; j<=d; ++j)
			{
				Rec nxt = dat[j] + p[i];
				if(!nxt.valid()) continue;
				ll dec = dat[j].area() - nxt.area();
				if(dec < mndec) pos = j, mndec = dec;
			}
			if(pos == -1)
			{
				ok = 0;
				break;
			}
			dat[pos] = dat[pos] + p[i];
		}
		
		if(ok) print(d);
	}
}

int main(void)
{
	srand((unsigned long long)new char ^ time(0));
	
	scanf("%d%d",&n,&d);
	for(int i=1; i<=n; ++i) p[i].read_self();
	
	for(int i=1; i<=n; ++i)
		dsc[++dcnt] = p[i].xl,
		dsc[++dcnt] = p[i].yl;
	sort(dsc+1,dsc+dcnt+1);
	dcnt = unique(dsc+1,dsc+dcnt+1) - dsc - 1;
	for(int i=1; i<=n; ++i)
	{
		p[i].xl = lower_bound(dsc+1,dsc+dcnt+1, p[i].xl) - dsc;
		p[i].yl = lower_bound(dsc+1,dsc+dcnt+1, p[i].yl) - dsc;
		p[i].xr = upper_bound(dsc+1,dsc+dcnt+1, p[i].xr) - dsc - 1;
		p[i].yr = upper_bound(dsc+1,dsc+dcnt+1, p[i].yr) - dsc - 1;
	}
	
	dfs(0);
	return 0;
}