{-# LANGUAGE BangPatterns #-}

import Control.Monad
import Data.Maybe
import Data.List (sort, groupBy)
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as M

splitEvery :: Int -> [a] -> [[a]]
splitEvery _ [] = []
splitEvery n xs = as : splitEvery n bs 
     where (as,bs) = splitAt n xs

str :: Maybe Bool -> String                
str (Just True) = "1"
str (Just False) = "0"
str Nothing = undefined

solve :: [Int] -> V.Vector (V.Vector (Int,Bool))
solve [] = undefined
solve (_:rest) = 
    V.fromList grp2
    where 
        arr = sort $ do {
            [u,v,w] <- splitEvery 3 rest;
            [(u-1, v-1, 0 == (w `mod` 2)),(v-1, u-1, 0 == (w `mod` 2))]
        }
        grp = groupBy comp arr
            where 
                 comp (u1,_,_) (u2,_,_) = u1 == u2
        grp2 = map f grp
            where
                f arr_ = V.fromList $ map (\(_,i1,i2) -> (i1,i2)) arr_

solve2 :: V.Vector (V.Vector (Int,Bool)) -> V.Vector (Maybe Bool)
solve2 !v = 
    V.create $ do { 
        ret <- M.replicate count Nothing;
        let solve3 !n !f = do {
            w <- M.read ret n;
            when (isNothing w) $ do {
                M.write ret n (Just f);
                V.forM_ (v V.! n) (\(j,w2) -> do {
                    solve3 j (f == w2)
                });
            }
        } in
        solve3 0 True;
        return ret;
    }
    where 
        count = length v

main :: IO ()    
main = interact $ unlines.map str.V.toList.solve2.solve.map read.words