#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using namespace std;

#define COMPRESS_NODES

struct rect
{
	int x0, x1, y0, y1;

	rect() {}
	rect(int x0, int x1, int y0, int y1)
	{
		this->x0 = x0;
		this->x1 = x1;
		this->y0 = y0;
		this->y1 = y1;
	}
	
	struct cmp
	{
		inline bool operator () (const rect& a, const rect& b) const
		{
			int cmp;
			if (cmp = a.x0 - b.x0) return cmp < 0;
			if (cmp = a.x1 - b.x1) return cmp < 0;
			if (cmp = a.y0 - b.y0) return cmp < 0;
			if (cmp = a.y1 - b.y1) return cmp < 0;
			return false;
		}
	};

	inline void mergewith(const rect& other)
	{
		x0 = min(x0, other.x0);
		x1 = max(x1, other.x1);
		y0 = min(y0, other.y0);
		y1 = max(y1, other.y1);
	}

	inline bool contains(const rect& other) const
	{
		return
			x0 <= other.x0 && other.x1 <= x1 &&
			y0 <= other.y0 && other.y1 <= y1;
	}

	inline bool intersects(const rect& other) const
	{
		const bool empty_intersection =
			x1 <= other.x0 || other.x1 <= x0 ||
			y1 <= other.y0 || other.y1 <= y0;
		return !empty_intersection;
	}
};

struct node
{
	node* children[4];
	int rectid;

	node()
	{
		children[0] = 0;
		children[1] = 0;
		children[2] = 0;
		children[3] = 0;
		rectid = -1;
	}
};

struct nodepool
{
	vector<node*> pool;

	node* alloc()
	{
		if (pool.empty())
		{
			const int chunksize = 10000;

			node* chunk = (node*) malloc(sizeof(node) * chunksize);
			for (int i = 0; i < chunksize; i++)
				pool.push_back(chunk + i);
		}

		node* new_node = new(pool.back()) node();
		pool.pop_back();
		return new_node;
	}

	void free(node* n)
	{
		pool.push_back(n);
	}
};

struct quadtree
{
	static const int min_coord = 0;
	static const int max_coord = 1 << 20;

	nodepool nodes;
	node* root;
	rect rootbounds;

	map<int, rect> rectmap;
	int rectidgen;

	quadtree()
	{
		root = nodes.alloc();

		rootbounds.x0 = min_coord;
		rootbounds.x1 = max_coord;
		rootbounds.y0 = min_coord;
		rootbounds.y1 = max_coord;

		rectidgen = 0;
	}

	void add()
	{
		rect r;
		cin >> r.x0 >> r.x1 >> r.y0 >> r.y1;
		merge(r);
	}

	rect curr;
	int foundid;

	void merge(rect& r)
	{
		while (1)
		{
			if (!find(r))
			{
				add(r);
				return;
			}

			const rect& found = rectmap[foundid];
			r.mergewith(found);
			remove(found);
			rectmap.erase(foundid);
		}
	}

	bool find(const rect& r)
	{
		curr = r;
		return find(root, rootbounds);
	}

	inline bool in0(int x2, int y2) const
	{
		return curr.x0 < x2 && curr.y0 < y2;
	}
	inline bool in1(int x2, int y2) const
	{
		return curr.x1 > x2 && curr.y0 < y2;
	}
	inline bool in2(int x2, int y2) const
	{
		return curr.x0 < x2 && curr.y1 > y2;
	}
	inline bool in3(int x2, int y2) const
	{
		return curr.x1 > x2 && curr.y1 > y2;
	}

	bool find(node* n, const rect& bounds)
	{
		if (n->rectid != -1)
		{
			foundid = n->rectid;
#ifdef COMPRESS_NODES
			const rect& found = rectmap[foundid];
			return found.intersects(curr);
#else
			return true;
#endif
		}

		if (bounds.x0 + 1 == bounds.x1)
			return false;

		const int x2 = (bounds.x0 + bounds.x1) >> 1;
		const int y2 = (bounds.y0 + bounds.y1) >> 1;

		if (n->children[0] && in0(x2, y2) &&
			find(n->children[0], rect(bounds.x0, x2, bounds.y0, y2)))
			return true;
		if (n->children[1] && in1(x2, y2) &&
			find(n->children[1], rect(x2, bounds.x1, bounds.y0, y2)))
			return true;
		if (n->children[2] && in2(x2, y2) &&
			find(n->children[2], rect(bounds.x0, x2, y2, bounds.y1)))
			return true;
		if (n->children[3] && in3(x2, y2) &&
			find(n->children[3], rect(x2, bounds.x1, y2, bounds.y1)))
			return true;

		return false;
	}

	void add(const rect& r)
	{
		rectidgen++;
		rectmap[rectidgen] = r;
		curr = r;
		add(root, rootbounds);
	}

