#include <fstream>
#include <stdlib.h>
#include <algorithm>
#include <math.h>
using namespace std;

ifstream fi ("overlap.in");
ofstream fo ("overlap.out");

const int dim = 802;
int N, D, R[dim], fr[dim], viz[dim], D1[dim], D2[dim];
struct coord { int x, y, i; } V[dim];

int cmp (coord a, coord b)
{
	if (a.x == b.x)
		return a.y < b.y;
	return a.x < b.x;
}

void cit ()
{
	int i, k;
	
	fi >> N;
	for (i = 1; i <= N; i++)
	{
		fi >> V[i].x >> V[i].y;
		V[i].i = i;
	}
	sort (V + 1, V + N + 1, cmp);
}

coord rot (coord c1, coord c2, coord c4)
{
	coord c3;
	c3.x = c2.x - c1.x;
	c3.y = c2.y - c1.y;
	switch (D)
	{
		case 0: c4.x +=  c3.x; c4.y +=  c3.y; break;
		case 1: c4.x += -c3.y; c4.y +=  c3.x; break;
		case 2: c4.x += -c3.x; c4.y += -c3.y; break;
		case 3: c4.x +=  c3.y; c4.y += -c3.x; break;
	}
	return c4;
}

int cauta (coord c1)
{
	int p = 1, u = N, m;
	while (p <= u)
	{
		m = (p + u) >> 1;
		if (c1.x == V[m].x)
		{
			if (c1.y == V[m].y)
				return m;
			if (c1.y > V[m].y)
				p = m + 1;
			else
				u = m - 1;
		}
		else 
		{
			if (c1.x > V[m].x)
				p = m + 1;
			else
				u = m - 1;
		}
	}
	return 0;
}

void back (int k)
{
	if (k - 1 == N >> 1)
	{
		for (int i = 1; i < k; i++)
		{
			R[V[D1[i]].i] = 1;
			R[V[D2[i]].i] = 2;
		}
		for (int i = 1; i <= N; i++)
			fo << R[i] << '\n';
		return;
	}
	
	int i, j;
	coord c1 = V[D1[k - 1]], c2;
	coord c3 = V[D2[k - 1]], c4;
	
	for (i = 1; i <= N && R[1] == 0; i++)
	{
		if (viz[i])
			continue;
		
		c2 = V[i];
		c4 = rot (c1, c2, c3);
		if (j = cauta (c4))
		{
			if (viz[j])
				continue;
			
			viz[i] ++;
			viz[j] ++;
			
			D1[k] = i;
			D2[k] = j;
			back (k + 1);
			
			viz[i] --;
			viz[j] --;
		}
	}
}

void rez ()
{
	D1[1] = 1;	
	viz[1] ++;
	for (int i = 2; i <= N; i++)
	{
		D2[1] = i;
		
		viz[i] ++;
		for (D = 0; D < 4; D++)
			back (2);
		viz[i] --;
	}
}

int main ()
{
	cit ();
	rez ();
	return 0;
}