#include<fstream>
#include<cstring>
#include<vector>
#include<queue>
using namespace std ;

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

#define maxn 200001

int N, M ;

vector<int> graf[maxn] ;

int val[maxn] ;
int start ;

bool ok ;

int start1, start2 ;

queue<int> coada ;

int check(int x)
{
    return 2 * N - x ;
}

void dfs()
{
    coada.push(start1) ;
    coada.push( check(start1) ) ;
    coada.push(start2) ;
    coada.push( check(start2) ) ;

    while( coada.empty() == false )
    {
        int NOD = coada.front() ;
        coada.pop() ;

        for(size_t i = 0; i < graf[NOD].size(); ++i )
        {
            int vecin = graf[NOD][i] ;

            if( val[vecin] > -1 )
            {
                if( val[vecin] == 0 && val[NOD] == 0 )
                {
                    ok = false ;
                    while( coada.empty() == false )
                        coada.pop() ;
                    return ;
                }
            }
            else
            {
                if( val[NOD] == 0 )
                {
                    val[vecin] = 1 ;
                    val[ check(vecin) ] = 0 ;

                    coada.push(vecin) ;
                    coada.push( check(vecin) ) ;
                }
            }
        }
    }
}

int main()
{
    fin >> N >> M ;

    for(int i = 0; i < M; ++i )
    {
        int x, y ;

        fin >> x >> y ;

        x += N ;
        y += N ;

        if( start1 == 0 )
            start1 = x ; start2 = y ;

        graf[x].push_back(y) ;
        graf[y].push_back(x) ;
    }

    memset( val, -1, sizeof(val) ) ;

    val[start1] = 1 ;
    val[ check(start1) ] = 0 ;
    val[start2] = 0 ;
    val[ check(start2) ] = 1 ;

    bool ok = true ;
    dfs() ;

    if( ok == true )
    {
        bool ver = true ;

        for(int i = 0; i <= 2 * N; ++i )
            for(size_t j = 0; j < graf[i].size(); ++j )
                if( val[i] + val[ graf[i][j] ] == -1 || ( val[i] == 0 && val[ graf[i][j] ] == 0 ) || val[i] + val[ graf[i][j] ] == -2 )
                {
                    ver = false ;
                    break ;
                }

        if( ver == true )
        {
            for(int i = N + 1; i <= 2 * N; ++i )
            {
                if( val[i] > -1 )
                    fout << val[i] << " " ;
                else
                    fout << "0 " ;
            }

            return 0 ;
        }
    }

        memset( val, -1, sizeof(val) ) ;

        val[start1] = 0 ;
        val[ check(start1) ] = 1 ;
        val[start2] = 1 ;
        val[ check(start2) ] ;

        ok = true ;
        dfs() ;

        if( ok == true )
        {
            bool ver = true ;

            for(int i = 0; i <= 2 * N; ++i )
                for(size_t j = 0; j < graf[i].size(); ++j )
                    if( val[i] + val[ graf[i][j] ] == -1 || ( val[i] == 0 && val[ graf[i][j] ] == 0 ) || val[i] + val[ graf[i][j] ] == -2 )
                    {
                        ver = false ;
                        break ;
                    }

            if( ver == true )
            {
                for(int i = N + 1; i <= 2 * N; ++i )
                {
                    if( val[i] > -1 )
                        fout << val[i] << " " ;
                    else
                        fout << "0 " ;
                }

                return 0 ;
            }
        }

    fout << "-1" ;

    return 0 ;
}