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 
				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