#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map>
#define pb push_back
#define fi first
#define se second
#define mp make_pair

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 5e4 + 10, INF = 1e9;

int n, pre[N], pos[N];

struct P{
	int x, y, id;
	bool operator < (const P &b) const {
		if (y == b.y) return x < b.x;
		return y < b.y;
	}
} e[N];

PII inline max(PII x, PII y) {
	return x > y ? x : y;
}

void inline upd(PII &x, PII y) {
	if (y > x) x = y;
}

PII operator + (PII x, int y) {
	return mp(x.fi + y, x.se);
}

int a[N];

int head[N], numE = 1;

struct E{
	int next, v, w;
} g[(N + N * 3 * 2) * 2];


void inline addE(int u, int v, int w) {
	g[++numE] = (E) { head[u], v, w };
	head[u] = numE;
	g[++numE] = (E) { head[v], u, 0 };
	head[v] = numE;
}

void inline addEdge(int u, int v, int L, int U) {
	a[v] += L, a[u] -= L;
	addE(u, v, U - L);
}

void inline add(int u, int v) {
	++u, ++v;
	addEdge(u, v, 1, INF);
}

namespace t1{
	PII f[N], g[N], h[N], nf[N], ng[N];
	bool v1[N], v2[N], v3[N];
	map<int, PII> H, L, R;
	int Le[N], Re[N];
	map<int, int> X, Y, Z;
	void print(int x, int o) {
		int k = 0;
		int la = f[x].se, Lf = Le[la], Rf = Re[la];
		if (!x) return;
		if (!o) print(h[x].se, 1);
		else {
			if (f[x] == h[x]) print(f[x].se, 1);
			else {
				k = 1;
				print(f[x].se, 0);
			}
		}
		if (k) {
			if (la > x) {
				for (int i = la + 1; i <= Rf; i++) printf("%d ", pos[i]);
				for (int i = la - 1; i > x; i--) printf("%d ", pos[i]);	
			} else {
				for (int i = la - 1; i >= Lf; i--) printf("%d ", pos[i]);
				for (int i = la + 1; i < x; i++) printf("%d ", pos[i]);
			}
		}
		printf("%d ", pos[x]);
	}
	