	inline void addchild(node* n, int childindex, const rect& bounds)
	{
		if (!n->children[childindex])
			n->children[childindex] = nodes.alloc();
		add(n->children[childindex], bounds);
	}

	void add(node* n, const rect& bounds)
	{
#ifdef COMPRESS_NODES
		const int x2 = (bounds.x0 + bounds.x1) >> 1;
		const int y2 = (bounds.y0 + bounds.y1) >> 1;

		if (n->rectid != -1)
		{
			const rect prevcurr = curr;
			const int prevrectidgen = rectidgen;

			curr = rectmap[n->rectid];
			rectidgen = n->rectid;
			if (in0(x2, y2)) addchild(n, 0, rect(bounds.x0, x2, bounds.y0, y2));
			if (in1(x2, y2)) addchild(n, 1, rect(x2, bounds.x1, bounds.y0, y2));
			if (in2(x2, y2)) addchild(n, 2, rect(bounds.x0, x2, y2, bounds.y1));
			if (in3(x2, y2)) addchild(n, 3, rect(x2, bounds.x1, y2, bounds.y1));
			curr = prevcurr;
			rectidgen = prevrectidgen;

			n->rectid = -1;
		}
		else if (!n->children[0] && !n->children[1] && !n->children[2] && !n->children[3])
		{
			n->rectid = rectidgen;
			return;
		}

		if (in0(x2, y2)) addchild(n, 0, rect(bounds.x0, x2, bounds.y0, y2));
		if (in1(x2, y2)) addchild(n, 1, rect(x2, bounds.x1, bounds.y0, y2));
		if (in2(x2, y2)) addchild(n, 2, rect(bounds.x0, x2, y2, bounds.y1));
		if (in3(x2, y2)) addchild(n, 3, rect(x2, bounds.x1, y2, bounds.y1));
#else
		if (curr.contains(bounds))
		{
			n->rectid = rectidgen;
			return;
		}

		const int x2 = (bounds.x0 + bounds.x1) >> 1;
		const int y2 = (bounds.y0 + bounds.y1) >> 1;

		if (in0(x2, y2)) addchild(n, 0, rect(bounds.x0, x2, bounds.y0, y2));
		if (in1(x2, y2)) addchild(n, 1, rect(x2, bounds.x1, bounds.y0, y2));
		if (in2(x2, y2)) addchild(n, 2, rect(bounds.x0, x2, y2, bounds.y1));
		if (in3(x2, y2)) addchild(n, 3, rect(x2, bounds.x1, y2, bounds.y1));
#endif
	}

	void remove(const rect& r)
	{
		curr = r;
		remove(root, rootbounds);
	}
	
	inline void removechild(node* n, int childindex, const rect& bounds)
	{
		if (n->children[childindex])
		{
			if (remove(n->children[childindex], bounds))
				n->children[childindex] = 0;
		}
	}

	bool remove(node* n, const rect& bounds)
	{
		bool doremove = false;
		if (n->rectid != -1)
		{
			doremove = true;
		}
		else
		{
			const int x2 = (bounds.x0 + bounds.x1) >> 1;
			const int y2 = (bounds.y0 + bounds.y1) >> 1;

			if (n->children[0] && in0(x2, y2))
				removechild(n, 0, rect(bounds.x0, x2, bounds.y0, y2));
			if (n->children[1] && in1(x2, y2))
				removechild(n, 1, rect(x2, bounds.x1, bounds.y0, y2));
			if (n->children[2] && in2(x2, y2))
				removechild(n, 2, rect(bounds.x0, x2, y2, bounds.y1));
			if (n->children[3] && in3(x2, y2))
				removechild(n, 3, rect(x2, bounds.x1, y2, bounds.y1));
			
			doremove = true;
			for (int i = 0; i < 4; i++)
				if (n->children[i])
				{
					doremove = false;
					break;
				}
		}

		if (n == root)
		{
			n->rectid = -1;
			return false;
		}

		if (doremove)
			nodes.free(n);
		return doremove;
	}
};

quadtree tree;

int main()
{
	int n;
	cin >> n;

	for (int i = 0; i < n; i++)
	{
//		if (!(i % 10000))
//			printf("%d...\n", i);
		tree.add();
	}

	vector<rect> rvec;
	rvec.reserve(tree.rectmap.size());
	for (map<int, rect>::iterator it = tree.rectmap.begin(), end = tree.rectmap.end(); it != end; ++it)
		rvec.push_back(it->second);
	sort(rvec.begin(), rvec.end(), rect::cmp());

	cout << rvec.size() << endl;
	for (vector<rect>::iterator it = rvec.begin(), end = rvec.end(); it != end; ++it)
		cout << it->x0 << " " << it->x1 << " " << it->y0 << " " << it->y1 << endl;

	return 0;
}