import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;


public class SDA1606917802T3 {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String baris;
        //inisiasi class tree
        Tree folderFile = new Tree();
        while ((baris = in.readLine()) != null) {
            String[] input = baris.split(" ");
            if(input[0].equals("add")) {
                folderFile.add(input[1], input[2]);
            }
            if(input[0].equals("print")){
                folderFile.print(input[1]);
            }
            if(input[0].equals("insert")) {
                String[] file = input[1].split("\\.");
                folderFile.insert(file[0], file[1], Integer.parseInt(input[2]), input[3]);
            }
            if(input[0].equals("remove")) {
                folderFile.remove(input[1]);
            }
            if (input[0].equals("search")) {
                folderFile.printSearch(input[1]);
            }
        }
    }
}
    /**
     * membuat class tree menyimpan root, hashmap berisi folder dan file
     *
     * @author putri
     *
     */
    class Tree {
        private Folder root;
        HashMap<String, Folder> folderMap;
        HashMap<String, ArrayList<File>> fileMap;

        public Tree() {
            //inisiasi root berupa objek Folder
            this.root = new Folder("root", null);
            //membuat dua hashmap untuk menyimpan data nama folder parent sebagai key dan valuenya adalah anaknya
            // menggunakan ArrayList untuk menyimpan file file yg memiliki nama
            this.fileMap = new HashMap<String, ArrayList<File>>();
            this.folderMap = new HashMap<String, Folder>();
            //menaruh root kedalam map pertama kali
            this.folderMap.put("root", root);

        }

        /**
         * memasukkan folder ke dalam tree
         *
         * @param folder
         * @param parent
         */
        public void add(String folder, String parent) {
            Folder newFolder = new Folder(folder, folderMap.get(parent));
            folderMap.get(parent).add(newFolder);
        }

        /**
         * method updateSize berfungsi untung mengupdate size size folder
         *
         * @param folder
         */
        public void updateSize(String folder) {
            Folder target = folderMap.get(folder);

            // membuat size kembali satu agar memudahkan pada saat mengupdate size ketika ada file yang telah dihapus
            target.size = 1;

            if (target.children.size() == 0) {
                for (File file : target.fileSet) {
                    target.size += file.size;
                }
            } else {
                for (Folder folders : target.children) {
                    updateSize(folders.name);
                    target.size += folders.size;
                }
            }
        }

        /**
         * method remove menghapus target apabila file serta menghapus folder berikut
         * dengan anak anaknya jika target merupaka folder
         *
         * @param target
         */
        public void remove(String target) {

            // apabila target berupa Folder
            if (folderMap.containsKey(target)) {
                Folder targetFolder = folderMap.get(target);
                targetFolder.remove();
                targetFolder.parent.children.remove(targetFolder);
                folderMap.remove(targetFolder.name);
                System.out.println("Folder " + targetFolder.name + " removed");
            }

            // apabila target berupa File
            if (fileMap.containsKey(target)) {
                int removedCount = 0;
                for (File files : fileMap.get(target)) {
                    files.parent.fileSet.remove(files);
                    removedCount++;
                }
                fileMap.remove(target);
                System.out.println(removedCount + " File " + target + " removed");
            }
        }


        /**
         * method printSearch dipanggil ketika melakukan fungsi search
         *
         * @param target
         */
        public void printSearch(String target) {
            //membuat treemap yang menyimpan info alur pencarian sama files
            Map<String, Set<String>> path = new TreeMap<String, Set<String>>();
            Map<String, List<String>> files = new TreeMap<String, List<String>>();
            // sebagai inisiasi start awal, semua dari root
            path.put("root", new TreeSet<String>());
            //boolean untuk nentuin apakah file tersebut sudah ditemukan
            boolean ketemu = false;

            // cek apakah fileMap memiliki target didalamnya dan memastikan map file tersebut tidak kosong
            if (fileMap.containsKey(target) && fileMap.get(target).size() != 0) {
                ketemu = true;
                for (File file : fileMap.get(target)) {
                    Folder tempParent = file.parent;
                    if (!files.containsKey(tempParent.name)) {
                        files.put(tempParent.name, new ArrayList<String>());
                    }
                    if (!path.containsKey(tempParent.name)) {
                        path.put(tempParent.name, new TreeSet<String>());
                    }
                    files.get(tempParent.name).add(file.name + "." + file.type);
                    Folder prev = tempParent;
                    tempParent = prev.parent;
                    while (tempParent != null) {
                        if (!path.containsKey(tempParent.name)) {
                            path.put(tempParent.name, new TreeSet<String>());
                        }
                        path.get(tempParent.name).add(prev.name);
                        prev = tempParent;
                        tempParent = prev.parent;
                    }

                }
            }
            // cek apakah dalam FolderMap terdapat target
            if (folderMap.containsKey(target)) {
                ketemu = true;
                Folder tempTarget = folderMap.get(target);
                Folder prev = tempTarget;
                tempTarget = tempTarget.parent;
                while (tempTarget != null) {
                    if (!path.containsKey(tempTarget.name)) {
                        path.put(tempTarget.name, new TreeSet<String>());
                    }
                    path.get(tempTarget.name).add(prev.name);
                    prev = tempTarget;
                    tempTarget = tempTarget.parent;
                }
            }
            // cetak apabila telah ketemu file/foldernya
            if (ketemu) {
                printPath(path, "root", "> ", files);
            }
        }

        /**
         * printPath merupakan method bantuan dari printSearch dengan memakai rekursive
         * dalam melakukan pencarian file
         *
         * @param path
         * @param current
         * @param depth
         * @param files
         */
        public void printPath(Map<String, Set<String>> path, String current, String depth,
            Map<String, List<String>> files) {
            System.out.println(depth + current);
            if (path.containsKey(current)) {
                for (String next : path.get(current)) {
                    printPath(path, next, "  " + depth, files);
                }
            }

            if (files.containsKey(current)) {
                for (String file : files.get(current)) {
                    System.out.println("  " + depth + file);
                }
            }
        }

        /**
         * Method print yang dipanggil ketika fungsi Print dijalankan (tidak dipanggil
         * ketika search karena search memiliki printnya sendiri)
         *
         * @param folder
         */
        public void print(String folder) {
            Folder target = folderMap.get(folder);
            updateSize(folder);
            print(target, 0);
        }

        /**
         * Method bantuan dari print yang sebelumnya, method ini membuat indentasi dari
         * setiap print print file dan folder
         *
         * @param folder
         * @param depth
         */
        public void print(Folder folder, int depth) {
            int indentasi = depth * 2;
            while (indentasi > 0) {
                System.out.print(" ");
                indentasi--;
            }
            System.out.println("> " + folder.name + " " + folder.size);
            if (folder.children.size() == 0) {
                for (File file : folder.fileSet) {
                    int indentasiFile = depth * 2;
                    while (indentasiFile > 0) {
                        System.out.print(" ");
                        indentasiFile--;
                    }
                    System.out.print("  ");
                    System.out.println("> " + file.name + "." + file.type + " " + file.size);
                }
            } else {
                for (Folder folders : folder.children) {
                    print(folders, depth + 1);
                }
            }
        }

        /**
         * Memastikan bahwa setiap file yang dibuat telah di petakan di fileMap
         *
         * @param file
         */
        public void fileMapping(File file) {
            if (!fileMap.containsKey(file.name))
                fileMap.put(file.name, new ArrayList<File>());
                fileMap.get(file.name).add(file);
        }

        /**
         * Method insert file yang dipanggil ketika fungsi insert dijalankan dan akan
         * menjalakan method insert yang terdapat dalam setiap folder
         *
         * @param name
         * @param type
         * @param size
         * @param folder
         */
        public void insert(String name, String type, int size, String folder) {
            Folder target = folderMap.get(folder);
            File newFile = new File(name, type, size, target);
            target.insert(newFile);
        }

        /**
         * class Node yang akan diextends oleh File dan Folder dan mengimplements
         * Comparable
         *
         * @author putri
         *
         */
        class Node implements Comparable<Node> {
            Folder parent;
            String name;
            int size;

            public int compareTo(Node other) {
                if (this.name.compareTo(other.name) == 0) {
                    return this.size - other.size;
                }
                else {
                    return this.name.compareTo(other.name);
                }
            }

            public String getName() {
                return name;
            }
        }

        /**
         * class file yang mengextends note
         * @author putri
         *
         */
        class File extends Node {
            private String type;

            File(String name, String type, int fileSize, Folder parent) {
                this.name = name;
                this.type = type;
                this.size = fileSize;
            }
        }

        /**
         * class folder yg mengextends node
         * @author putri
         *
         */

        class Folder extends Node {
            TreeSet<File> fileSet;
            TreeSet<Folder> children;

            public Folder(String name, Folder parent) {
                this.name = name;
                this.parent = parent;
                fileSet = new TreeSet<File>();
                children = new TreeSet<Folder>();

            }


            /**
             * method Add yang berfungsi untuk menambahkan folder baru ke folder target
             * dan memindahkan file ke folder baru yang menjadi folder anak dari
             * folder target
             *
             * @param newFolder
             */
            public void add(Folder newFolder) {
                if (children.size() == 0) {
                    for (File tempFile : fileSet) {
                        tempFile.parent = newFolder;
                        newFolder.fileSet.add(tempFile);
                    }
                    fileSet.clear();
                    children.add(newFolder);
                } else {
                    children.add(newFolder);
                }
                folderMap.put(newFolder.getName(), newFolder);
            }

            /**
             * Method remove yang akan menghapus anak anak dari folder tersebut ketika
             * dihapus
             */
            public void remove() {
                if (children.size() == 0) {
                    for (File files : fileSet) {
                        fileMap.get(files.name).remove(files);
                    }
                    fileSet.clear();
                } else {
                    for (Folder folders : children) {
                        folders.remove();
                        folderMap.remove(folders.name);
                    }
                    children.clear();
                }
            }

            public boolean insertAllowed(File file, Folder folderPrev) {
                if (children.size() == 0) {
                    if (fileSet.isEmpty()) {
                        file.parent = this;
                        fileSet.add(file);
                        fileMapping(file);
                        System.out.println(file.name + "." + file.type + " added to " + file.parent.name);
                        return true;

                    }
                    if (file.type.equals(fileSet.first().type)) {
                        file.parent = this;
                        fileSet.add(file);
                        fileMapping(file);
                        System.out.println(file.name + "." + file.type + " added to " + file.parent.name);
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    if (folderPrev == null) {
                        Iterator<Folder> folderIterator = children.iterator();
                        while (folderIterator.hasNext()) {
                            if (folderIterator.next().insertAllowed(file, null)) {
                                return true;
                            }
                        }
                        return false;

                    } else {
                        Iterator<Folder> tailFolderIterator = children.tailSet(folderPrev, false).iterator();
                        while (tailFolderIterator.hasNext()) {
                            if (tailFolderIterator.next().insertAllowed(file, null))
                                return true;
                        }
                        Iterator<Folder> headFolderIterator = children.headSet(folderPrev, false).iterator();
                        while (headFolderIterator.hasNext()) {
                            if (headFolderIterator.next().insertAllowed(file, null))
                                return true;
                        }
                        return false;
                    }
                }
            }

            public void insert(File newFile) {
                boolean check = this.insertAllowed(newFile, null);
                Folder folderCheck = this;
                while (!check) {
                    if (folderCheck.parent == null) {
                        break;
                    }
                    check = folderCheck.parent.insertAllowed(newFile, folderCheck);
                    folderCheck = folderCheck.parent;

                }
            }
        }
    }