#include <bits/stdc++.h>

using namespace std;

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

#define cin fin
#define cout fout
#define PB push_back
#define FR( a, b ) for( int a = 0; a < b; a ++ )
#define FOR( a, c, b ) for( int a = c;  a < b; a ++ )

const int Nmax = 2e5 + 5;
int n, cnt = - 1;

bool processed[Nmax], adevar[Nmax];
vector<int> in[Nmax], out[Nmax], comp_sortate;
vector< vector<int> > comp;
vector<int> dependenti[Nmax];
int componenta[Nmax], deg_componenta[Nmax];
int lista[Nmax];
queue<int> q;

int negare( int nod ) {
  return ( nod + n ) % ( 2 * n );
}

void dfs1( int nod ) {
  if( processed[nod] )
    return;

  processed[nod] = true;
  FR( i, (int) out[nod].size() ) {
    int u = out[nod][i];
    dfs1( u );
  }

  lista[++cnt] = nod;
}

void dfs2( int nod ) {
  if( processed[nod] )
    return;
  processed[nod] = true;

  FR( i, (int) in[nod].size() ) {
    int parinte = in[nod][i];
    if( !processed[parinte] ) {
      comp[comp.size()-1].PB( parinte );
      componenta[parinte] = comp.size() - 1;
      dfs2( parinte );
    }
  }
}


int main()
{
    int m, u, v, nr_comp, nod, comp_crt;
    cin >> n >> m;

    FR( i, m ) {
      cin >> u >> v;
      if( u > 0 )
        u--;
      else
        u = ( -u + n - 1 );
      if( v > 0 )
        v--;
      else
        v = ( -v + n - 1 );
      out[ negare(u) ].PB( v );
      in[v].PB( negare(u) );
      out[negare(v)].PB( u );
      in[u].PB( negare(v) );
    }


    FR( i, 2 * n )
      dfs1( i );
    FR( i, 2 * n )
      processed[i] = false;

    for( int i = cnt; i >= 0; i -- ) {
      int nod = lista[i];
      if( !processed[nod] ) {
        comp.PB( {nod} );
        componenta[nod] = comp.size()-1;
        dfs2( nod );
      }
    }

    nr_comp = comp.size();
    FR( i, nr_comp ) {
      FR( j, (int) comp[i].size() ) {
        nod = comp[i][j];
        FR( l, (int) out[nod].size() ) {
          int copil = out[nod][l];
          if( componenta[copil] != componenta[nod] ) {
            deg_componenta[ componenta[nod] ]++;
            dependenti[ componenta[copil] ].PB( nod );
          }
        }
      }
    }

    FR( i, nr_comp )
      if( deg_componenta[i] == 0 )
        q.push( i );


    while( !q.empty() ) {
      comp_crt = q.front();
      q.pop();
      comp_sortate.PB( comp_crt );

      FR( i, (int) dependenti[comp_crt].size() ) {
        nod = dependenti[comp_crt][i];
        deg_componenta[ componenta[nod] ] --;
        if( deg_componenta[ componenta[nod] ] == 0 )
          q.push( componenta[nod] );
      }
    }


    bool ok = true;
    FR( i, n )
      if( componenta[i] == componenta[ negare(i) ] )
        ok = false;

    if( !ok )
      cout << -1 << '\n';
    else {
      FR( i, 2 * n )
        adevar[i] = true;

      for( int i = 0; i < comp_sortate.size(); i ++ ) {
        comp_crt = comp_sortate[ i ];
        ok = true;
        FR( j, comp[comp_crt].size() ) {
          nod = comp[comp_crt][j];
          if( adevar[nod] == false )
            ok = false;
        }

        if( ok )
          FR( j, comp[comp_crt].size() ) {
            nod = comp[comp_crt][j];
            adevar[ negare(nod) ] = false;
        } else
          FR( j, comp[comp_crt].size() ) {
            nod = comp[comp_crt][j];
            adevar[ nod ] = false;
          }
       }
       FR( i, n )
        if( adevar[i] )
         cout << 1 << " ";
        else
          cout << 0 << " ";
    }

    return 0;
}