#include <fstream>
#include <map>
#include <cstring>

#define x first
#define y second

using namespace std;

typedef pair<int, int> Point;

const int MaxN = 805;

map<Point, int> H;
Point P[MaxN];
int N, G[MaxN], InDeg[MaxN];
int Sol[MaxN];
bool Used[MaxN];

inline void Rotate(Point &p, int k) {
    if (k == 0)
        return;
    int x = -p.y, y = p.x;
    p.x = x, p.y = y;
    Rotate(p, k-1);
}

inline void Shift(Point &p, int ShiftX, int ShiftY) {
    p.x += ShiftX, p.y += ShiftY;
}

void BuildGraph(int k, int ShiftX, int ShiftY) {
    memset(G, 0, sizeof(G)), memset(InDeg, 0, sizeof(InDeg));
    for (int i = 1; i <= N; ++i) {
        Point p = P[i];
        Rotate(p, k); Shift(p, ShiftX, ShiftY);
        if (H.find(p) != H.end())
            G[i] = H[p], ++InDeg[H[p]];
    }
}

int DFS(int X, int S) {
    if (X == 0 || Used[X])
        return 0;
    Used[X] = true, Sol[X] = S;
    return 1 + DFS(G[X], S^1);
}

bool BuildSol() {
    memset(Used, 0, sizeof(Used));
    for (int i = 1; i <= N; ++i)
        if (InDeg[i] == 0)
            if (DFS(i, 1) % 2 == 1)
                return false;
    for (int i = 1; i <= N; ++i)
        if (!Used[i] && InDeg[i] > 0)
            if (DFS(i, 1) % 2 == 1)
                return false;
    return true;
}

void Solve() {
    for (int k = 0; k < 4; ++k) {
        for (int i = 1; i <= N; ++i) {
            if (P[1] == P[i])
                continue;
            Point p = P[i]; Rotate(p, k);
            int ShiftX = P[1].x - p.x, ShiftY = P[1].y - p.y;
            BuildGraph(k, ShiftX, ShiftY);
            if (BuildSol())
                return;
        }
    }
}

void Read() {
    ifstream fin("overlap.in");
    fin >> N;
    for (int i = 1; i <= N; ++i) {
        fin >> P[i].x >> P[i].y;
        H[P[i]] = i;
    }
    fin.close();
}

void Print() {
    ofstream fout("overlap.out");
    for (int i = 1; i <= N; ++i)
        fout << Sol[i]+1 << "\n";
    fout.close();
}

int main() {
    Read();
    Solve();
    Print();
    return 0;
}