#include <fstream>
#include <cstring>
#include <algorithm>

#define vint vector<Hash>::iterator
#define mod 666013

using namespace std;

ifstream fin ("overlap.in");
ofstream fout ("overlap.out");

int n;
struct point
{
    int x,y;
    int i;
}r[4][801],v[801];
int tr[801],viz[801],inv[801],cnt;
bool ok;

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

int bs (point s)
{
    int lo = 0, hi = n+1;

    while (hi - lo > 1)
    {
        int mid = (lo + hi)/2;

        if (v[mid].x == s.x)
        {
            if (v[mid].y <= s.y)
                lo = mid;
            else hi = mid;
        }
        else if (v[mid].x < s.x)
            lo = mid;
        else hi = mid;
    }

    if (lo != 0 && v[lo].x == s.x && v[lo].y == s.y)
        return v[lo].i;
    return 0;
}

void dfs(int x, int wh)
{
    ++cnt;
    viz[x] = wh + 1;

    if (tr[x] && !viz[tr[x]])
        dfs (tr[x],1-wh);
}

int main()
{
    fin>>n;

    for (int i=1; i<=n; ++i)
    {
        fin>>v[i].x>>v[i].y;
        v[i].i = i;

        r[0][i].x = v[i].x;
        r[0][i].y = v[i].y;
    }

    for (int k=1; k<4; ++k)
    {
        for (int i=1; i<=n; ++i)
        r[k][i].x = r[k-1][i].y,
        r[k][i].y = r[k-1][i].x,
        r[k][i].x = -r[k][i].x;
    }

    sort (v+1,v+n+1,cmp);

    for (int k=0; k<4; ++k)
    {
        for (int i=1; i<=n; ++i)
        {
            memset (tr,0,sizeof(tr));
            memset (inv,0,sizeof(inv));
            memset (viz,0,sizeof(viz));

            if (v[i].i == 1)
                continue;

            int shiftx = v[i].x - r[k][1].x;
            int shifty = v[i].y - r[k][1].y;

            tr[1] = v[i].i;
            inv[v[i].i] = 1;

            for (int j=2; j <= n; ++j)
            {
                point s;
                s.x = r[k][j].x + shiftx;
                s.y = r[k][j].y + shifty;

                tr[j] = bs (s);

                if (tr[j] != 0)
                    inv[tr[j]] = 1;
            }

            ok = 1;

            for (int j=1; j<=n; ++j)
            {
                if (!inv[j])
                {
                    cnt = 0;

                    dfs (j,0);

                    if (cnt&1)
                        ok = 0;
                }
            }

            for (int j=1; j<=n; ++j)
            {
                if (!viz[j])
                {
                    cnt = 0;
                    dfs (j,0);
                    if (cnt&1)
                        ok = 0;
                }
            }

            if (ok)
                break;
        }

        if (ok)
            break;
    }

    for (int i=1; i<=n; ++i)
        fout<<viz[i]<<"\n";
}