	void inline work() {
		PII ans = mp(0, 0);
		L[0] = H[0] = R[0] = ans;
		for (int i = 1; i <= n; i++) {
			int j = i;
			while (j < n && e[j + 1].y == e[i].y) j++;
			PII v = mp(-INF, 0);
			for (int k = i; k <= j; k++) {
				Le[k] = i, Re[k] = j;
				int x = e[k].x, y = e[k].y;
				f[k] = g[k] = mp(-INF, 0);
				if (H.count(x)) upd(f[k], H[x] + 1);
				if (H[x] == mp(0, 0)) v1[k] = 1;
				if (L.count(x + y)) upd(f[k], L[x + y] + 1);
				if (L[x + y] == mp(0, 0)) v2[k] = 1;
				if (R.count(x - y)) upd(f[k], R[x - y] + 1);
				if (R[x - y] == mp(0, 0)) v3[k] = 1;
				upd(g[k], v + (k - i));
				upd(v, mp(f[k].fi, k));
			}
			v = mp(-INF, 0);
			for (int k = j; k >= i; k--) {
				int x = e[k].x, y = e[k].y;
				PII t = mp(f[k].fi, k);
				h[k] = f[k];
				g[k] = max(g[k], v + (j - k));
				upd(f[k], g[k]);
				v = max(v, t);
				H[x] = mp(f[k].fi, k);
				L[x + y] = mp(f[k].fi, k);
				R[x - y] = mp(f[k].fi, k);
				upd(ans, mp(f[k].fi, k));
			}
		
			i = j;
		}
		
		int Ans = ans.fi;
		
		printf("%d\n", Ans);
		print(ans.se, 1);
		puts("");
		L.clear(), H.clear(), R.clear();
		
		
		for (int j = n; j; j--) {
			int i = j;
			while (i > 1 && e[i - 1].y == e[j].y) i--;
			PII v = mp(-INF, 0);
			for (int k = i; k <= j; k++) {
				int x = e[k].x, y = e[k].y;
				nf[k] = mp(1, 0);
				ng[k] = mp(-INF, 0);
				if (H.count(x)) upd(nf[k], H[x] + 1);
				if (L.count(x + y)) upd(nf[k], L[x + y] + 1);
				if (R.count(x - y)) upd(nf[k], R[x - y] + 1);
				upd(ng[k], v + j);
				upd(v, mp(nf[k].fi - k, k));
			}
			v = mp(-INF, 0);
			for (int k = j; k >= i; k--) {
				int x = e[k].x, y = e[k].y;
				PII t = mp(nf[k].fi, k);
				ng[k] = max(ng[k], v + (-i));
				upd(nf[k], ng[k]);
				v = max(v, t + k);
				if (H.count(x) && H[x].fi + f[k].fi == Ans) add(k, H[x].se);
				if (L.count(x + y) && L[x + y].fi + f[k].fi == Ans) add(k, L[x + y].se);
				if (R.count(x - y) && R[x - y].fi + f[k].fi == Ans) add(k, R[x - y].se);
				if (nf[k].fi == Ans && ((x == 0 && v1[k]) || (x + y == 0 && v2[k]) || (x - y == 0 && v3[k]))) add(0, k);
				H[x] = mp(nf[k].fi, k);
				L[x + y] = mp(nf[k].fi, k);
				R[x - y] = mp(nf[k].fi, k);
				upd(ans, mp(nf[k].fi, k));
			}
		
			j = i;
		}
	}
}

namespace t2{
	int S, T;
	
	int q[N], d[N], cur[N];
	
	bool bfs() {
		int hh = 0, tt = 0;
		memset(d, 0, sizeof d);
		d[S] = 1, q[0] = S;
		while (hh <= tt) {
			int u = q[hh++]; cur[u] = head[u];
			if (u == T) return 1;
			for (int i = head[u]; i; i = g[i].next) {
				int v = g[i].v;
				if (!d[v] && g[i].w) {
					d[v] = d[u] + 1;
					q[++tt] = v;
				}
			}
		}
		return 0;
	}
	
	int dinic(int u, int flow) {
		if (u == T) return flow;
		int rest = flow;
		for (int i = cur[u]; i && rest; i = g[i].next) {
			cur[u] = i;
			int v = g[i].v;
			if (g[i].w && d[u] + 1 == d[v]) {
				int k = dinic(v, min(rest, g[i].w));
				if (!k) d[v] = 0;
				g[i].w -= k, rest -= k, g[i ^ 1].w += k;
			}
		}
		return flow - rest;
	}
	
	void inline work() {
		++n;
		int s, t;
		s = n + 1, t = n + 2;
		for (int i = 1; i <= n; i++) addE(s, i, INF), addE(i, t, INF);
		S = t + 1, T = S + 1;
		int tot = 0;
		for (int i = 1; i <= n; i++) {
			if (a[i] > 0) addE(S, i, a[i]);
			else if (a[i] < 0) addE(i, T, -a[i]);
		}
		addE(t, s, INF);
		int ans = 0, res;
		while (bfs())
			while (res = dinic(S, INF)) ans += res;
		ans = g[numE].w;
		g[numE].w = g[numE - 1].w = 0;
		S = t, T = s;
		while (bfs())
			while (res = dinic(S, INF)) ans -= res;//, cout << res << "???";
		printf("%d\n", ans); 
	}
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) scanf("%d%d", &e[i].x, &e[i].y), e[i].id = i;
	sort(e + 1, e + 1 + n);
	for (int i = 1; i <= n; i++) pos[i] = e[i].id;
	t1::work();	
	t2::work();
	return 0;
}