module Main where

import Data.List
import Control.Monad
import Debug.Trace
import qualified Data.Vector.Mutable as MV
import Control.Monad.ST (runST)

matrixRead v x y = MV.read v x >>= \v' -> MV.read v' y
matrixWrite v x y val = MV.read v x >>= \v' -> MV.write v' y val

solve :: Int -> [(Int, Int, Int)] -> [Int]
solve n [] = [undefined]
solve n ((root, target, distance) : routes) = runST $ do
    distantVec <- MV.replicateM n (MV.replicate n Nothing)
    distantFromRootVec <- MV.replicate n Nothing
    MV.write distantFromRootVec (root - 1) (Just 0)
    MV.write distantFromRootVec (target - 1) (Just target)
    matrixWrite distantVec (root - 1)  (target - 1) (Just distance)
    matrixWrite distantVec (target - 1) (root - 1) (Just distance)
    forM_ routes $ \(from, to, distance) -> do
        matrixWrite distantVec (from - 1)  (to - 1) (Just distance)
        matrixWrite distantVec (to - 1)  (from - 1)  (Just distance)
    let getDistantFromRoot from accumDistance = 
            forM_ [1..n] $ \to ->  do
                    distToTo <- MV.read distantFromRootVec to
                    case distToTo of
                        Nothing-> do
                            distance <- matrixRead distantVec (from - 1) (to - 1)
                            case distance of
                                Nothing -> pure ()
                                Just dist -> do
                                    MV.write distantFromRootVec (to - 1) $ Just (accumDistance + dist)
                                    getDistantFromRoot to (accumDistance + dist) 
                        Just n -> pure ()
    getDistantFromRoot root 0 
    forM [0..n-1] $ \i -> do
        dist <- MV.read distantFromRootVec i
        case dist of
            Nothing -> undefined
            Just j -> pure $ if even j then 0 else 1

    

readTuple2 :: IO (Int, Int)
readTuple2 = do
    [a, b] <- words <$> getLine
    return (read a, read b)

readTuple3 :: IO (Int, Int, Int)
readTuple3 = do
    [a, b, c] <- words <$> getLine
    return (read a, read b, read c)

main = do
    n <- readLn
    routes <- replicateM (n - 1) readTuple3
    forM_ (solve n routes) print 
