#include "parks.h"
#include<bits/stdc++.h>

using namespace std;

typedef int ll;

struct DSU {
	vector<ll> p;
	DSU(ll n) {
		p.resize(n);
		for (ll i = 0; i < n; i++) {
			p[i] = i;
		}
	}
	ll get(ll a) {
		return (p[a] == a ? a : p[a] = get(p[a]));
	}
	void unite(ll a, ll b) {
		p[get(a)] = get(b);
	}
};

ll construct_roads(vector<ll> x, vector<ll> y) {
	ll n = x.size();
	map<pair<ll, ll>, ll> all;
	for (ll i = 0; i < n; i++) {
		all[make_pair(x[i], y[i])] = i;
	}
	vector<vector<ll>> to(n);
	vector<ll> m1;
	for (ll i = 0; i < n; i++) {
		bool bx = false, by = false;
		if (all.find(make_pair(x[i] + 2, y[i])) != all.end()) {
			bx = true;
			to[i].push_back(all[make_pair(x[i] + 2, y[i])]);
		}
		if (all.find(make_pair(x[i], y[i] + 2)) != all.end()) {
			by = true;
			to[i].push_back(all[make_pair(x[i], y[i] + 2)]);
		}
		if (all.find(make_pair(x[i] - 2, y[i])) != all.end()) {
			bx = true;
			to[i].push_back(all[make_pair(x[i] - 2, y[i])]);
		}
		if (all.find(make_pair(x[i], y[i] - 2)) != all.end()) {
			by = true;
			to[i].push_back(all[make_pair(x[i], y[i] - 2)]);
		}
		if (bx && by) {
			m1.push_back(i);
		}
	}
	set<pair<ll, ll>> have;
	vector<ll> u, v, a, b;
	DSU d(n);
	for (ll i = 0; i < n; i++) {
		for (auto j : to[i]) {
			d.unite(i, j);
			if (have.find(make_pair(j, i)) != have.end() || have.find(make_pair(i, j)) != have.end()) {
				continue;
			}
			u.push_back(i);
			v.push_back(j);
			have.emplace(i, j);
			ll bx = (x[i] + x[j]) / 2, by = (y[i] + y[j]) / 2;
			ll add = 1;
			if ((x[i] + y[i]) % 4 == 0) {
				add = -add;
			}
			if (x[i] == x[j]) {
				add = -add;
				if (y[i] < y[j]) {
					add = -add;
				}
				bx += add;
			} else {
				if (x[i] < x[j]) {
					add = -add;
				}
				by += add;
			}
			a.push_back(bx);
			b.push_back(by);
		}
	}
	set<ll> aa;
	for (ll i = 0; i < n; i++) {
		aa.insert(d.get(i));
	}
	if (aa.size() > 1) {
		return 0;
	}
	build(u, v, a, b);
	return 1;
}

#ifdef LOCAL
static void check(bool cond, string message) {
        if (!cond) {
                printf("%s\n", message.c_str());
                fclose(stdout);
                exit(0);
        }
}

static int n;
static bool build_called;
static int m;
static vector<int> _u, _v, _a, _b;

void build(vector<int> u, vector<int> v, vector<int> a, vector<int> b) {
        check(!build_called, "build is called more than once");
        build_called = true;
        m = u.size();
        check(int(v.size()) == m, "u.size() != v.size()");
        check(int(a.size()) == m, "u.size() != a.size()");
        check(int(b.size()) == m, "u.size() != b.size()");
        _u = u;
        _v = v;
        _a = a;
        _b = b;
}

int main() {
        assert(scanf("%d", &n) == 1);
        vector<int> x(n), y(n);
        for (int i = 0; i < n; i++) {
                assert(scanf("%d%d", &x[i], &y[i]) == 2);
        }
        fclose(stdin);

        build_called = false;
        const int possible = construct_roads(x, y);

        check(possible == 0 || possible == 1, "Invalid return value of construct_roads()");
        if (possible == 1) {
                check(build_called, "construct_roads() returned 1 without calling build()");
        } else {
                check(!build_called, "construct_roads() called build() but returned 0");
        }

        printf("%d\n", possible);
        if (possible == 1) {
                printf("%d\n", m);
                for (int j = 0; j < m; j++) {
                        printf("%d %d %d %d\n", _u[j], _v[j], _a[j], _b[j]);
                }
        }
        fclose(stdout);
        return 0;
}
#endif