#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <stack>

using namespace std;

typedef struct node{
    int index;
    int lowest;
} NODE;

int n,m;
int currentIndex = 1;
int currentStartedIndex;

NODE visitedOrder[200002];

vector<int> adjacencyList[200002];

int componentsNr = 0;
vector<int> components[200002];

int decidedValue[200002];

stack<int> st;

int getVariable(int a){
    return a-n;
}

int transformVariable(int a){
    return a+n;
}

int negateVariable(int a){
    return transformVariable(-getVariable(a));
}

int isNegative(int a){
    if (a<n){
        return 1;
    } else
        return 0;
}

void readData(){
    freopen("2sat.in", "r", stdin);
    freopen("2sat.out", "w", stdout);

    scanf("%d %d", &n, &m);

    int term1, term2;
    for (int i=0; i<m; i++){
        scanf("%d %d", &term1, &term2);

        term1 = transformVariable(term1);
        term2 = transformVariable(term2);

        adjacencyList[negateVariable(term1)].push_back(term2);
        adjacencyList[negateVariable(term2)].push_back(term1);
    }
    /*
        int a,b,na,nb;
      for (int i=1; i<=m; ++i)
    {
        scanf("%d %d", &a, &b);

        if (a < 0)
        {
            na = -a;
            a = na + n;
        }
        else
        {
            na = a + n;
        }

        if (b < 0)
        {
            nb = -b;
            b = -b + n;
        }
        else
        {
            nb = b + n;
        }

        adjacencyList[na].push_back (b);
        adjacencyList[nb].push_back (a);
    }

*/
}

int getMin(int a, int b){
    if (a<b){
        return a;
    }
    else
        return b;
}

void dfs(int currentNode){
    visitedOrder[currentNode].index = currentIndex;
    visitedOrder[currentNode].lowest = currentIndex;
    currentIndex++;

    //go through all of the adjacent nodes;
    for (int i=0; i<adjacencyList[currentNode].size(); i++){
        int nodeToBeVisited = adjacencyList[currentNode][i];

        if (visitedOrder[nodeToBeVisited].index == 0){
            st.push(nodeToBeVisited);
            dfs(nodeToBeVisited);
            visitedOrder[currentNode].lowest = getMin(visitedOrder[nodeToBeVisited].lowest, visitedOrder[currentNode].lowest);
        } else if (visitedOrder[nodeToBeVisited].index >= currentStartedIndex){
            visitedOrder[currentNode].lowest = getMin(visitedOrder[nodeToBeVisited].index, visitedOrder[currentNode].lowest);
        }
    }

    //check if a new connected component has been found
    if (visitedOrder[currentNode].index == visitedOrder[currentNode].lowest){
        int stackNode;

        do {
            stackNode = st.top();
            st.pop();

            components[componentsNr].push_back(stackNode);

        } while(stackNode != currentNode);

        componentsNr++;
    }

}


int main()
{
    readData();

    int ok = 1;

    for (int i=0; i<=2*n; i++){

        if (i!=n){
            if (!visitedOrder[i].index){
                currentStartedIndex = currentIndex;
                st.push(i);
                dfs(i);
            }
        }
    }

 //   printf("%d", componentsNr);


    for (int i=componentsNr-1; i>=0; i--){
        if (decidedValue[components[i][0]] != 1){
            for (int j=0; j<components[i].size(); j++){
                int currentNode = components[i][j];
                decidedValue[negateVariable(currentNode)] = 1;
            }
        }
    }

    for (int i=0; i<=n; i++){
        if (i != n && decidedValue[i] == decidedValue[negateVariable(i)]){
            ok = 0;
            break;
        }
    }

    if (ok){
        for (int i=n+1; i<=2*n; i++){
            printf("%d ", decidedValue[i]);
        }
    } else {
        printf("-1");
    }

    return 0;
}