class UNION_FIND(object):

    def __init__(self,n):

        self.parent=[-1 for i in range(n)]

        

    def root(self,x):

        if self.parent[x]<0:

            return x

        else:

            self.parent[x]=self.root(self.parent[x])

            return self.parent[x]

 

    def size(self,x):

        return -self.parent[self.root(x)]

    def union(self,x,y):

        x=self.root(x)

        y=self.root(y)

        if x==y:

            return False

        if self.size(x)<self.size(y):

            x,y=y,x

        self.parent[x]+=self.parent[y]  #Aのサイズを更新する

        self.parent[y]=x   #Bの親をAに変更する

        return True



n=int(eval(input()))

u=UNION_FIND(2*n)

for i in range(n-1):

    a,b,c=list(map(int,input().split()))

    if c%2==0:

        u.union(a-1,b-1)

        u.union(a-1+n,b-1+n)

    else:

        u.union(a-1+n,b-1)

        u.union(a-1,b-1+n)

#print(u.parent)

for i in range(n):

    if u.root(i)<n:

        print((1))

    else:

        print((0))
class POTENTIAL_UNION_FIND(object):

    def __init__(self, n):

        self.parent = [-1 for i in range(n)]#非負なら親ノード，負ならグループの要素数

        self.diff_p = [0 for i in range(n)]#親ノードを基準としたポテンシャル

 

    def root(self, x): #root(x): xの根ノードを返す

        if self.parent[x] < 0:

            return x

        else:

            rx = self.root(self.parent[x]) #xをxの根rxに直接つなぎたい

            self.diff_p[x] += self.diff_p[self.parent[x]] #そのために，diff(rx,x)を計算

            self.parent[x] = rx #xをrxに直接つなげる

            return rx

 

    def size(self,x): #size(x): xのいるグループの要素数を返す

        return -self.parent[self.root(x)]



    def merge(self, x, y, dxy): #ポテンシャル差の条件p(y)-p(x)=dxyでxとyのグループをまとめる

        rx = self.root(x) #rxを新たにxと名づける

        ry = self.root(y) #ryを新たにyと名づける

        dxy += self.diff_p[x] - self.diff_p[y] #dxyをdiff(rx,ry)で置き換え

        x,y=rx,ry

        if x == y:

            return False

        if self.parent[x] > self.parent[y]: #xの要素数がyの要素数より「小さい」とき入れ替える

            x,y,dxy=y,x,-dxy

        self.parent[x] += self.parent[y] #xの要素数を更新

        self.parent[y] = x #yをxにつなぐ

        self.diff_p[y] = dxy #yの相対ポテンシャルを更新

        return True

 

    def issame(self, x, y): #issame(x,y): xとyが同じグループにあるならTrue

        return self.root(x) == self.root(y)

        

    def diff(self,x,y): #diff(x,y): xを基準としたyのポテンシャルを返す 

        if self.root(x) == self.root(y): #この時点でxの親はroot(x)

            return self.diff_p[y] - self.diff_p[x]

        else:

            return None



n=int(eval(input()))

u=POTENTIAL_UNION_FIND(n)

for i in range(n-1):

    a,b,c=list(map(int,input().split()))

    u.merge(a-1,b-1,c)

for i in range(n):

    print((u.diff(0,i)%2))
class UNION_FIND(object):
    def __init__(self, n):
        self.parent = [-1 for i in range(n)]

    def root(self, x):
        if self.parent[x] < 0:
            return x
        else:
            self.parent[x] = self.root(self.parent[x])
            return self.parent[x]

    def size(self, x):
        return -self.parent[self.root(x)]

    def union(self, x, y):
        x = self.root(x)
        y = self.root(y)
        if x == y:
            return False
        if self.size(x) < self.size(y):
            x, y = y, x
        self.parent[x] += self.parent[y]  # Aのサイズを更新する
        self.parent[y] = x  # Bの親をAに変更する
        return True


n = int(eval(input()))
u = UNION_FIND(2 * n)
for i in range(n - 1):
    a, b, c = list(map(int, input().split()))
    if c % 2 == 0:
        u.union(a - 1, b - 1)
        u.union(a - 1 + n, b - 1 + n)
    else:
        u.union(a - 1 + n, b - 1)
        u.union(a - 1, b - 1 + n)
# print(u.parent)
for i in range(n):
    if u.root(i) < n:
        print((1))
    else:
        print((0))

