#include <iostream>
#include <fstream>

using namespace std;

ifstream fin("2sat.in");
ofstream fout("2sat.out");

struct Nod{
    int val;
    Nod *next;
};


class Lista{
    Nod *v;
    int last;
public:

    Lista(){
        last = 0;
    }

    void push(int i);
    int pop();
    Nod* getHead();
};

void Lista::push(int i){
    Nod *q = new Nod();
    q->val = i;
    q->next = v;
    v = q;
}

int Lista::pop(){
    if(v == NULL)return -1;

    int q = v->val;
    v = v->next;

    return q;
}

Nod *Lista::getHead(){
    return v;
}

inline int getPositive(int &n, int &i){
    return i+n;
}

inline int getNegative(int &n, int &i){
    return 2*n-i;
}


struct Graph{
    Lista a[200004];
    int n, m;

    Graph();

    void add(int , int);

    Graph transpus();

    friend inline int getPositive(int&, int&);
    friend inline int getNegative(int&, int&);
};

Graph Graph::transpus(){
    Graph gt;

    gt.n = n;
    gt.m = m;

    for(int i=0; i<=2*n; i++){
        if(i == n)continue;
        /*
        for(int j=0; j<a[i].getLenght(); j++){
            gt.a[a[i].get(j)].add(i);
        }*/

        Nod *c = a[i].getHead();

        while(c){
            gt.a[c->val].push(i);
            c = c->next;
        }

    }
    return gt;
}

Graph::Graph(){

}

void Graph::add(int nod, int v){
    nod = getPositive(n, nod);
    v   = getPositive(n, v);

    int c = getNegative(n, nod);
    int d = getNegative(n, v);

    a[getNegative(n, v)].push(nod);
    a[getNegative(n, nod)].push(v);
}

void read(Graph &g){
    fin>>g.n>>g.m;

    int x, y;
    for(int i=1; i<=g.m; i++){
        fin>>x>>y;

        g.add(x, y);
    }
}

bool viz[128];

void setEmptyViz(){
    for(int i=0; i<128; i++)viz[i] = false;
}

void DFS(Graph &g, Lista &c, int nod){
    viz[nod] = true;
    /*
    for(int i=0; i<g.a[nod].getLenght(); i++){
        if(!viz[g.a[nod].get(i)]){
            DFS(g, c, g.a[nod].get(i));
        }
    }*/

    Nod *d = g.a[nod].getHead();

    while(d){
        if(!viz[d->val]){
            DFS(g, c, d->val);
        }
        d = d->next;
    }

    c.push(nod);
}

int c[128];
bool atrib[128];


void DFS_Transpus(Graph &gt, int nod, int t){
    c[nod] = t;
    atrib[nod] = false;
    atrib[getNegative(gt.n, nod)] = true;
    /*
    for(int i=0; i<gt.a[nod].getLenght(); i++){
        if(!c[gt.a[nod].get(i)]){
            DFS_Transpus(gt, gt.a[nod].get(i), t);
        }
    }*/

    Nod *d = gt.a[nod].getHead();

    while(d){
        if(!c[d->val]){
            DFS_Transpus(gt, d->val, t);
        }
        d = d->next;
    }
}

void getHardConex(Graph &gt, Lista &l){
    int t = 1;
    for(int i=0; i<=gt.n*2; i++){
        if(i == gt.n)continue;

        int x = l.pop();

        if(!c[x]){
            DFS_Transpus(gt, x, t);
            t++;
        }
    }
}


int main(){
    Graph g;
    Lista q, d;

    read(g);

    setEmptyViz();

    for(int i=0; i<=2*g.n; i++){
        if(i == g.n)continue;

        if(!viz[i])
            DFS(g, q, i);
    }

    d = q;

    Graph gt = g.transpus();

    getHardConex(gt, q);

    for(int i=0; i<=2*g.n; i++){
        if(i == g.n)continue;

        if(c[getNegative(g.n, i)] == c[i]){
            fout<<-1<<'\n';
            return 0;
        }
    }

    for(int i=0; i<g.n; i++){
        fout<<atrib[i]<<' ';
    }
    fout<<'\n';


}