#include <bits/stdc++.h>

using namespace std;

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

struct pair_hash {
    template<class T1, class T2>
    size_t operator() (const pair<T1, T2> &p) const {
        return hash<T1>()(p.first)^hash<T2>()(p.second);
    }
};

const int NMAX = 8e2 + 2;
int N, x, y, prv[NMAX], nxt[NMAX], sol[NMAX];
pair<int,int> p[NMAX], init[NMAX];
unordered_map<pair<int,int>,int,pair_hash> match;

int main() {
    fin >> N;
    for(int i = 1; i <= N; ++i) {
        fin >> p[i].first >> p[i].second;
        match[init[i] = p[i]] = i;
    }
    // rotatie trigonometrica la 90 de grade: (-y, x)
    // rotatie in sensul acelor de ceasornic la 90 de grade: (y, -x)
    for(int rep = 0; rep < 4; ++rep) { // 4 variante de rotatie
        for(int i = 1; i <= N; ++i) { // rotatia
            swap(p[i].first, p[i].second);
            p[i].first *= -1;
        }
        for(int i = 2; i <= N; ++i) { // consideram fiecare punct pe rand ca s-ar obtine din punctul 1
            // astfel, am fixat translatia planului
            int diffx = init[i].first - p[1].first,
                diffy = init[i].second - p[1].second;
            for(int j = 1; j <= N; ++j)
                prv[j] = nxt[j] = sol[j] = 0;
            // verific daca exista un punct pe care sa-l translatez ca sa obtin p[j]
            for(int j = 1; j <= N; ++j) {
                auto it = match.find({p[j].first + diffx, p[j].second + diffy});
                if(it != match.end()) {
                    nxt[j] = it->second;
                    prv[it->second] = j;
                }
            }
            bool ok = true;
            // incerc sa construiesc solutia
            for(int j = 1; j <= N; ++j)
                if(!sol[j]) { // trebuie sa am doar cicluri pare(graf bipartit kinda)
                    int curr = j;
                    while(prv[curr] && prv[curr] != j)
                        curr = prv[curr];
                    bool colour = false;
                    while(curr && !sol[curr]) {
                        sol[curr] = colour + 1;
                        colour ^= 1;
                        curr = nxt[curr];
                    }
                    if(colour) { // ciclu impar
                        ok = false;
                        break;
                    }
                }
            if(ok) { // daca am gasit solutie o afisez si gata
                for(int j = 1; j <= N; ++j)
                    fout << sol[j] << '\n';
                return 0;
            }
        }
    }
}