#include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <array>
#include <memory>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <stdexcept>


using std::string;
using std::vector;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf("%d", list[i]);
        if(i != list.size() -1){
            printf(" ");
        }
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Node;
using Container = std::map<int, std::shared_ptr<Node>>;
class Node{
private:
    Container *container;
    int id;
    int parentId;
    vector<int> childIds;
public:
    Node(Container* container, int id, const vector<int>&& childIds)
        : container(container)
        , id(id)
        , childIds(childIds)
        , parentId(-1)
    {
    }
    int Id(){
        return this->id;
    }
    int ParentId(){
        return this->parentId;
    }
    void ParentId(int id){
        this->parentId = id;
    }
    std::shared_ptr<Node> Parent(){
        if(this->parentId == -1) return nullptr;
        return (*this->container)[this->parentId];
    }
    int Depth(){
        if(this->parentId == -1){
            return 0;
        }else{
            return this->Parent()->Depth() + 1;
        }
    }
    string Type(){
        if(this->parentId == -1){
            return "root";
        }
        if(this->childIds.empty()){
            return "leaf";
        }else{
            return "internal node";
        }
    }
    string Child(){
        string result = "";
        for(int i = 0; i < this->childIds.size(); i++){
            result += std::to_string(childIds[i]);
            if(i != this->childIds.size() -1) result += ", ";
        }
        return result;
    }
    vector<int>ChildIds(){
        return this->childIds;
    }

};

void solve() {
    int n;
    scanf("%d", &n);
    Container container;
    for(int i = 0; i < n; i++){
        int id;
        scanf("%d", &id);
        int k;
        scanf("%d", &k);
        vector<int> child;
        for(int j = 0; j < k; j++){
            int cid;
            scanf("%d", &cid);
            child.push_back(cid);
        }
        auto node = std::make_shared<Node>(&container, id, std::move(child));
        container.insert(std::make_pair(id, node));
    }
    // set parent
    for(auto& each: container){
        for(int id: each.second->ChildIds()){
            (*container[id]).ParentId(each.first);
        }
    }
    for(auto each: container){
        printf("node %d: parent = %d, depth = %d, %s, [%s]\n", 
        each.first,
        each.second->ParentId(),
        each.second->Depth(),
        each.second->Type().c_str(),
        each.second->Child().c_str());
    }
    
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
    solve();
    return 0;
}


Measured memory_bytes: 17300