using System;
using System.Collections.Generic;
using System.Linq;

namespace ALDS1_7B{
    public class Program{
        public static void Main(string[] args){
            var sr = new StreamReader();
            //---------------------------------
            var N = sr.Next<int>();
            var tree = new Tree(N);

            for(var i = 0; i < N; i++){
                var id = sr.Next<int>();
                var children = sr.Next<int>(2).Where(x => x != -1).ToArray();

                tree.Add(id, children);
            }

            foreach(var node in tree.Nodes){
                Console.Write("node {0}: ", node.Id);
                Console.Write("parent = {0}, ", node.ParentId);
                Console.Write("sibling = {0}, ", node.SiblingId.DefaultIfEmpty(-1).First());
                Console.Write("degree = {0}, ", node.Children.Count);
                Console.Write("depth = {0}, ", node.Depth);
                Console.Write("height = {0}, ", node.Height);
                Console.Write("{0}", node.Type);
                Console.WriteLine();
            }
            //---------------------------------
        }
    }

    public class Tree{
        public readonly Node[] Nodes;

        public Tree(int cap){
            Nodes = new Node[cap];
            for(var i = 0; i < cap; i++){
                Nodes[i] = new Node(i);
            }
        }

        public void Add(int id, int[] children){
            foreach(var child in children){
                Nodes[id].Children.Add(Nodes[child]);
                Nodes[child].Parent = Nodes[id];
            }
        }
    }

    public class Node{
        private static int NIL = -1;
        public int Id;
        public Node Parent;
        public List<Node> Children = new List<Node>();

        public int Depth{
            get{
                if(Parent == null) return 0;
                if(_depth != NIL) return _depth;
                return _depth = Parent.Depth + 1;
            }
        }

        public int Height{
            get{
                if(Children.Count == 0) return 0;
                if(_height != NIL) return _height;
                return _height = Children.Max(n => n.Height) + 1;
            }
        }

        public string Type{
            get{
                if(Parent == null) return "root";
                if(Children.Count == 0) return "leaf";
                return "internal node";
            }
        }

        public int ParentId{
            get{
                if(Parent == null) return -1;
                return Parent.Id;
            }
        }

        public int[] ChildrenId{
            get { return Children.Select(n => n.Id).ToArray(); }
        }

        public int[] SiblingId{
            get{
                if(Parent == null) return new int[]{};
                return Parent.ChildrenId.Where(x => x != Id).ToArray();
            }
        }

        private int _depth = NIL;
        private int _height = NIL;

        public Node(int id){
            Id = id;
        }
    }

    public class StreamReader{
        private readonly char[] _c = {' '};
        private int _index = -1;
        private string[] _input = new string[0];

        public T Next<T>(){
            if(_index == _input.Length - 1){
                _index = -1;
                while(true){
                    string rl = Console.ReadLine();
                    if(rl == null){
                        if(typeof(T).IsClass) return default(T);
                        return (T)typeof(T).GetField("MinValue").GetValue(null);
                    }
                    if(rl != ""){
                        _input = rl.Split(_c, StringSplitOptions.RemoveEmptyEntries);
                        break;
                    }
                }
            }
            return (T)Convert.ChangeType(_input[++_index], typeof(T), System.Globalization.CultureInfo.InvariantCulture);
        }

        public T[] Next<T>(int x){
            var ret = new T[x];
            for(var i = 0; i < x; ++i) ret[i] = Next<T>();
            return ret;
        }

        public T[][] Next<T>(int y, int x){
            var ret = new T[y][];
            for(var i = 0; i < y; ++i) ret[i] = Next<T>(x);
            return ret;
        }
    }
}

Measured memory_bytes: 10232