import scala.io.StdIn

object Main extends App {

  final val nil = -1
  
  case class Node(var parent: Int = -1,var left: Int = -1, var right: Int = -1){
    
    def typeInfo: String = if(parent == -1) {
      "root"
    } else if(left == nil ) {
      "leaf"
    } else {
      "internal node"
    }
    
    def nodeLiteral(depth: Int, sibling: Int, height: Int): String = {
      val degree = (if(left == nil) 0 else 1) + (if(right == nil) 0 else 1)
      s"parent = $parent, sibling = $sibling, degree = $degree, depth = $depth, height = $height, $typeInfo"
    }
    override def toString: String = s"parent = $parent, depth = X, $typeInfo, [child]"
    
  }

  def setDepth(index: Int, cnt: Int): Unit = {
    //println("setDepth:" + index)
    depth(index) = cnt
    if(input(index).right != nil){ 
      setDepth(input(index).right, cnt + 1)
    }
    if(input(index).left != nil){ 
      setDepth(input(index).left, cnt + 1)
    }
  }
  
  def setHeight(index: Int): Int = {
    //println("setDepth:" + index)
    val h1 = if(input(index).right != nil){
      setHeight(input(index).right) + 1
    } else 0
    val h2 = if(input(index).left != nil){
      setHeight(input(index).left) + 1
    } else 0
    height(index) = scala.math.max(h1, h2)
    height(index)
  }
  
  def getChild(index: Int): Array[Int] = (input(index).left, input(index).right) match {
    case (-1,      -1) => Array.empty[Int]
    case (left,    -1) => Array(left)
    case (-1,   right) => Array(right)
    case (left, right) => Array(left, right)
  }
  
  val n = StdIn.readLine().trim.toInt
  val input  = Array.fill[Node](n)(Node())
  val depth  = Array.fill[Int](n)(0)
  val height = Array.fill[Int](n)(0)

  (0 until n).foreach{ _ =>
    val Array(current, left, right) = StdIn.readLine().trim.split(" ").map(_.toInt)
    input(current).left = left
    input(current).right = right
    if(left != nil) input(left).parent = current
    if(right != nil) input(right).parent = current
  }

  var root = nil
  (0 until n).foreach{ i =>
    //println(s"$i:" + input(i))
    if(input(i).parent == nil) root = i
  }
  
  setDepth(root, 0)
  setHeight(root)
  
  (0 until n).foreach{ i =>
    val ch = getChild(i)
    val parent = input(i).parent
    val sibling = if(parent != nil){
      if(input(parent).left == i) input(parent).right
      else input(parent).left
    } else -1
    
    println(s"node $i: " + input(i).nodeLiteral(depth(i), sibling, height(i)))
  }

}