class POTENTIAL_UNION_FIND(object):
    def __init__(self, n):
        self.parent = [-1 for i in range(n)]  # 非負なら親ノード，負ならグループの要素数
        self.diff_p = [0 for i in range(n)]  # 親ノードを基準としたポテンシャル

    def root(self, x):  # root(x): xの根ノードを返す
        if self.parent[x] < 0:
            return x
        else:
            rx = self.root(self.parent[x])  # xをxの根rxに直接つなぎたい
            self.diff_p[x] += self.diff_p[self.parent[x]]  # そのために，diff(rx,x)を計算
            self.parent[x] = rx  # xをrxに直接つなげる
            return rx

    def size(self, x):  # size(x): xのいるグループの要素数を返す
        return -self.parent[self.root(x)]

    def merge(self, x, y, dxy):  # ポテンシャル差の条件p(y)-p(x)=dxyでxとyのグループをまとめる
        rx = self.root(x)  # rxを新たにxと名づける
        ry = self.root(y)  # ryを新たにyと名づける
        dxy += self.diff_p[x] - self.diff_p[y]  # dxyをdiff(rx,ry)で置き換え
        x, y = rx, ry
        if x == y:
            return False
        if self.parent[x] > self.parent[y]:  # xの要素数がyの要素数より「小さい」とき入れ替える
            x, y, dxy = y, x, -dxy
        self.parent[x] += self.parent[y]  # xの要素数を更新
        self.parent[y] = x  # yをxにつなぐ
        self.diff_p[y] = dxy  # yの相対ポテンシャルを更新
        return True

    def issame(self, x, y):  # issame(x,y): xとyが同じグループにあるならTrue
        return self.root(x) == self.root(y)

    def diff(self, x, y):  # diff(x,y): xを基準としたyのポテンシャルを返す
        if self.root(x) == self.root(y):  # この時点でxの親はroot(x)
            return self.diff_p[y] - self.diff_p[x]
        else:
            return None


n = int(eval(input()))
u = POTENTIAL_UNION_FIND(n)
for i in range(n - 1):
    a, b, c = list(map(int, input().split()))
    u.merge(a - 1, b - 1, c)
for i in range(n):
    print((u.diff(0, i) % 2))

-class UNION_FIND(object): +class POTENTIAL_UNION_FIND(object): -        self.parent = [-1 for i in range(n)] +        self.parent = [-1 for i in range(n)]  # 非負なら親ノード，負ならグループの要素数 +        self.diff_p = [0 for i in range(n)]  # 親ノードを基準としたポテンシャル -    def root(self, x): +    def root(self, x):  # root(x): xの根ノードを返す -            self.parent[x] = self.root(self.parent[x]) -            return self.parent[x] +            rx = self.root(self.parent[x])  # xをxの根rxに直接つなぎたい +            self.diff_p[x] += self.diff_p[self.parent[x]]  # そのために，diff(rx,x)を計算 +            self.parent[x] = rx  # xをrxに直接つなげる +            return rx -    def size(self, x): +    def size(self, x):  # size(x): xのいるグループの要素数を返す -    def union(self, x, y): -        x = self.root(x) -        y = self.root(y) +    def merge(self, x, y, dxy):  # ポテンシャル差の条件p(y)-p(x)=dxyでxとyのグループをまとめる +        rx = self.root(x)  # rxを新たにxと名づける +        ry = self.root(y)  # ryを新たにyと名づける +        dxy += self.diff_p[x] - self.diff_p[y]  # dxyをdiff(rx,ry)で置き換え +        x, y = rx, ry -        if self.size(x) < self.size(y): -            x, y = y, x -        self.parent[x] += self.parent[y]  # Aのサイズを更新する -        self.parent[y] = x  # Bの親をAに変更する +        if self.parent[x] > self.parent[y]:  # xの要素数がyの要素数より「小さい」とき入れ替える +            x, y, dxy = y, x, -dxy +        self.parent[x] += self.parent[y]  # xの要素数を更新 +        self.parent[y] = x  # yをxにつなぐ +        self.diff_p[y] = dxy  # yの相対ポテンシャルを更新 + +    def issame(self, x, y):  # issame(x,y): xとyが同じグループにあるならTrue +        return self.root(x) == self.root(y) + +    def diff(self, x, y):  # diff(x,y): xを基準としたyのポテンシャルを返す +        if self.root(x) == self.root(y):  # この時点でxの親はroot(x) +            return self.diff_p[y] - self.diff_p[x] +        else: +            return None -u = UNION_FIND(2 * n) +u = POTENTIAL_UNION_FIND(n) -    if c % 2 == 0: -        u.union(a - 1, b - 1) -        u.union(a - 1 + n, b - 1 + n) -    else: -        u.union(a - 1 + n, b - 1) -        u.union(a - 1, b - 1 + n) -# print(u.parent) +    u.merge(a - 1, b - 1, c) -    if u.root(i) < n: -        print((1)) -    else: -        print((0)) +    print((u.diff(0, i) % 2))