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

namespace ALDS1_7A{
    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 k = sr.Next<int>();
                var c = sr.Next<int>(k);

                tree.Add(id, c);
            }

            for(var i = 0; i < N; i++){
                var node = tree.Nodes[i];

                var id = node.Id;
                var parent = node.ParentId;
                var depth = node.Depth;
                var type = node.Type;
                var children = string.Join(", ", node.ChildrenId.Select(x => x.ToString()).ToArray());

                Console.WriteLine("node {0}: parent = {1}, depth = {2}, {3}, [{4}]", id, parent, depth, type, children);
            }
            //---------------------------------
        }
    }

    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{
        public int Id;
        public Node Parent;
        public List<Node> Children = new List<Node>();

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

        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(); }
        }

        private int _depth = -1;

        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: 31984