#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;

//#define int long long
//using ll = boost::multiprecision::cpp_int;
using ll = long long;
//const int INF = 1e9;//INT_MAX=1<<31-1=2147483647
const ll INF = (ll)1e18;//1<<63-1=9223372036854775807
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
#ifdef LOCAL_ENV
	#define debug(var) std::cout<<#var" = "<<var<<std::endl
#else
	#define debug(var)
#endif
#define p(var) std::cout<<var<<std::endl
#define PI (acos(-1))
#define rep(i, n)   for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define all(a) (a).begin(), (a).end()
#define pb push_back
inline bool isnatural(double a) { return a>=0 && ceil(a)==floor(a); }
template<typename T> inline T gcd(T a, T b) { return b ? gcd(b,a%b) : a; }
template<typename T> inline T lcm(T a, T b) { return a / gcd(a,  b) * b; }
template<typename T1, typename T2>inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template<typename T1, typename T2>inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << ", " << p.second << ")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
	for (int i = 0, len = v.size(); i < len; ++i){
		s << v[i]; if (i < len - 1) s << "\t";
	}
	return s;
}
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
	for (int i = 0, len = vv.size(); i < len; ++i){
		s << vv[i] << endl;
	}
	return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s, const map<T1, T2>& m) {
	s << "{" << endl;
	for (typeof(m.begin()) itr = m.begin(); itr != m.end(); ++itr){
		s << "\t" << (*itr).first << " : " << (*itr).second << endl;
	}
	s << "}" << endl;
	return s;
}

/*-----8<-----8<-----*/

class UnionFind {
public:
	vector<int> v;
	vector<int> diff_weight;
	UnionFind(size_t size) : v(size, -1), diff_weight(size, 0) {}

	int root(int x) {
		if (v[x] < 0) {
			return x;
		} else {
            int r = root(v[x]);
            diff_weight[x] += diff_weight[v[x]];
            return v[x] = r;
		}
	}

	bool is_root(int x) {
		return x == root(x);
	}

	bool is_same(int x, int y) {
		return root(x) == root(y);
	}

	int weight(int x) {
		root(x);
		return diff_weight[x];
	}

	//weight(y) = weight(x) + w / xが親
	bool unite(int x, int y, int w) {
		w += weight(x);
		w -= weight(y);
		x = root(x);
		y = root(y);
		if (x == y) return false;
		if (v[x] > v[y]) swap(x, y);
		v[x] += v[y];
		v[y] = x;
		diff_weight[y] = w;
		return true;
	}

	int size(int x) {
		return -v[root(x)];
	}

	int diff(int x, int y) {
		return weight(y) - weight(x);
	}
};

class Edge{
public:
	ll u,v,w;
};
const ll N_MAX = 100000;
const ll W_I_MAX = 1000000000;

ll N;

vector<Edge> v;

void input() {
	scanf("%lld", &N);
 
	v=vector<Edge>(N-1,Edge());
 
	rep(i, N-1){
		cin >>v[i].u>>v[i].v>>v[i].w;
		v[i].u--;v[i].v--;
	}
 
}
 

void solve() {
	UnionFind tree=UnionFind(N);
	rep(i,N-1){
		tree.unite(v[i].u,v[i].v,v[i].w);
	}

	int root=tree.root(0);
	rep(i,N){
		int d=tree.diff(root,i);
		if(d%2==0)p(1);
		else p(0);
	}

}
 
signed main() {
	input();
	solve();
	return 0;
}


Measured memory_bytes: 3584