import scala.collection.mutable.{ListBuffer, Stack}

object Scanner {
  private val buf = new Array[Byte](1024);
  private var ptr = 0;
  private var len = 0

  @inline private def isPrintableChar(c: Int): Boolean = 33 <= c && c <= 126

  @inline private def hasNextByte(): Boolean =
    if (ptr >= len) {
      ptr = 0;
      len = System.in.read(buf);
      len > 0
    } else {
      true
    }

  @inline private def hasNext(): Boolean = {
    while (hasNextByte() && !isPrintableChar(buf(ptr))) ptr += 1
    hasNextByte()
  }

  @inline private def readByte(): Byte =
    if (hasNextByte()) {
      val res = buf(ptr);
      ptr += 1;
      res
    } else {
      -1
    }

  def next(): String = {
    if (!hasNext()) ???
    val sb = new StringBuilder;
    var b = readByte()
    while (isPrintableChar(b)) {
      sb.append(b.toChar);
      b = readByte()
    }
    sb.toString
  }

  def nextInt(): Int = {
    val n = nextLong()
    if (n < Int.MinValue || Int.MaxValue < n) ???
    n.toInt
  }

  def nextLong(): Long = {
    if (!hasNext()) ???
    var minus = false;
    var b = readByte()
    if (b == '-') {
      minus = true;
      b = readByte()
    }

    def go(b: Byte, n: Long = 0): Long =
      if ('0' <= b && b <= '9') {
        go(readByte(), n * 10 + b - '0')
      }
      else if (minus) {
        -n
      } else {
        n
      }

    go(b)
  }

  def nextDouble(): Double = next.toDouble
}

object Main {
  def main(args: Array[String]): Unit = {
    val N = Scanner.nextInt
    case class Edge(to: Int, d: Long)
    val tree = Array.fill[ListBuffer[Edge]](N)(new ListBuffer[Edge]())
    for (_ <- 0 until N - 1) {
      val u = Scanner.nextInt - 1
      val v = Scanner.nextInt - 1
      val w = Scanner.nextLong
      tree(u) :+= Edge(v, w)
      tree(v) :+= Edge(u, w)
    }

    val colorMap = new Array[Long](N)
    val checked = Array.fill[Boolean](N)(false)

    def dfs(node: Int): Unit = {
      val stack = new Stack[(Int, Long)]()
      stack.push((node, 0L))
      checked(node) = true
      while (stack.nonEmpty) {
        val (node, d) = stack.pop
        colorMap(node) = d % 2
        for (edge <- tree(node)) {
          if (!checked(edge.to)) {
            checked(edge.to) = true
            val depth = d + edge.d
            colorMap(edge.to) = depth % 2
            stack.push((edge.to, depth))
          }
        }
      }
    }

    dfs(0)

    val pw = new java.io.PrintWriter(System.out)
    for (i <- 0 until N) pw.println(colorMap(i))
    pw.flush()
  }


}