#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstring>
#include <ctime>
#include <bitset>
#include <deque>
#include <fstream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>

using namespace std;

typedef bool int01;
typedef char cha08;
typedef short int int16;
typedef int int32;
typedef float rea32;
typedef long long int int64;
typedef double rea64;

const cha08 Input[] = "andrei.in";
const cha08 Output[] = "andrei.out";

ifstream fin( Input );
ofstream fout( Output );

const int32 Dim = 100001;
const int32 Max = 10001;

char s[Max];
int32 N, M;
int32 cnt, g[Dim], cc[Dim], gg[Dim];
queue <int32> q;
vector <int32> gA, gB, va[Dim], vr[Dim], vv[Dim], comp[Dim];

void DF( int32 nod ) {

    vector <int32> :: iterator it;

    cc[nod] = cc[0];
    comp[cc[0]].push_back( nod );

    for( it = vv[nod].begin(); it != vv[nod].end(); ++it )
        if( !cc[*it] )
            DF( *it );
}

inline void read( int32 &val ) {

    while( s[cnt] < '0' || s[cnt] > '9' )
        if( ++cnt == Max ) {

            fin.read( s, Max );
            cnt = 0;
        }

    val = 0;
    while( s[cnt] >= '0' && s[cnt] <= '9' ) {

        val = val * 10 + s[cnt] - '0';
        if( ++cnt == Max ) {

            fin.read( s, Max );
            cnt = 0;
        }
    }
}

int32 main() {

    int01 ok;
    int32 i, j, c, x, y;
    vector <int32> :: iterator it;

    srand( time( 0 ) );
    cnt = Max - 1;

    read( N );
    read( M );

    while( M-- ) {

        read( x );
        read( y );
        read( c );

        switch( c ) {

            case 0:
                va[x].push_back( y );
                va[y].push_back( x );
                break;
            case 1:
                vr[x].push_back( y );
                vr[y].push_back( x );
                break;
            case 2:
                vv[x].push_back( y );
                vv[y].push_back( x );
                break;
        }
    }

    for( i = 1; i <= N; ++i )
        if( !cc[i] ) {

            ++cc[0];
            DF( i );
        }

//    for( int32 i = 1; i <= N; ++i )
//        fout << cc[i] << "\n";

//    for( int32 i = 1; i <= cc[0]; ++i, fout << "\n" )
//        for( int32 j = 0; j < (int32) comp[i].size(); ++j )
//            fout << comp[i][j] << " ";

    for( i = 1; i <= cc[0]; ++i )
        for( j = 0; j < (int32) comp[i].size(); ++j ) {

            if( !va[comp[i][j]].empty() )
                for( it = va[comp[i][j]].begin(); it != va[comp[i][j]].end(); ++it )
                    if( cc[*it] == i ) {

                        gB.push_back( i );
                        g[i] = 2;
                        j = (int32) comp[i].size();
                        break;
                    }
            if( j < (int32) comp[i].size() && !vr[comp[i][j]].empty() )
                for( it = vr[comp[i][j]].begin(); it != vr[comp[i][j]].end(); ++it )
                    if( cc[*it] == i ) {

                        gA.push_back( i );
                        g[i] = 1;
                        j = (int32) comp[i].size();
                        break;
                    }
        }

//    for( int32 i = 0; i < (int32) gA.size(); ++i )
//        fout << gA[i] << " ";
//    fout << "\n";
//    for( int32 i = 0; i < (int32) gB.size(); ++i )
//        fout << gB[i] << " ";

    for( i = 1; i <= cc[0]; ++i )
        if( g[i] )
            q.push( i );

    do {

        while( !q.empty() ) {

            c = q.front();
            q.pop();

            if( g[c] == 1 )
                for( i = 0; i < (int32) comp[c].size(); ++i )
                    for( it = va[comp[c][i]].begin(); it != va[comp[c][i]].end(); ++it )
                        if( !g[cc[*it]] ) {

                            g[cc[*it]] = 2;
                            q.push( cc[*it] );
                        }
            if( g[c] == 2 )
                for( i = 0; i < (int32) comp[c].size(); ++i )
                    for( it = vr[comp[c][i]].begin(); it != vr[comp[c][i]].end(); ++it )
                        if( !g[cc[*it]] ) {

                            g[cc[*it]] = 1;
                            q.push( cc[*it] );
                        }
        }

        for( i = 1, ok = false; i <= cc[0]; ++i )
            if( !g[i] ) {

                g[i] = rand() % 2 + 1;
                q.push( i );
                ok = true;
                break;
            }
    }
    while( ok == true );

//    for( i = 1; i <= cc[0]; ++i )
//        fout << g[i] << " ";

    for( i = 1; i <= cc[0]; ++i )
        for( j = 0; j < (int32) comp[i].size(); ++j )
            gg[comp[i][j]] = g[i] - 1;

    for( i = 1; i <= N; ++i )
        fout << gg[i] << " ";

    fin.close();
    fout.close();

    return 0;
}