#include <climits>
#include <vector>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <math.h>
#include <sstream>
#include <string>
using namespace std;

#define MAX 100001
#define NIL -1



void print(vector<int> &v) {
    int n = (int)v.size();

    for (int i = 0; i < n; ++i)
    {
        cout << v[i];
        if(i < n - 1) {
            cout << " ";
        }
    }
    cout << endl;
}




struct node {
    int parent;
    int left_child;    //nodeの一番左の子
    int right_sibling; //nodeの右側の兄弟(子ではないので注意)
};

node T[MAX];


int getDepth(int node_number) {
    //親の番号を取得
    int parent_number = T[node_number].parent;

    //親がないときは終了
    if(parent_number == NIL) {
        return 0;
    }

    //親を伝って根の方向へ登っていく
    int depth = 0;
    while(parent_number != NIL) {
        //1つ上へ登る
        parent_number = T[parent_number].parent;
        depth++;
    }

    return depth;
}

//左側から右側に向かって子を出力する
void printChildren(int node_number) {
    //一番左の子を取得
    int child_number = T[node_number].left_child;

    //子がないときは終了
    if(child_number == NIL) {
        return;
    }

    //右の兄弟がある限り表示を続ける
    while(child_number != NIL) {
        cout << child_number;
        child_number = T[child_number].right_sibling;
        if(child_number != NIL) {
            cout << ", ";
        }
    }
}


//ノードの種類を判定する
void checkType(int node_number) {
    node u = T[node_number];

    //親がないときは　root
    if(u.parent == NIL) {
        cout << "root";
        return;
    }

    //子供がないときは leaf
    if(u.left_child == NIL) {
        cout << "leaf";
        return;
    }

    //rootでもleafでもないときはinternal node
    cout << "internal node";
}


//出力
void out(int node_number) {
    printf("node %d: ", node_number);
    printf("parent = %d, ", T[node_number].parent);
    printf("depth = %d, ", getDepth(node_number));
    checkType(node_number); cout << ", ";

    cout << "[";
    printChildren(node_number);
    cout << "]";

    cout << endl;
}




int main(void) {
    int n;
    cin >> n;

    vector<int> id(n);
    vector<int> k(n);
    vector<vector<int>> c(n);

    //入力
    for (int i = 0; i < n; ++i)
    {
        //ノードidと次数(子の数)
        int node_number;
        int num_of_children;

        // cin >> id[i] >> k[i];
        cin  >> node_number >> num_of_children;
        // printf("id, k : %d, %d\n", node_number, num_of_children);
        id[node_number] = node_number;
        k[node_number] = num_of_children;


        //子
        vector<int> tmp(num_of_children);
        for (int j = 0; j < num_of_children; ++j)
        {
            cin >> tmp[j];
        }
        c[node_number] = tmp;
    }


    //初期化
    for (int i = 0; i < n; ++i)
    {
        node u;
        u.parent = NIL;
        u.left_child = NIL;
        u.right_sibling = NIL;
        T[i] = u;
    }

    //木を作る
    // printf("---- make tree ---\n");
    for (int i = 0; i < n; ++i) {
        //親に左の子を設定
        int node_number = id[i];
        int num_of_children = k[node_number];
        T[node_number].left_child = num_of_children > 0 ? c[node_number][0] : NIL; //左の子の設定
        // printf("  node_number : %d\n", node_number); 

        //子の設定
        // printf("   ---- set children ---\n");
        // printf("      num_of_children : %d\n", num_of_children); 
        for (int j = 0; j < num_of_children; ++j)
        {
            // printf("         child_number : %d\n", c[node_number][j]);
            //右の兄弟の有無
            int right_sibling_number = NIL;
            if(j < num_of_children - 1) { //右に兄弟がいるとき
                right_sibling_number = c[node_number][j+1]; //右の兄弟
            }

            //子の設定
            int child_number = c[node_number][j];
            T[child_number].parent = node_number; //親
            T[child_number].right_sibling = right_sibling_number; //右の兄弟
        }

        // printf("      left_child    : %d\n", T[node_number].left_child);
        // printf("      right_sibling : %d\n", T[node_number].right_sibling);
        // cout << endl;

        // printf("      ----> node_number : 0\n");
        // printChildren(0);
        // cout << endl;
    }

    // printf("----- all nodes ----\n");
    // for (int i = 0; i < n; ++i)
    // {
    //     printf("id : %d\n", i);
    //     printf("     parent        : %d\n", T[i].parent);
    //     printf("     left_child    : %d\n", T[i].left_child);
    //     printf("     right_sibling : %d\n", T[i].right_sibling);
    // }


    // printf("----- print children ----\n");
    // for (int i = 0; i < n; ++i)
    // {
    //     printf("id : %d\n", i);
    //     printf("     ");
    //     printChildren(i);
    // }

    // printf("----- print depth ----\n");
    // for (int i = 0; i < n; ++i)
    // {
    //     printf("id : %d\n", i);
    //     printf("     depth : %d\n", getDepth(i));
    // }

    
    // printf("----- print result ----\n");
    for (int i = 0; i < n; ++i)
    {
        out(i);
    }

    return 0;
}



Measured memory_bytes: 7556