Problem:
Score : 400 points

Problem Statement

We have a tree with N vertices numbered 1 to N.
The i-th edge in the tree connects Vertex u_i and Vertex v_i, and its length is w_i.
Your objective is to paint each vertex in the tree white or black (it is fine to paint all vertices the same color) so that the following condition is satisfied:

For any two vertices painted in the same color, the distance between them is an even number.

Find a coloring of the vertices that satisfies the condition and print it. It can be proved that at least one such coloring exists under the constraints of this problem.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq u_i < v_i \leq N

1 \leq w_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
u_1 v_1 w_1
u_2 v_2 w_2
.
.
.
u_{N - 1} v_{N - 1} w_{N - 1}

Output

Print a coloring of the vertices that satisfies the condition, in N lines.
The i-th line should contain 0 if Vertex i is painted white and 1 if it is painted black.

If there are multiple colorings that satisfy the condition, any of them will be accepted.

Sample Input 1

3
1 2 2
2 3 1

Sample Output 1

0
0
1

Sample Input 2

5
2 5 2
2 3 10
1 3 8
3 4 2

Sample Output 2

1
0
1
0
1

Solution in Fortran (gfortran v4.8.4) (judge verdict: Wrong Answer)

module UF
	implicit none
	private
	type Union_Find
		integer, allocatable :: par(:), rank(:), counter(:)
	end type Union_Find
	public Union_Find, make_Union_Find, unite, UF_size, root,  same
	
	contains
	
	subroutine make_Union_Find(UFty, N)
		integer, intent(in)           :: N
		type(Union_Find), intent(out) :: UFty
		allocate(UFty%par(1:N), UFty%rank(1:N), UFty%counter(1:N))
		call format_Union_Find(UFty, N)
	end subroutine make_Union_Find
	
	subroutine format_Union_Find(UFty, N)
		integer, intent(in)             :: N
		type(Union_Find), intent(inout) :: UFty
		integer :: i
		do i = 1, N
			UFty%par(i) = i
		end do
		UFty%rank    = 0
		UFty%counter = 1
	end subroutine format_Union_Find
	
	subroutine unite(UFty, x, y)
		integer, value                  :: x, y
		type(Union_Find), intent(inout) :: UFty
		x = root(UFty, x)
		y = root(UFty, y)
		if(x == y) return
		if(UFty%rank(x) < UFty%rank(y)) then
			UFty%par(x)     = y
			UFty%counter(y) = UFty%counter(y) + UFty%counter(x)	
		else
			UFty%par(y)     = x
			UFty%counter(x) = UFty%counter(x) + UFty%counter(y)	
			if(UFty%rank(x) == UFty%rank(y)) UFty%rank(x) = UFty%rank(x) + 1
		end if
	end subroutine unite
	
	function UF_size(UFty, x) result(y)
		integer, intent(in)             :: x
		type(Union_Find), intent(inout) :: UFty
		integer :: y
		y = UFty%counter(root(UFty, x))
		return
	end function UF_size
	
	recursive function root(UFty, x) result(root_ans)
		integer, intent(in)             :: x
		type(Union_Find), intent(inout) :: UFty
		integer :: root_ans
		if(UFty%par(x) == x) then
			root_ans = x
			return
		else
			UFty%par(x) = root(UFty, UFty%par(x))
			root_ans    = UFty%par(x)
			return
		end if
	end function root
	
	logical function same(UFty, x, y)
		integer, intent(in) :: x, y
		type(Union_Find), intent(inout) :: UFty
		if(root(UFty, x) == root(UFty, y)) then
			same = .TRUE.
		else
			same = .FALSE. 
		end if
	end function same
end module UF

program main
	use UF
	implicit none
	type(Union_Find) :: X
	integer :: N, i
	integer, allocatable :: u(:), v(:), w(:), ans(:)
	read(*, *) N
	allocate(u(1:N-1), v(1:N-1), w(1:N-1), ans(1:N-1))
	do i = 1, N-1
		read(*, *) u(i), v(i), w(i)
	end  do
	ans = -1
	
	
	call make_Union_Find(X, N)
	do i = 1, N-1
		if(mod(w(i),2) == 0) then
			call unite(X, u(i), v(i))
		end if
	end do
	do i = 1, N-1
		if(mod(w(i),2) == 1) then
			if(ans(root(X, u(i))) == 0) then
				ans(root(X, v(i))) = 1
			else if(ans(root(X, u(i))) == 1) then
				ans(root(X, v(i))) = 0
			else if(ans(root(X, v(i))) == 0) then
				ans(root(X, u(i))) = 1
			else if(ans(root(X, v(i))) == 1) then
				ans(root(X, u(i))) = 0
			else
				ans(root(X, u(i))) = 1
				ans(root(X, v(i))) = 0
			end if
		end if
	end do
	do i = 1, N
		write(*, *) abs(ans(root(X, i)))
	end do
end program main